{"version":3,"file":"47b342e8a83d12e12d5b3febff65bfe8e1d8cae4-d871279d56b0df04eb26.js","mappings":"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","sources":["webpack://mch/./node_modules/@babel/runtime/helpers/construct.js","webpack://mch/./node_modules/@babel/runtime/helpers/inherits.js","webpack://mch/./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/byte-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/codecs.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/mp4-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/opus-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/ebml-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/nal-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/containers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/id3-helpers.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/media-types.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/resolve-url.js","webpack://mch/./node_modules/@videojs/xhr/lib/http-handler.js","webpack://mch/./node_modules/@videojs/xhr/lib/index.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/conventions.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/dom-parser.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/dom.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/entities.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/index.js","webpack://mch/./node_modules/@xmldom/xmldom/lib/sax.js","webpack://mch/./node_modules/global/document.js","webpack://mch/./node_modules/global/window.js","webpack://mch/./node_modules/is-function/index.js","webpack://mch/./node_modules/keycode/index.js","webpack://mch/./node_modules/@videojs/vhs-utils/es/stream.js","webpack://mch/./node_modules/m3u8-parser/dist/m3u8-parser.es.js","webpack://mch/./node_modules/mpd-parser/dist/mpd-parser.es.js","webpack://mch/./node_modules/mux.js/lib/tools/parse-sidx.js","webpack://mch/./node_modules/mux.js/lib/utils/clock.js","webpack://mch/./node_modules/safe-json-parse/tuple.js","webpack://mch/./node_modules/url-toolkit/src/url-toolkit.js","webpack://mch/./node_modules/videojs-vtt.js/lib/browser-index.js","webpack://mch/./node_modules/videojs-vtt.js/lib/vtt.js","webpack://mch/./node_modules/videojs-vtt.js/lib/vttcue.js","webpack://mch/./node_modules/videojs-vtt.js/lib/vttregion.js","webpack://mch/./src/components/video/freeVideo.js","webpack://mch/./node_modules/videojs-hls-quality-selector/dist/videojs-hls-quality-selector.es.js","webpack://mch/./node_modules/videojs-contrib-quality-levels/dist/videojs-contrib-quality-levels.es.js","webpack://mch/./src/components/video/video.js"],"sourcesContent":["var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\n\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct;\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nmodule.exports = _construct;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nmodule.exports = _isNativeReflectConstruct;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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; // eslint-disable-next-line\n\n\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;","\"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() {}","'use strict';\n/**\n * \"Shallow freezes\" an object to render it immutable.\n * Uses `Object.freeze` if available,\n * otherwise the immutability is only in the type.\n *\n * Is used to create \"enum like\" objects.\n *\n * @template T\n * @param {T} object the object to freeze\n * @param {Pick<ObjectConstructor, 'freeze'> = Object} oc `Object` by default,\n * \t\t\t\tallows to inject custom object constructor for tests\n * @returns {Readonly<T>}\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\n */\n\nfunction freeze(object, oc) {\n  if (oc === undefined) {\n    oc = Object;\n  }\n\n  return oc && typeof oc.freeze === 'function' ? oc.freeze(object) : object;\n}\n/**\n * All mime types that are allowed as input to `DOMParser.parseFromString`\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN\n * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec\n * @see DOMParser.prototype.parseFromString\n */\n\n\nvar MIME_TYPE = freeze({\n  /**\n   * `text/html`, the only mime type that triggers treating an XML document as HTML.\n   *\n   * @see DOMParser.SupportedType.isHTML\n   * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n   * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n   * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec\n   */\n  HTML: 'text/html',\n\n  /**\n   * Helper method to check a mime type if it indicates an HTML document\n   *\n   * @param {string} [value]\n   * @returns {boolean}\n   *\n   * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration\n   * @see https://en.wikipedia.org/wiki/HTML Wikipedia\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN\n   * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring \t */\n  isHTML: function isHTML(value) {\n    return value === MIME_TYPE.HTML;\n  },\n\n  /**\n   * `application/xml`, the standard mime type for XML documents.\n   *\n   * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration\n   * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303\n   * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n   */\n  XML_APPLICATION: 'application/xml',\n\n  /**\n   * `text/html`, an alias for `application/xml`.\n   *\n   * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303\n   * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration\n   * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia\n   */\n  XML_TEXT: 'text/xml',\n\n  /**\n   * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,\n   * but is parsed as an XML document.\n   *\n   * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration\n   * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec\n   * @see https://en.wikipedia.org/wiki/XHTML Wikipedia\n   */\n  XML_XHTML_APPLICATION: 'application/xhtml+xml',\n\n  /**\n   * `image/svg+xml`,\n   *\n   * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration\n   * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1\n   * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia\n   */\n  XML_SVG_IMAGE: 'image/svg+xml'\n});\n/**\n * Namespaces that are used in this code base.\n *\n * @see http://www.w3.org/TR/REC-xml-names\n */\n\nvar NAMESPACE = freeze({\n  /**\n   * The XHTML namespace.\n   *\n   * @see http://www.w3.org/1999/xhtml\n   */\n  HTML: 'http://www.w3.org/1999/xhtml',\n\n  /**\n   * Checks if `uri` equals `NAMESPACE.HTML`.\n   *\n   * @param {string} [uri]\n   *\n   * @see NAMESPACE.HTML\n   */\n  isHTML: function isHTML(uri) {\n    return uri === NAMESPACE.HTML;\n  },\n\n  /**\n   * The SVG namespace.\n   *\n   * @see http://www.w3.org/2000/svg\n   */\n  SVG: 'http://www.w3.org/2000/svg',\n\n  /**\n   * The `xml:` namespace.\n   *\n   * @see http://www.w3.org/XML/1998/namespace\n   */\n  XML: 'http://www.w3.org/XML/1998/namespace',\n\n  /**\n   * The `xmlns:` namespace\n   *\n   * @see https://www.w3.org/2000/xmlns/\n   */\n  XMLNS: 'http://www.w3.org/2000/xmlns/'\n});\nexports.freeze = freeze;\nexports.MIME_TYPE = MIME_TYPE;\nexports.NAMESPACE = NAMESPACE;","var conventions = require(\"./conventions\");\n\nvar dom = require('./dom');\n\nvar entities = require('./entities');\n\nvar sax = require('./sax');\n\nvar DOMImplementation = dom.DOMImplementation;\nvar NAMESPACE = conventions.NAMESPACE;\nvar ParseError = sax.ParseError;\nvar XMLReader = sax.XMLReader;\n\nfunction DOMParser(options) {\n  this.options = options || {\n    locator: {}\n  };\n}\n\nDOMParser.prototype.parseFromString = function (source, mimeType) {\n  var options = this.options;\n  var sax = new XMLReader();\n  var domBuilder = options.domBuilder || new DOMHandler(); //contentHandler and LexicalHandler\n\n  var errorHandler = options.errorHandler;\n  var locator = options.locator;\n  var defaultNSMap = options.xmlns || {};\n  var isHTML = /\\/x?html?$/.test(mimeType); //mimeType.toLowerCase().indexOf('html') > -1;\n\n  var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;\n\n  if (locator) {\n    domBuilder.setDocumentLocator(locator);\n  }\n\n  sax.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);\n  sax.domBuilder = options.domBuilder || domBuilder;\n\n  if (isHTML) {\n    defaultNSMap[''] = NAMESPACE.HTML;\n  }\n\n  defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;\n\n  if (source && typeof source === 'string') {\n    sax.parse(source, defaultNSMap, entityMap);\n  } else {\n    sax.errorHandler.error(\"invalid doc source\");\n  }\n\n  return domBuilder.doc;\n};\n\nfunction buildErrorHandler(errorImpl, domBuilder, locator) {\n  if (!errorImpl) {\n    if (domBuilder instanceof DOMHandler) {\n      return domBuilder;\n    }\n\n    errorImpl = domBuilder;\n  }\n\n  var errorHandler = {};\n  var isCallback = errorImpl instanceof Function;\n  locator = locator || {};\n\n  function build(key) {\n    var fn = errorImpl[key];\n\n    if (!fn && isCallback) {\n      fn = errorImpl.length == 2 ? function (msg) {\n        errorImpl(key, msg);\n      } : errorImpl;\n    }\n\n    errorHandler[key] = fn && function (msg) {\n      fn('[xmldom ' + key + ']\\t' + msg + _locator(locator));\n    } || function () {};\n  }\n\n  build('warning');\n  build('error');\n  build('fatalError');\n  return errorHandler;\n} //console.log('#\\n\\n\\n\\n\\n\\n\\n####')\n\n/**\n * +ContentHandler+ErrorHandler\n * +LexicalHandler+EntityResolver2\n * -DeclHandler-DTDHandler\n *\n * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler\n * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2\n * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html\n */\n\n\nfunction DOMHandler() {\n  this.cdata = false;\n}\n\nfunction position(locator, node) {\n  node.lineNumber = locator.lineNumber;\n  node.columnNumber = locator.columnNumber;\n}\n/**\n * @see org.xml.sax.ContentHandler#startDocument\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html\n */\n\n\nDOMHandler.prototype = {\n  startDocument: function startDocument() {\n    this.doc = new DOMImplementation().createDocument(null, null, null);\n\n    if (this.locator) {\n      this.doc.documentURI = this.locator.systemId;\n    }\n  },\n  startElement: function startElement(namespaceURI, localName, qName, attrs) {\n    var doc = this.doc;\n    var el = doc.createElementNS(namespaceURI, qName || localName);\n    var len = attrs.length;\n    appendElement(this, el);\n    this.currentElement = el;\n    this.locator && position(this.locator, el);\n\n    for (var i = 0; i < len; i++) {\n      var namespaceURI = attrs.getURI(i);\n      var value = attrs.getValue(i);\n      var qName = attrs.getQName(i);\n      var attr = doc.createAttributeNS(namespaceURI, qName);\n      this.locator && position(attrs.getLocator(i), attr);\n      attr.value = attr.nodeValue = value;\n      el.setAttributeNode(attr);\n    }\n  },\n  endElement: function endElement(namespaceURI, localName, qName) {\n    var current = this.currentElement;\n    var tagName = current.tagName;\n    this.currentElement = current.parentNode;\n  },\n  startPrefixMapping: function startPrefixMapping(prefix, uri) {},\n  endPrefixMapping: function endPrefixMapping(prefix) {},\n  processingInstruction: function processingInstruction(target, data) {\n    var ins = this.doc.createProcessingInstruction(target, data);\n    this.locator && position(this.locator, ins);\n    appendElement(this, ins);\n  },\n  ignorableWhitespace: function ignorableWhitespace(ch, start, length) {},\n  characters: function characters(chars, start, length) {\n    chars = _toString.apply(this, arguments); //console.log(chars)\n\n    if (chars) {\n      if (this.cdata) {\n        var charNode = this.doc.createCDATASection(chars);\n      } else {\n        var charNode = this.doc.createTextNode(chars);\n      }\n\n      if (this.currentElement) {\n        this.currentElement.appendChild(charNode);\n      } else if (/^\\s*$/.test(chars)) {\n        this.doc.appendChild(charNode); //process xml\n      }\n\n      this.locator && position(this.locator, charNode);\n    }\n  },\n  skippedEntity: function skippedEntity(name) {},\n  endDocument: function endDocument() {\n    this.doc.normalize();\n  },\n  setDocumentLocator: function setDocumentLocator(locator) {\n    if (this.locator = locator) {\n      // && !('lineNumber' in locator)){\n      locator.lineNumber = 0;\n    }\n  },\n  //LexicalHandler\n  comment: function comment(chars, start, length) {\n    chars = _toString.apply(this, arguments);\n    var comm = this.doc.createComment(chars);\n    this.locator && position(this.locator, comm);\n    appendElement(this, comm);\n  },\n  startCDATA: function startCDATA() {\n    //used in characters() methods\n    this.cdata = true;\n  },\n  endCDATA: function endCDATA() {\n    this.cdata = false;\n  },\n  startDTD: function startDTD(name, publicId, systemId) {\n    var impl = this.doc.implementation;\n\n    if (impl && impl.createDocumentType) {\n      var dt = impl.createDocumentType(name, publicId, systemId);\n      this.locator && position(this.locator, dt);\n      appendElement(this, dt);\n      this.doc.doctype = dt;\n    }\n  },\n\n  /**\n   * @see org.xml.sax.ErrorHandler\n   * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html\n   */\n  warning: function warning(error) {\n    console.warn('[xmldom warning]\\t' + error, _locator(this.locator));\n  },\n  error: function error(_error) {\n    console.error('[xmldom error]\\t' + _error, _locator(this.locator));\n  },\n  fatalError: function fatalError(error) {\n    throw new ParseError(error, this.locator);\n  }\n};\n\nfunction _locator(l) {\n  if (l) {\n    return '\\n@' + (l.systemId || '') + '#[line:' + l.lineNumber + ',col:' + l.columnNumber + ']';\n  }\n}\n\nfunction _toString(chars, start, length) {\n  if (typeof chars == 'string') {\n    return chars.substr(start, length);\n  } else {\n    //java sax connect width xmldom on rhino(what about: \"? && !(chars instanceof String)\")\n    if (chars.length >= start + length || start) {\n      return new java.lang.String(chars, start, length) + '';\n    }\n\n    return chars;\n  }\n}\n/*\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html\n * used method of org.xml.sax.ext.LexicalHandler:\n *  #comment(chars, start, length)\n *  #startCDATA()\n *  #endCDATA()\n *  #startDTD(name, publicId, systemId)\n *\n *\n * IGNORED method of org.xml.sax.ext.LexicalHandler:\n *  #endDTD()\n *  #startEntity(name)\n *  #endEntity(name)\n *\n *\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html\n * IGNORED method of org.xml.sax.ext.DeclHandler\n * \t#attributeDecl(eName, aName, type, mode, value)\n *  #elementDecl(name, model)\n *  #externalEntityDecl(name, publicId, systemId)\n *  #internalEntityDecl(name, value)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html\n * IGNORED method of org.xml.sax.EntityResolver2\n *  #resolveEntity(String name,String publicId,String baseURI,String systemId)\n *  #resolveEntity(publicId, systemId)\n *  #getExternalSubset(name, baseURI)\n * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html\n * IGNORED method of org.xml.sax.DTDHandler\n *  #notationDecl(name, publicId, systemId) {};\n *  #unparsedEntityDecl(name, publicId, systemId, notationName) {};\n */\n\n\n\"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl\".replace(/\\w+/g, function (key) {\n  DOMHandler.prototype[key] = function () {\n    return null;\n  };\n});\n/* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */\n\nfunction appendElement(hander, node) {\n  if (!hander.currentElement) {\n    hander.doc.appendChild(node);\n  } else {\n    hander.currentElement.appendChild(node);\n  }\n} //appendChild and setAttributeNS are preformance key\n\n\nexports.__DOMHandler = DOMHandler;\nexports.DOMParser = DOMParser;\n/**\n * @deprecated Import/require from main entry point instead\n */\n\nexports.DOMImplementation = dom.DOMImplementation;\n/**\n * @deprecated Import/require from main entry point instead\n */\n\nexports.XMLSerializer = dom.XMLSerializer;","var conventions = require(\"./conventions\");\n\nvar NAMESPACE = conventions.NAMESPACE;\n/**\n * A prerequisite for `[].filter`, to drop elements that are empty\n * @param {string} input\n * @returns {boolean}\n */\n\nfunction notEmptyString(input) {\n  return input !== '';\n}\n/**\n * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace\n * @see https://infra.spec.whatwg.org/#ascii-whitespace\n *\n * @param {string} input\n * @returns {string[]} (can be empty)\n */\n\n\nfunction splitOnASCIIWhitespace(input) {\n  // U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, U+0020 SPACE\n  return input ? input.split(/[\\t\\n\\f\\r ]+/).filter(notEmptyString) : [];\n}\n/**\n * Adds element as a key to current if it is not already present.\n *\n * @param {Record<string, boolean | undefined>} current\n * @param {string} element\n * @returns {Record<string, boolean | undefined>}\n */\n\n\nfunction orderedSetReducer(current, element) {\n  if (!current.hasOwnProperty(element)) {\n    current[element] = true;\n  }\n\n  return current;\n}\n/**\n * @see https://infra.spec.whatwg.org/#ordered-set\n * @param {string} input\n * @returns {string[]}\n */\n\n\nfunction toOrderedSet(input) {\n  if (!input) return [];\n  var list = splitOnASCIIWhitespace(input);\n  return Object.keys(list.reduce(orderedSetReducer, {}));\n}\n/**\n * Uses `list.indexOf` to implement something like `Array.prototype.includes`,\n * which we can not rely on being available.\n *\n * @param {any[]} list\n * @returns {function(any): boolean}\n */\n\n\nfunction arrayIncludes(list) {\n  return function (element) {\n    return list && list.indexOf(element) !== -1;\n  };\n}\n\nfunction copy(src, dest) {\n  for (var p in src) {\n    dest[p] = src[p];\n  }\n}\n/**\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*((?:.*\\{\\s*?[\\r\\n][\\s\\S]*?^})|\\S.*?(?=[;\\r\\n]));?\n^\\w+\\.prototype\\.([_\\w]+)\\s*=\\s*(\\S.*?(?=[;\\r\\n]));?\n */\n\n\nfunction _extends(Class, Super) {\n  var pt = Class.prototype;\n\n  if (!(pt instanceof Super)) {\n    function t() {}\n\n    ;\n    t.prototype = Super.prototype;\n    t = new t();\n    copy(pt, t);\n    Class.prototype = pt = t;\n  }\n\n  if (pt.constructor != Class) {\n    if (typeof Class != 'function') {\n      console.error(\"unknown Class:\" + Class);\n    }\n\n    pt.constructor = Class;\n  }\n} // Node Types\n\n\nvar NodeType = {};\nvar ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;\nvar ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;\nvar TEXT_NODE = NodeType.TEXT_NODE = 3;\nvar CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;\nvar ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;\nvar ENTITY_NODE = NodeType.ENTITY_NODE = 6;\nvar PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;\nvar COMMENT_NODE = NodeType.COMMENT_NODE = 8;\nvar DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;\nvar DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;\nvar DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;\nvar NOTATION_NODE = NodeType.NOTATION_NODE = 12; // ExceptionCode\n\nvar ExceptionCode = {};\nvar ExceptionMessage = {};\nvar INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = \"Index size error\", 1);\nvar DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = \"DOMString size error\", 2);\nvar HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = \"Hierarchy request error\", 3);\nvar WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = \"Wrong document\", 4);\nvar INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = \"Invalid character\", 5);\nvar NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = \"No data allowed\", 6);\nvar NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = \"No modification allowed\", 7);\nvar NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = \"Not found\", 8);\nvar NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = \"Not supported\", 9);\nvar INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = \"Attribute in use\", 10); //level2\n\nvar INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = \"Invalid state\", 11);\nvar SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = \"Syntax error\", 12);\nvar INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = \"Invalid modification\", 13);\nvar NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = \"Invalid namespace\", 14);\nvar INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = \"Invalid access\", 15);\n/**\n * DOM Level 2\n * Object DOMException\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html\n * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html\n */\n\nfunction DOMException(code, message) {\n  if (message instanceof Error) {\n    var error = message;\n  } else {\n    error = this;\n    Error.call(this, ExceptionMessage[code]);\n    this.message = ExceptionMessage[code];\n    if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);\n  }\n\n  error.code = code;\n  if (message) this.message = this.message + \": \" + message;\n  return error;\n}\n\n;\nDOMException.prototype = Error.prototype;\ncopy(ExceptionCode, DOMException);\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177\n * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.\n * The items in the NodeList are accessible via an integral index, starting from 0.\n */\n\nfunction NodeList() {}\n\n;\nNodeList.prototype = {\n  /**\n   * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.\n   * @standard level1\n   */\n  length: 0,\n\n  /**\n   * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.\n   * @standard level1\n   * @param index  unsigned long \n   *   Index into the collection.\n   * @return Node\n   * \tThe node at the indexth position in the NodeList, or null if that is not a valid index. \n   */\n  item: function item(index) {\n    return this[index] || null;\n  },\n  toString: function toString(isHTML, nodeFilter) {\n    for (var buf = [], i = 0; i < this.length; i++) {\n      serializeToString(this[i], buf, isHTML, nodeFilter);\n    }\n\n    return buf.join('');\n  }\n};\n\nfunction LiveNodeList(node, refresh) {\n  this._node = node;\n  this._refresh = refresh;\n\n  _updateLiveList(this);\n}\n\nfunction _updateLiveList(list) {\n  var inc = list._node._inc || list._node.ownerDocument._inc;\n\n  if (list._inc != inc) {\n    var ls = list._refresh(list._node); //console.log(ls.length)\n\n\n    __set__(list, 'length', ls.length);\n\n    copy(ls, list);\n    list._inc = inc;\n  }\n}\n\nLiveNodeList.prototype.item = function (i) {\n  _updateLiveList(this);\n\n  return this[i];\n};\n\n_extends(LiveNodeList, NodeList);\n/**\n * Objects implementing the NamedNodeMap interface are used\n * to represent collections of nodes that can be accessed by name.\n * Note that NamedNodeMap does not inherit from NodeList;\n * NamedNodeMaps are not maintained in any particular order.\n * Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index,\n * but this is simply to allow convenient enumeration of the contents of a NamedNodeMap,\n * and does not imply that the DOM specifies an order to these Nodes.\n * NamedNodeMap objects in the DOM are live.\n * used for attributes or DocumentType entities \n */\n\n\nfunction NamedNodeMap() {}\n\n;\n\nfunction _findNodeIndex(list, node) {\n  var i = list.length;\n\n  while (i--) {\n    if (list[i] === node) {\n      return i;\n    }\n  }\n}\n\nfunction _addNamedNode(el, list, newAttr, oldAttr) {\n  if (oldAttr) {\n    list[_findNodeIndex(list, oldAttr)] = newAttr;\n  } else {\n    list[list.length++] = newAttr;\n  }\n\n  if (el) {\n    newAttr.ownerElement = el;\n    var doc = el.ownerDocument;\n\n    if (doc) {\n      oldAttr && _onRemoveAttribute(doc, el, oldAttr);\n\n      _onAddAttribute(doc, el, newAttr);\n    }\n  }\n}\n\nfunction _removeNamedNode(el, list, attr) {\n  //console.log('remove attr:'+attr)\n  var i = _findNodeIndex(list, attr);\n\n  if (i >= 0) {\n    var lastIndex = list.length - 1;\n\n    while (i < lastIndex) {\n      list[i] = list[++i];\n    }\n\n    list.length = lastIndex;\n\n    if (el) {\n      var doc = el.ownerDocument;\n\n      if (doc) {\n        _onRemoveAttribute(doc, el, attr);\n\n        attr.ownerElement = null;\n      }\n    }\n  } else {\n    throw DOMException(NOT_FOUND_ERR, new Error(el.tagName + '@' + attr));\n  }\n}\n\nNamedNodeMap.prototype = {\n  length: 0,\n  item: NodeList.prototype.item,\n  getNamedItem: function getNamedItem(key) {\n    //\t\tif(key.indexOf(':')>0 || key == 'xmlns'){\n    //\t\t\treturn null;\n    //\t\t}\n    //console.log()\n    var i = this.length;\n\n    while (i--) {\n      var attr = this[i]; //console.log(attr.nodeName,key)\n\n      if (attr.nodeName == key) {\n        return attr;\n      }\n    }\n  },\n  setNamedItem: function setNamedItem(attr) {\n    var el = attr.ownerElement;\n\n    if (el && el != this._ownerElement) {\n      throw new DOMException(INUSE_ATTRIBUTE_ERR);\n    }\n\n    var oldAttr = this.getNamedItem(attr.nodeName);\n\n    _addNamedNode(this._ownerElement, this, attr, oldAttr);\n\n    return oldAttr;\n  },\n\n  /* returns Node */\n  setNamedItemNS: function setNamedItemNS(attr) {\n    // raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR\n    var el = attr.ownerElement,\n        oldAttr;\n\n    if (el && el != this._ownerElement) {\n      throw new DOMException(INUSE_ATTRIBUTE_ERR);\n    }\n\n    oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);\n\n    _addNamedNode(this._ownerElement, this, attr, oldAttr);\n\n    return oldAttr;\n  },\n\n  /* returns Node */\n  removeNamedItem: function removeNamedItem(key) {\n    var attr = this.getNamedItem(key);\n\n    _removeNamedNode(this._ownerElement, this, attr);\n\n    return attr;\n  },\n  // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR\n  //for level2\n  removeNamedItemNS: function removeNamedItemNS(namespaceURI, localName) {\n    var attr = this.getNamedItemNS(namespaceURI, localName);\n\n    _removeNamedNode(this._ownerElement, this, attr);\n\n    return attr;\n  },\n  getNamedItemNS: function getNamedItemNS(namespaceURI, localName) {\n    var i = this.length;\n\n    while (i--) {\n      var node = this[i];\n\n      if (node.localName == localName && node.namespaceURI == namespaceURI) {\n        return node;\n      }\n    }\n\n    return null;\n  }\n};\n/**\n * The DOMImplementation interface represents an object providing methods\n * which are not dependent on any particular document.\n * Such an object is returned by the `Document.implementation` property.\n *\n * __The individual methods describe the differences compared to the specs.__\n *\n * @constructor\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN\n * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)\n * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core\n * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core\n * @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard\n */\n\nfunction DOMImplementation() {}\n\nDOMImplementation.prototype = {\n  /**\n   * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.\n   * The different implementations fairly diverged in what kind of features were reported.\n   * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.\n   *\n   * @deprecated It is deprecated and modern browsers return true in all cases.\n   *\n   * @param {string} feature\n   * @param {string} [version]\n   * @returns {boolean} always true\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN\n   * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core\n   * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard\n   */\n  hasFeature: function hasFeature(feature, version) {\n    return true;\n  },\n\n  /**\n   * Creates an XML Document object of the specified type with its document element.\n   *\n   * __It behaves slightly different from the description in the living standard__:\n   * - There is no interface/class `XMLDocument`, it returns a `Document` instance.\n   * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.\n   * - this implementation is not validating names or qualified names\n   *   (when parsing XML strings, the SAX parser takes care of that)\n   *\n   * @param {string|null} namespaceURI\n   * @param {string} qualifiedName\n   * @param {DocumentType=null} doctype\n   * @returns {Document}\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN\n   * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)\n   * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core\n   *\n   * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n   * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n   * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n   */\n  createDocument: function createDocument(namespaceURI, qualifiedName, doctype) {\n    var doc = new Document();\n    doc.implementation = this;\n    doc.childNodes = new NodeList();\n    doc.doctype = doctype || null;\n\n    if (doctype) {\n      doc.appendChild(doctype);\n    }\n\n    if (qualifiedName) {\n      var root = doc.createElementNS(namespaceURI, qualifiedName);\n      doc.appendChild(root);\n    }\n\n    return doc;\n  },\n\n  /**\n   * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.\n   *\n   * __This behavior is slightly different from the in the specs__:\n   * - this implementation is not validating names or qualified names\n   *   (when parsing XML strings, the SAX parser takes care of that)\n   *\n   * @param {string} qualifiedName\n   * @param {string} [publicId]\n   * @param {string} [systemId]\n   * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation\n   * \t\t\t\t  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN\n   * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core\n   * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard\n   *\n   * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract\n   * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names\n   * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names\n   */\n  createDocumentType: function createDocumentType(qualifiedName, publicId, systemId) {\n    var node = new DocumentType();\n    node.name = qualifiedName;\n    node.nodeName = qualifiedName;\n    node.publicId = publicId || '';\n    node.systemId = systemId || '';\n    return node;\n  }\n};\n/**\n * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247\n */\n\nfunction Node() {}\n\n;\nNode.prototype = {\n  firstChild: null,\n  lastChild: null,\n  previousSibling: null,\n  nextSibling: null,\n  attributes: null,\n  parentNode: null,\n  childNodes: null,\n  ownerDocument: null,\n  nodeValue: null,\n  namespaceURI: null,\n  prefix: null,\n  localName: null,\n  // Modified in DOM Level 2:\n  insertBefore: function insertBefore(newChild, refChild) {\n    //raises \n    return _insertBefore(this, newChild, refChild);\n  },\n  replaceChild: function replaceChild(newChild, oldChild) {\n    //raises \n    this.insertBefore(newChild, oldChild);\n\n    if (oldChild) {\n      this.removeChild(oldChild);\n    }\n  },\n  removeChild: function removeChild(oldChild) {\n    return _removeChild(this, oldChild);\n  },\n  appendChild: function appendChild(newChild) {\n    return this.insertBefore(newChild, null);\n  },\n  hasChildNodes: function hasChildNodes() {\n    return this.firstChild != null;\n  },\n  cloneNode: function cloneNode(deep) {\n    return _cloneNode(this.ownerDocument || this, this, deep);\n  },\n  // Modified in DOM Level 2:\n  normalize: function normalize() {\n    var child = this.firstChild;\n\n    while (child) {\n      var next = child.nextSibling;\n\n      if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {\n        this.removeChild(next);\n        child.appendData(next.data);\n      } else {\n        child.normalize();\n        child = next;\n      }\n    }\n  },\n  // Introduced in DOM Level 2:\n  isSupported: function isSupported(feature, version) {\n    return this.ownerDocument.implementation.hasFeature(feature, version);\n  },\n  // Introduced in DOM Level 2:\n  hasAttributes: function hasAttributes() {\n    return this.attributes.length > 0;\n  },\n\n  /**\n   * Look up the prefix associated to the given namespace URI, starting from this node.\n   * **The default namespace declarations are ignored by this method.**\n   * See Namespace Prefix Lookup for details on the algorithm used by this method.\n   *\n   * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._\n   *\n   * @param {string | null} namespaceURI\n   * @returns {string | null}\n   * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix\n   * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo\n   * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix\n   * @see https://github.com/xmldom/xmldom/issues/322\n   */\n  lookupPrefix: function lookupPrefix(namespaceURI) {\n    var el = this;\n\n    while (el) {\n      var map = el._nsMap; //console.dir(map)\n\n      if (map) {\n        for (var n in map) {\n          if (map[n] == namespaceURI) {\n            return n;\n          }\n        }\n      }\n\n      el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;\n    }\n\n    return null;\n  },\n  // Introduced in DOM Level 3:\n  lookupNamespaceURI: function lookupNamespaceURI(prefix) {\n    var el = this;\n\n    while (el) {\n      var map = el._nsMap; //console.dir(map)\n\n      if (map) {\n        if (prefix in map) {\n          return map[prefix];\n        }\n      }\n\n      el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;\n    }\n\n    return null;\n  },\n  // Introduced in DOM Level 3:\n  isDefaultNamespace: function isDefaultNamespace(namespaceURI) {\n    var prefix = this.lookupPrefix(namespaceURI);\n    return prefix == null;\n  }\n};\n\nfunction _xmlEncoder(c) {\n  return c == '<' && '&lt;' || c == '>' && '&gt;' || c == '&' && '&amp;' || c == '\"' && '&quot;' || '&#' + c.charCodeAt() + ';';\n}\n\ncopy(NodeType, Node);\ncopy(NodeType, Node.prototype);\n/**\n * @param callback return true for continue,false for break\n * @return boolean true: break visit;\n */\n\nfunction _visitNode(node, callback) {\n  if (callback(node)) {\n    return true;\n  }\n\n  if (node = node.firstChild) {\n    do {\n      if (_visitNode(node, callback)) {\n        return true;\n      }\n    } while (node = node.nextSibling);\n  }\n}\n\nfunction Document() {}\n\nfunction _onAddAttribute(doc, el, newAttr) {\n  doc && doc._inc++;\n  var ns = newAttr.namespaceURI;\n\n  if (ns === NAMESPACE.XMLNS) {\n    //update namespace\n    el._nsMap[newAttr.prefix ? newAttr.localName : ''] = newAttr.value;\n  }\n}\n\nfunction _onRemoveAttribute(doc, el, newAttr, remove) {\n  doc && doc._inc++;\n  var ns = newAttr.namespaceURI;\n\n  if (ns === NAMESPACE.XMLNS) {\n    //update namespace\n    delete el._nsMap[newAttr.prefix ? newAttr.localName : ''];\n  }\n}\n\nfunction _onUpdateChild(doc, el, newChild) {\n  if (doc && doc._inc) {\n    doc._inc++; //update childNodes\n\n    var cs = el.childNodes;\n\n    if (newChild) {\n      cs[cs.length++] = newChild;\n    } else {\n      //console.log(1)\n      var child = el.firstChild;\n      var i = 0;\n\n      while (child) {\n        cs[i++] = child;\n        child = child.nextSibling;\n      }\n\n      cs.length = i;\n    }\n  }\n}\n/**\n * attributes;\n * children;\n * \n * writeable properties:\n * nodeValue,Attr:value,CharacterData:data\n * prefix\n */\n\n\nfunction _removeChild(parentNode, child) {\n  var previous = child.previousSibling;\n  var next = child.nextSibling;\n\n  if (previous) {\n    previous.nextSibling = next;\n  } else {\n    parentNode.firstChild = next;\n  }\n\n  if (next) {\n    next.previousSibling = previous;\n  } else {\n    parentNode.lastChild = previous;\n  }\n\n  _onUpdateChild(parentNode.ownerDocument, parentNode);\n\n  return child;\n}\n/**\n * preformance key(refChild == null)\n */\n\n\nfunction _insertBefore(parentNode, newChild, nextChild) {\n  var cp = newChild.parentNode;\n\n  if (cp) {\n    cp.removeChild(newChild); //remove and update\n  }\n\n  if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {\n    var newFirst = newChild.firstChild;\n\n    if (newFirst == null) {\n      return newChild;\n    }\n\n    var newLast = newChild.lastChild;\n  } else {\n    newFirst = newLast = newChild;\n  }\n\n  var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;\n  newFirst.previousSibling = pre;\n  newLast.nextSibling = nextChild;\n\n  if (pre) {\n    pre.nextSibling = newFirst;\n  } else {\n    parentNode.firstChild = newFirst;\n  }\n\n  if (nextChild == null) {\n    parentNode.lastChild = newLast;\n  } else {\n    nextChild.previousSibling = newLast;\n  }\n\n  do {\n    newFirst.parentNode = parentNode;\n  } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));\n\n  _onUpdateChild(parentNode.ownerDocument || parentNode, parentNode); //console.log(parentNode.lastChild.nextSibling == null)\n\n\n  if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {\n    newChild.firstChild = newChild.lastChild = null;\n  }\n\n  return newChild;\n}\n\nfunction _appendSingleChild(parentNode, newChild) {\n  var cp = newChild.parentNode;\n\n  if (cp) {\n    var pre = parentNode.lastChild;\n    cp.removeChild(newChild); //remove and update\n\n    var pre = parentNode.lastChild;\n  }\n\n  var pre = parentNode.lastChild;\n  newChild.parentNode = parentNode;\n  newChild.previousSibling = pre;\n  newChild.nextSibling = null;\n\n  if (pre) {\n    pre.nextSibling = newChild;\n  } else {\n    parentNode.firstChild = newChild;\n  }\n\n  parentNode.lastChild = newChild;\n\n  _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);\n\n  return newChild; //console.log(\"__aa\",parentNode.lastChild.nextSibling == null)\n}\n\nDocument.prototype = {\n  //implementation : null,\n  nodeName: '#document',\n  nodeType: DOCUMENT_NODE,\n\n  /**\n   * The DocumentType node of the document.\n   *\n   * @readonly\n   * @type DocumentType\n   */\n  doctype: null,\n  documentElement: null,\n  _inc: 1,\n  insertBefore: function insertBefore(newChild, refChild) {\n    //raises\n    if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {\n      var child = newChild.firstChild;\n\n      while (child) {\n        var next = child.nextSibling;\n        this.insertBefore(child, refChild);\n        child = next;\n      }\n\n      return newChild;\n    }\n\n    if (this.documentElement == null && newChild.nodeType == ELEMENT_NODE) {\n      this.documentElement = newChild;\n    }\n\n    return _insertBefore(this, newChild, refChild), newChild.ownerDocument = this, newChild;\n  },\n  removeChild: function removeChild(oldChild) {\n    if (this.documentElement == oldChild) {\n      this.documentElement = null;\n    }\n\n    return _removeChild(this, oldChild);\n  },\n  // Introduced in DOM Level 2:\n  importNode: function importNode(importedNode, deep) {\n    return _importNode(this, importedNode, deep);\n  },\n  // Introduced in DOM Level 2:\n  getElementById: function getElementById(id) {\n    var rtv = null;\n\n    _visitNode(this.documentElement, function (node) {\n      if (node.nodeType == ELEMENT_NODE) {\n        if (node.getAttribute('id') == id) {\n          rtv = node;\n          return true;\n        }\n      }\n    });\n\n    return rtv;\n  },\n\n  /**\n   * The `getElementsByClassName` method of `Document` interface returns an array-like object\n   * of all child elements which have **all** of the given class name(s).\n   *\n   * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.\n   *\n   *\n   * Warning: This is a live LiveNodeList.\n   * Changes in the DOM will reflect in the array as the changes occur.\n   * If an element selected by this array no longer qualifies for the selector,\n   * it will automatically be removed. Be aware of this for iteration purposes.\n   *\n   * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName\n   * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname\n   */\n  getElementsByClassName: function getElementsByClassName(classNames) {\n    var classNamesSet = toOrderedSet(classNames);\n    return new LiveNodeList(this, function (base) {\n      var ls = [];\n\n      if (classNamesSet.length > 0) {\n        _visitNode(base.documentElement, function (node) {\n          if (node !== base && node.nodeType === ELEMENT_NODE) {\n            var nodeClassNames = node.getAttribute('class'); // can be null if the attribute does not exist\n\n            if (nodeClassNames) {\n              // before splitting and iterating just compare them for the most common case\n              var matches = classNames === nodeClassNames;\n\n              if (!matches) {\n                var nodeClassNamesSet = toOrderedSet(nodeClassNames);\n                matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));\n              }\n\n              if (matches) {\n                ls.push(node);\n              }\n            }\n          }\n        });\n      }\n\n      return ls;\n    });\n  },\n  //document factory method:\n  createElement: function createElement(tagName) {\n    var node = new Element();\n    node.ownerDocument = this;\n    node.nodeName = tagName;\n    node.tagName = tagName;\n    node.localName = tagName;\n    node.childNodes = new NodeList();\n    var attrs = node.attributes = new NamedNodeMap();\n    attrs._ownerElement = node;\n    return node;\n  },\n  createDocumentFragment: function createDocumentFragment() {\n    var node = new DocumentFragment();\n    node.ownerDocument = this;\n    node.childNodes = new NodeList();\n    return node;\n  },\n  createTextNode: function createTextNode(data) {\n    var node = new Text();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createComment: function createComment(data) {\n    var node = new Comment();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createCDATASection: function createCDATASection(data) {\n    var node = new CDATASection();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createProcessingInstruction: function createProcessingInstruction(target, data) {\n    var node = new ProcessingInstruction();\n    node.ownerDocument = this;\n    node.tagName = node.target = target;\n    node.nodeValue = node.data = data;\n    return node;\n  },\n  createAttribute: function createAttribute(name) {\n    var node = new Attr();\n    node.ownerDocument = this;\n    node.name = name;\n    node.nodeName = name;\n    node.localName = name;\n    node.specified = true;\n    return node;\n  },\n  createEntityReference: function createEntityReference(name) {\n    var node = new EntityReference();\n    node.ownerDocument = this;\n    node.nodeName = name;\n    return node;\n  },\n  // Introduced in DOM Level 2:\n  createElementNS: function createElementNS(namespaceURI, qualifiedName) {\n    var node = new Element();\n    var pl = qualifiedName.split(':');\n    var attrs = node.attributes = new NamedNodeMap();\n    node.childNodes = new NodeList();\n    node.ownerDocument = this;\n    node.nodeName = qualifiedName;\n    node.tagName = qualifiedName;\n    node.namespaceURI = namespaceURI;\n\n    if (pl.length == 2) {\n      node.prefix = pl[0];\n      node.localName = pl[1];\n    } else {\n      //el.prefix = null;\n      node.localName = qualifiedName;\n    }\n\n    attrs._ownerElement = node;\n    return node;\n  },\n  // Introduced in DOM Level 2:\n  createAttributeNS: function createAttributeNS(namespaceURI, qualifiedName) {\n    var node = new Attr();\n    var pl = qualifiedName.split(':');\n    node.ownerDocument = this;\n    node.nodeName = qualifiedName;\n    node.name = qualifiedName;\n    node.namespaceURI = namespaceURI;\n    node.specified = true;\n\n    if (pl.length == 2) {\n      node.prefix = pl[0];\n      node.localName = pl[1];\n    } else {\n      //el.prefix = null;\n      node.localName = qualifiedName;\n    }\n\n    return node;\n  }\n};\n\n_extends(Document, Node);\n\nfunction Element() {\n  this._nsMap = {};\n}\n\n;\nElement.prototype = {\n  nodeType: ELEMENT_NODE,\n  hasAttribute: function hasAttribute(name) {\n    return this.getAttributeNode(name) != null;\n  },\n  getAttribute: function getAttribute(name) {\n    var attr = this.getAttributeNode(name);\n    return attr && attr.value || '';\n  },\n  getAttributeNode: function getAttributeNode(name) {\n    return this.attributes.getNamedItem(name);\n  },\n  setAttribute: function setAttribute(name, value) {\n    var attr = this.ownerDocument.createAttribute(name);\n    attr.value = attr.nodeValue = \"\" + value;\n    this.setAttributeNode(attr);\n  },\n  removeAttribute: function removeAttribute(name) {\n    var attr = this.getAttributeNode(name);\n    attr && this.removeAttributeNode(attr);\n  },\n  //four real opeartion method\n  appendChild: function appendChild(newChild) {\n    if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return this.insertBefore(newChild, null);\n    } else {\n      return _appendSingleChild(this, newChild);\n    }\n  },\n  setAttributeNode: function setAttributeNode(newAttr) {\n    return this.attributes.setNamedItem(newAttr);\n  },\n  setAttributeNodeNS: function setAttributeNodeNS(newAttr) {\n    return this.attributes.setNamedItemNS(newAttr);\n  },\n  removeAttributeNode: function removeAttributeNode(oldAttr) {\n    //console.log(this == oldAttr.ownerElement)\n    return this.attributes.removeNamedItem(oldAttr.nodeName);\n  },\n  //get real attribute name,and remove it by removeAttributeNode\n  removeAttributeNS: function removeAttributeNS(namespaceURI, localName) {\n    var old = this.getAttributeNodeNS(namespaceURI, localName);\n    old && this.removeAttributeNode(old);\n  },\n  hasAttributeNS: function hasAttributeNS(namespaceURI, localName) {\n    return this.getAttributeNodeNS(namespaceURI, localName) != null;\n  },\n  getAttributeNS: function getAttributeNS(namespaceURI, localName) {\n    var attr = this.getAttributeNodeNS(namespaceURI, localName);\n    return attr && attr.value || '';\n  },\n  setAttributeNS: function setAttributeNS(namespaceURI, qualifiedName, value) {\n    var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);\n    attr.value = attr.nodeValue = \"\" + value;\n    this.setAttributeNode(attr);\n  },\n  getAttributeNodeNS: function getAttributeNodeNS(namespaceURI, localName) {\n    return this.attributes.getNamedItemNS(namespaceURI, localName);\n  },\n  getElementsByTagName: function getElementsByTagName(tagName) {\n    return new LiveNodeList(this, function (base) {\n      var ls = [];\n\n      _visitNode(base, function (node) {\n        if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)) {\n          ls.push(node);\n        }\n      });\n\n      return ls;\n    });\n  },\n  getElementsByTagNameNS: function getElementsByTagNameNS(namespaceURI, localName) {\n    return new LiveNodeList(this, function (base) {\n      var ls = [];\n\n      _visitNode(base, function (node) {\n        if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)) {\n          ls.push(node);\n        }\n      });\n\n      return ls;\n    });\n  }\n};\nDocument.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;\nDocument.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;\n\n_extends(Element, Node);\n\nfunction Attr() {}\n\n;\nAttr.prototype.nodeType = ATTRIBUTE_NODE;\n\n_extends(Attr, Node);\n\nfunction CharacterData() {}\n\n;\nCharacterData.prototype = {\n  data: '',\n  substringData: function substringData(offset, count) {\n    return this.data.substring(offset, offset + count);\n  },\n  appendData: function appendData(text) {\n    text = this.data + text;\n    this.nodeValue = this.data = text;\n    this.length = text.length;\n  },\n  insertData: function insertData(offset, text) {\n    this.replaceData(offset, 0, text);\n  },\n  appendChild: function appendChild(newChild) {\n    throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);\n  },\n  deleteData: function deleteData(offset, count) {\n    this.replaceData(offset, count, \"\");\n  },\n  replaceData: function replaceData(offset, count, text) {\n    var start = this.data.substring(0, offset);\n    var end = this.data.substring(offset + count);\n    text = start + text + end;\n    this.nodeValue = this.data = text;\n    this.length = text.length;\n  }\n};\n\n_extends(CharacterData, Node);\n\nfunction Text() {}\n\n;\nText.prototype = {\n  nodeName: \"#text\",\n  nodeType: TEXT_NODE,\n  splitText: function splitText(offset) {\n    var text = this.data;\n    var newText = text.substring(offset);\n    text = text.substring(0, offset);\n    this.data = this.nodeValue = text;\n    this.length = text.length;\n    var newNode = this.ownerDocument.createTextNode(newText);\n\n    if (this.parentNode) {\n      this.parentNode.insertBefore(newNode, this.nextSibling);\n    }\n\n    return newNode;\n  }\n};\n\n_extends(Text, CharacterData);\n\nfunction Comment() {}\n\n;\nComment.prototype = {\n  nodeName: \"#comment\",\n  nodeType: COMMENT_NODE\n};\n\n_extends(Comment, CharacterData);\n\nfunction CDATASection() {}\n\n;\nCDATASection.prototype = {\n  nodeName: \"#cdata-section\",\n  nodeType: CDATA_SECTION_NODE\n};\n\n_extends(CDATASection, CharacterData);\n\nfunction DocumentType() {}\n\n;\nDocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;\n\n_extends(DocumentType, Node);\n\nfunction Notation() {}\n\n;\nNotation.prototype.nodeType = NOTATION_NODE;\n\n_extends(Notation, Node);\n\nfunction Entity() {}\n\n;\nEntity.prototype.nodeType = ENTITY_NODE;\n\n_extends(Entity, Node);\n\nfunction EntityReference() {}\n\n;\nEntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;\n\n_extends(EntityReference, Node);\n\nfunction DocumentFragment() {}\n\n;\nDocumentFragment.prototype.nodeName = \"#document-fragment\";\nDocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;\n\n_extends(DocumentFragment, Node);\n\nfunction ProcessingInstruction() {}\n\nProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;\n\n_extends(ProcessingInstruction, Node);\n\nfunction XMLSerializer() {}\n\nXMLSerializer.prototype.serializeToString = function (node, isHtml, nodeFilter) {\n  return nodeSerializeToString.call(node, isHtml, nodeFilter);\n};\n\nNode.prototype.toString = nodeSerializeToString;\n\nfunction nodeSerializeToString(isHtml, nodeFilter) {\n  var buf = [];\n  var refNode = this.nodeType == 9 && this.documentElement || this;\n  var prefix = refNode.prefix;\n  var uri = refNode.namespaceURI;\n\n  if (uri && prefix == null) {\n    //console.log(prefix)\n    var prefix = refNode.lookupPrefix(uri);\n\n    if (prefix == null) {\n      //isHTML = true;\n      var visibleNamespaces = [{\n        namespace: uri,\n        prefix: null\n      } //{namespace:uri,prefix:''}\n      ];\n    }\n  }\n\n  serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces); //console.log('###',this.nodeType,uri,prefix,buf.join(''))\n\n  return buf.join('');\n}\n\nfunction needNamespaceDefine(node, isHTML, visibleNamespaces) {\n  var prefix = node.prefix || '';\n  var uri = node.namespaceURI; // According to [Namespaces in XML 1.0](https://www.w3.org/TR/REC-xml-names/#ns-using) ,\n  // and more specifically https://www.w3.org/TR/REC-xml-names/#nsc-NoPrefixUndecl :\n  // > In a namespace declaration for a prefix [...], the attribute value MUST NOT be empty.\n  // in a similar manner [Namespaces in XML 1.1](https://www.w3.org/TR/xml-names11/#ns-using)\n  // and more specifically https://www.w3.org/TR/xml-names11/#nsc-NSDeclared :\n  // > [...] Furthermore, the attribute value [...] must not be an empty string.\n  // so serializing empty namespace value like xmlns:ds=\"\" would produce an invalid XML document.\n\n  if (!uri) {\n    return false;\n  }\n\n  if (prefix === \"xml\" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {\n    return false;\n  }\n\n  var i = visibleNamespaces.length;\n\n  while (i--) {\n    var ns = visibleNamespaces[i]; // get namespace prefix\n\n    if (ns.prefix === prefix) {\n      return ns.namespace !== uri;\n    }\n  }\n\n  return true;\n}\n/**\n * Well-formed constraint: No < in Attribute Values\n * The replacement text of any entity referred to directly or indirectly in an attribute value must not contain a <.\n * @see https://www.w3.org/TR/xml/#CleanAttrVals\n * @see https://www.w3.org/TR/xml/#NT-AttValue\n */\n\n\nfunction addSerializedAttribute(buf, qualifiedName, value) {\n  buf.push(' ', qualifiedName, '=\"', value.replace(/[<&\"]/g, _xmlEncoder), '\"');\n}\n\nfunction serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {\n  if (!visibleNamespaces) {\n    visibleNamespaces = [];\n  }\n\n  if (nodeFilter) {\n    node = nodeFilter(node);\n\n    if (node) {\n      if (typeof node == 'string') {\n        buf.push(node);\n        return;\n      }\n    } else {\n      return;\n    } //buf.sort.apply(attrs, attributeSorter);\n\n  }\n\n  switch (node.nodeType) {\n    case ELEMENT_NODE:\n      var attrs = node.attributes;\n      var len = attrs.length;\n      var child = node.firstChild;\n      var nodeName = node.tagName;\n      isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML;\n      var prefixedNodeName = nodeName;\n\n      if (!isHTML && !node.prefix && node.namespaceURI) {\n        var defaultNS; // lookup current default ns from `xmlns` attribute\n\n        for (var ai = 0; ai < attrs.length; ai++) {\n          if (attrs.item(ai).name === 'xmlns') {\n            defaultNS = attrs.item(ai).value;\n            break;\n          }\n        }\n\n        if (!defaultNS) {\n          // lookup current default ns in visibleNamespaces\n          for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {\n            var namespace = visibleNamespaces[nsi];\n\n            if (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {\n              defaultNS = namespace.namespace;\n              break;\n            }\n          }\n        }\n\n        if (defaultNS !== node.namespaceURI) {\n          for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {\n            var namespace = visibleNamespaces[nsi];\n\n            if (namespace.namespace === node.namespaceURI) {\n              if (namespace.prefix) {\n                prefixedNodeName = namespace.prefix + ':' + nodeName;\n              }\n\n              break;\n            }\n          }\n        }\n      }\n\n      buf.push('<', prefixedNodeName);\n\n      for (var i = 0; i < len; i++) {\n        // add namespaces for attributes\n        var attr = attrs.item(i);\n\n        if (attr.prefix == 'xmlns') {\n          visibleNamespaces.push({\n            prefix: attr.localName,\n            namespace: attr.value\n          });\n        } else if (attr.nodeName == 'xmlns') {\n          visibleNamespaces.push({\n            prefix: '',\n            namespace: attr.value\n          });\n        }\n      }\n\n      for (var i = 0; i < len; i++) {\n        var attr = attrs.item(i);\n\n        if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {\n          var prefix = attr.prefix || '';\n          var uri = attr.namespaceURI;\n          addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : \"xmlns\", uri);\n          visibleNamespaces.push({\n            prefix: prefix,\n            namespace: uri\n          });\n        }\n\n        serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);\n      } // add namespace for current node\t\t\n\n\n      if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {\n        var prefix = node.prefix || '';\n        var uri = node.namespaceURI;\n        addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : \"xmlns\", uri);\n        visibleNamespaces.push({\n          prefix: prefix,\n          namespace: uri\n        });\n      }\n\n      if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {\n        buf.push('>'); //if is cdata child node\n\n        if (isHTML && /^script$/i.test(nodeName)) {\n          while (child) {\n            if (child.data) {\n              buf.push(child.data);\n            } else {\n              serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n            }\n\n            child = child.nextSibling;\n          }\n        } else {\n          while (child) {\n            serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n            child = child.nextSibling;\n          }\n        }\n\n        buf.push('</', prefixedNodeName, '>');\n      } else {\n        buf.push('/>');\n      } // remove added visible namespaces\n      //visibleNamespaces.length = startVisibleNamespaces;\n\n\n      return;\n\n    case DOCUMENT_NODE:\n    case DOCUMENT_FRAGMENT_NODE:\n      var child = node.firstChild;\n\n      while (child) {\n        serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());\n        child = child.nextSibling;\n      }\n\n      return;\n\n    case ATTRIBUTE_NODE:\n      return addSerializedAttribute(buf, node.name, node.value);\n\n    case TEXT_NODE:\n      /**\n       * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,\n       * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.\n       * If they are needed elsewhere, they must be escaped using either numeric character references or the strings\n       * `&amp;` and `&lt;` respectively.\n       * The right angle bracket (>) may be represented using the string \" &gt; \", and must, for compatibility,\n       * be escaped using either `&gt;` or a character reference when it appears in the string `]]>` in content,\n       * when that string is not marking the end of a CDATA section.\n       *\n       * In the content of elements, character data is any string of characters\n       * which does not contain the start-delimiter of any markup\n       * and does not include the CDATA-section-close delimiter, `]]>`.\n       *\n       * @see https://www.w3.org/TR/xml/#NT-CharData\n       */\n      return buf.push(node.data.replace(/[<&]/g, _xmlEncoder).replace(/]]>/g, ']]&gt;'));\n\n    case CDATA_SECTION_NODE:\n      return buf.push('<![CDATA[', node.data, ']]>');\n\n    case COMMENT_NODE:\n      return buf.push(\"<!--\", node.data, \"-->\");\n\n    case DOCUMENT_TYPE_NODE:\n      var pubid = node.publicId;\n      var sysid = node.systemId;\n      buf.push('<!DOCTYPE ', node.name);\n\n      if (pubid) {\n        buf.push(' PUBLIC ', pubid);\n\n        if (sysid && sysid != '.') {\n          buf.push(' ', sysid);\n        }\n\n        buf.push('>');\n      } else if (sysid && sysid != '.') {\n        buf.push(' SYSTEM ', sysid, '>');\n      } else {\n        var sub = node.internalSubset;\n\n        if (sub) {\n          buf.push(\" [\", sub, \"]\");\n        }\n\n        buf.push(\">\");\n      }\n\n      return;\n\n    case PROCESSING_INSTRUCTION_NODE:\n      return buf.push(\"<?\", node.target, \" \", node.data, \"?>\");\n\n    case ENTITY_REFERENCE_NODE:\n      return buf.push('&', node.nodeName, ';');\n    //case ENTITY_NODE:\n    //case NOTATION_NODE:\n\n    default:\n      buf.push('??', node.nodeName);\n  }\n}\n\nfunction _importNode(doc, node, deep) {\n  var node2;\n\n  switch (node.nodeType) {\n    case ELEMENT_NODE:\n      node2 = node.cloneNode(false);\n      node2.ownerDocument = doc;\n    //var attrs = node2.attributes;\n    //var len = attrs.length;\n    //for(var i=0;i<len;i++){\n    //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));\n    //}\n\n    case DOCUMENT_FRAGMENT_NODE:\n      break;\n\n    case ATTRIBUTE_NODE:\n      deep = true;\n      break;\n    //case ENTITY_REFERENCE_NODE:\n    //case PROCESSING_INSTRUCTION_NODE:\n    ////case TEXT_NODE:\n    //case CDATA_SECTION_NODE:\n    //case COMMENT_NODE:\n    //\tdeep = false;\n    //\tbreak;\n    //case DOCUMENT_NODE:\n    //case DOCUMENT_TYPE_NODE:\n    //cannot be imported.\n    //case ENTITY_NODE:\n    //case NOTATION_NODE：\n    //can not hit in level3\n    //default:throw e;\n  }\n\n  if (!node2) {\n    node2 = node.cloneNode(false); //false\n  }\n\n  node2.ownerDocument = doc;\n  node2.parentNode = null;\n\n  if (deep) {\n    var child = node.firstChild;\n\n    while (child) {\n      node2.appendChild(_importNode(doc, child, deep));\n      child = child.nextSibling;\n    }\n  }\n\n  return node2;\n} //\n//var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,\n//\t\t\t\t\tattributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};\n\n\nfunction _cloneNode(doc, node, deep) {\n  var node2 = new node.constructor();\n\n  for (var n in node) {\n    var v = node[n];\n\n    if (typeof v != 'object') {\n      if (v != node2[n]) {\n        node2[n] = v;\n      }\n    }\n  }\n\n  if (node.childNodes) {\n    node2.childNodes = new NodeList();\n  }\n\n  node2.ownerDocument = doc;\n\n  switch (node2.nodeType) {\n    case ELEMENT_NODE:\n      var attrs = node.attributes;\n      var attrs2 = node2.attributes = new NamedNodeMap();\n      var len = attrs.length;\n      attrs2._ownerElement = node2;\n\n      for (var i = 0; i < len; i++) {\n        node2.setAttributeNode(_cloneNode(doc, attrs.item(i), true));\n      }\n\n      break;\n      ;\n\n    case ATTRIBUTE_NODE:\n      deep = true;\n  }\n\n  if (deep) {\n    var child = node.firstChild;\n\n    while (child) {\n      node2.appendChild(_cloneNode(doc, child, deep));\n      child = child.nextSibling;\n    }\n  }\n\n  return node2;\n}\n\nfunction __set__(object, key, value) {\n  object[key] = value;\n} //do dynamic\n\n\ntry {\n  if (Object.defineProperty) {\n    Object.defineProperty(LiveNodeList.prototype, 'length', {\n      get: function get() {\n        _updateLiveList(this);\n\n        return this.$$length;\n      }\n    });\n    Object.defineProperty(Node.prototype, 'textContent', {\n      get: function get() {\n        return getTextContent(this);\n      },\n      set: function set(data) {\n        switch (this.nodeType) {\n          case ELEMENT_NODE:\n          case DOCUMENT_FRAGMENT_NODE:\n            while (this.firstChild) {\n              this.removeChild(this.firstChild);\n            }\n\n            if (data || String(data)) {\n              this.appendChild(this.ownerDocument.createTextNode(data));\n            }\n\n            break;\n\n          default:\n            this.data = data;\n            this.value = data;\n            this.nodeValue = data;\n        }\n      }\n    });\n\n    function getTextContent(node) {\n      switch (node.nodeType) {\n        case ELEMENT_NODE:\n        case DOCUMENT_FRAGMENT_NODE:\n          var buf = [];\n          node = node.firstChild;\n\n          while (node) {\n            if (node.nodeType !== 7 && node.nodeType !== 8) {\n              buf.push(getTextContent(node));\n            }\n\n            node = node.nextSibling;\n          }\n\n          return buf.join('');\n\n        default:\n          return node.nodeValue;\n      }\n    }\n\n    __set__ = function __set__(object, key, value) {\n      //console.log(value)\n      object['$$' + key] = value;\n    };\n  }\n} catch (e) {//ie8\n} //if(typeof require == 'function'){\n\n\nexports.DocumentType = DocumentType;\nexports.DOMException = DOMException;\nexports.DOMImplementation = DOMImplementation;\nexports.Element = Element;\nexports.Node = Node;\nexports.NodeList = NodeList;\nexports.XMLSerializer = XMLSerializer; //}","var freeze = require('./conventions').freeze;\n/**\n * The entities that are predefined in every XML document.\n *\n * @see https://www.w3.org/TR/2006/REC-xml11-20060816/#sec-predefined-ent W3C XML 1.1\n * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent W3C XML 1.0\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML Wikipedia\n */\n\n\nexports.XML_ENTITIES = freeze({\n  amp: '&',\n  apos: \"'\",\n  gt: '>',\n  lt: '<',\n  quot: '\"'\n});\n/**\n * A map of currently 241 entities that are detected in an HTML document.\n * They contain all entries from `XML_ENTITIES`.\n *\n * @see XML_ENTITIES\n * @see DOMParser.parseFromString\n * @see DOMImplementation.prototype.createHTMLDocument\n * @see https://html.spec.whatwg.org/#named-character-references WHATWG HTML(5) Spec\n * @see https://www.w3.org/TR/xml-entity-names/ W3C XML Entity Names\n * @see https://www.w3.org/TR/html4/sgml/entities.html W3C HTML4/SGML\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)\n * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML Wikpedia (XHTML)\n */\n\nexports.HTML_ENTITIES = freeze({\n  lt: '<',\n  gt: '>',\n  amp: '&',\n  quot: '\"',\n  apos: \"'\",\n  Agrave: \"À\",\n  Aacute: \"Á\",\n  Acirc: \"Â\",\n  Atilde: \"Ã\",\n  Auml: \"Ä\",\n  Aring: \"Å\",\n  AElig: \"Æ\",\n  Ccedil: \"Ç\",\n  Egrave: \"È\",\n  Eacute: \"É\",\n  Ecirc: \"Ê\",\n  Euml: \"Ë\",\n  Igrave: \"Ì\",\n  Iacute: \"Í\",\n  Icirc: \"Î\",\n  Iuml: \"Ï\",\n  ETH: \"Ð\",\n  Ntilde: \"Ñ\",\n  Ograve: \"Ò\",\n  Oacute: \"Ó\",\n  Ocirc: \"Ô\",\n  Otilde: \"Õ\",\n  Ouml: \"Ö\",\n  Oslash: \"Ø\",\n  Ugrave: \"Ù\",\n  Uacute: \"Ú\",\n  Ucirc: \"Û\",\n  Uuml: \"Ü\",\n  Yacute: \"Ý\",\n  THORN: \"Þ\",\n  szlig: \"ß\",\n  agrave: \"à\",\n  aacute: \"á\",\n  acirc: \"â\",\n  atilde: \"ã\",\n  auml: \"ä\",\n  aring: \"å\",\n  aelig: \"æ\",\n  ccedil: \"ç\",\n  egrave: \"è\",\n  eacute: \"é\",\n  ecirc: \"ê\",\n  euml: \"ë\",\n  igrave: \"ì\",\n  iacute: \"í\",\n  icirc: \"î\",\n  iuml: \"ï\",\n  eth: \"ð\",\n  ntilde: \"ñ\",\n  ograve: \"ò\",\n  oacute: \"ó\",\n  ocirc: \"ô\",\n  otilde: \"õ\",\n  ouml: \"ö\",\n  oslash: \"ø\",\n  ugrave: \"ù\",\n  uacute: \"ú\",\n  ucirc: \"û\",\n  uuml: \"ü\",\n  yacute: \"ý\",\n  thorn: \"þ\",\n  yuml: \"ÿ\",\n  nbsp: \"\\xA0\",\n  iexcl: \"¡\",\n  cent: \"¢\",\n  pound: \"£\",\n  curren: \"¤\",\n  yen: \"¥\",\n  brvbar: \"¦\",\n  sect: \"§\",\n  uml: \"¨\",\n  copy: \"©\",\n  ordf: \"ª\",\n  laquo: \"«\",\n  not: \"¬\",\n  shy: \"­­\",\n  reg: \"®\",\n  macr: \"¯\",\n  deg: \"°\",\n  plusmn: \"±\",\n  sup2: \"²\",\n  sup3: \"³\",\n  acute: \"´\",\n  micro: \"µ\",\n  para: \"¶\",\n  middot: \"·\",\n  cedil: \"¸\",\n  sup1: \"¹\",\n  ordm: \"º\",\n  raquo: \"»\",\n  frac14: \"¼\",\n  frac12: \"½\",\n  frac34: \"¾\",\n  iquest: \"¿\",\n  times: \"×\",\n  divide: \"÷\",\n  forall: \"∀\",\n  part: \"∂\",\n  exist: \"∃\",\n  empty: \"∅\",\n  nabla: \"∇\",\n  isin: \"∈\",\n  notin: \"∉\",\n  ni: \"∋\",\n  prod: \"∏\",\n  sum: \"∑\",\n  minus: \"−\",\n  lowast: \"∗\",\n  radic: \"√\",\n  prop: \"∝\",\n  infin: \"∞\",\n  ang: \"∠\",\n  and: \"∧\",\n  or: \"∨\",\n  cap: \"∩\",\n  cup: \"∪\",\n  'int': \"∫\",\n  there4: \"∴\",\n  sim: \"∼\",\n  cong: \"≅\",\n  asymp: \"≈\",\n  ne: \"≠\",\n  equiv: \"≡\",\n  le: \"≤\",\n  ge: \"≥\",\n  sub: \"⊂\",\n  sup: \"⊃\",\n  nsub: \"⊄\",\n  sube: \"⊆\",\n  supe: \"⊇\",\n  oplus: \"⊕\",\n  otimes: \"⊗\",\n  perp: \"⊥\",\n  sdot: \"⋅\",\n  Alpha: \"Α\",\n  Beta: \"Β\",\n  Gamma: \"Γ\",\n  Delta: \"Δ\",\n  Epsilon: \"Ε\",\n  Zeta: \"Ζ\",\n  Eta: \"Η\",\n  Theta: \"Θ\",\n  Iota: \"Ι\",\n  Kappa: \"Κ\",\n  Lambda: \"Λ\",\n  Mu: \"Μ\",\n  Nu: \"Ν\",\n  Xi: \"Ξ\",\n  Omicron: \"Ο\",\n  Pi: \"Π\",\n  Rho: \"Ρ\",\n  Sigma: \"Σ\",\n  Tau: \"Τ\",\n  Upsilon: \"Υ\",\n  Phi: \"Φ\",\n  Chi: \"Χ\",\n  Psi: \"Ψ\",\n  Omega: \"Ω\",\n  alpha: \"α\",\n  beta: \"β\",\n  gamma: \"γ\",\n  delta: \"δ\",\n  epsilon: \"ε\",\n  zeta: \"ζ\",\n  eta: \"η\",\n  theta: \"θ\",\n  iota: \"ι\",\n  kappa: \"κ\",\n  lambda: \"λ\",\n  mu: \"μ\",\n  nu: \"ν\",\n  xi: \"ξ\",\n  omicron: \"ο\",\n  pi: \"π\",\n  rho: \"ρ\",\n  sigmaf: \"ς\",\n  sigma: \"σ\",\n  tau: \"τ\",\n  upsilon: \"υ\",\n  phi: \"φ\",\n  chi: \"χ\",\n  psi: \"ψ\",\n  omega: \"ω\",\n  thetasym: \"ϑ\",\n  upsih: \"ϒ\",\n  piv: \"ϖ\",\n  OElig: \"Œ\",\n  oelig: \"œ\",\n  Scaron: \"Š\",\n  scaron: \"š\",\n  Yuml: \"Ÿ\",\n  fnof: \"ƒ\",\n  circ: \"ˆ\",\n  tilde: \"˜\",\n  ensp: \" \",\n  emsp: \" \",\n  thinsp: \" \",\n  zwnj: \"‌\",\n  zwj: \"‍\",\n  lrm: \"‎\",\n  rlm: \"‏\",\n  ndash: \"–\",\n  mdash: \"—\",\n  lsquo: \"‘\",\n  rsquo: \"’\",\n  sbquo: \"‚\",\n  ldquo: \"“\",\n  rdquo: \"”\",\n  bdquo: \"„\",\n  dagger: \"†\",\n  Dagger: \"‡\",\n  bull: \"•\",\n  hellip: \"…\",\n  permil: \"‰\",\n  prime: \"′\",\n  Prime: \"″\",\n  lsaquo: \"‹\",\n  rsaquo: \"›\",\n  oline: \"‾\",\n  euro: \"€\",\n  trade: \"™\",\n  larr: \"←\",\n  uarr: \"↑\",\n  rarr: \"→\",\n  darr: \"↓\",\n  harr: \"↔\",\n  crarr: \"↵\",\n  lceil: \"⌈\",\n  rceil: \"⌉\",\n  lfloor: \"⌊\",\n  rfloor: \"⌋\",\n  loz: \"◊\",\n  spades: \"♠\",\n  clubs: \"♣\",\n  hearts: \"♥\",\n  diams: \"♦\"\n});\n/**\n * @deprecated use `HTML_ENTITIES` instead\n * @see HTML_ENTITIES\n */\n\nexports.entityMap = exports.HTML_ENTITIES;","var dom = require('./dom');\n\nexports.DOMImplementation = dom.DOMImplementation;\nexports.XMLSerializer = dom.XMLSerializer;\nexports.DOMParser = require('./dom-parser').DOMParser;","var NAMESPACE = require(\"./conventions\").NAMESPACE; //[4]   \tNameStartChar\t   ::=   \t\":\" | [A-Z] | \"_\" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n//[4a]   \tNameChar\t   ::=   \tNameStartChar | \"-\" | \".\" | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]\n//[5]   \tName\t   ::=   \tNameStartChar (NameChar)*\n\n\nvar nameStartChar = /[A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/; //\\u10000-\\uEFFFF\n\nvar nameChar = new RegExp(\"[\\\\-\\\\.0-9\" + nameStartChar.source.slice(1, -1) + \"\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040]\");\nvar tagNamePattern = new RegExp('^' + nameStartChar.source + nameChar.source + '*(?:\\:' + nameStartChar.source + nameChar.source + '*)?$'); //var tagNamePattern = /^[a-zA-Z_][\\w\\-\\.]*(?:\\:[a-zA-Z_][\\w\\-\\.]*)?$/\n//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')\n//S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n//S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\n\nvar S_TAG = 0; //tag name offerring\n\nvar S_ATTR = 1; //attr name offerring \n\nvar S_ATTR_SPACE = 2; //attr name end and space offer\n\nvar S_EQ = 3; //=space?\n\nvar S_ATTR_NOQUOT_VALUE = 4; //attr value(no quot value only)\n\nvar S_ATTR_END = 5; //attr value end and no space(quot end)\n\nvar S_TAG_SPACE = 6; //(attr value end || tag end ) && (space offer)\n\nvar S_TAG_CLOSE = 7; //closed el<el />\n\n/**\n * Creates an error that will not be caught by XMLReader aka the SAX parser.\n *\n * @param {string} message\n * @param {any?} locator Optional, can provide details about the location in the source\n * @constructor\n */\n\nfunction ParseError(message, locator) {\n  this.message = message;\n  this.locator = locator;\n  if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);\n}\n\nParseError.prototype = new Error();\nParseError.prototype.name = ParseError.name;\n\nfunction XMLReader() {}\n\nXMLReader.prototype = {\n  parse: function parse(source, defaultNSMap, entityMap) {\n    var domBuilder = this.domBuilder;\n    domBuilder.startDocument();\n\n    _copy(defaultNSMap, defaultNSMap = {});\n\n    _parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);\n\n    domBuilder.endDocument();\n  }\n};\n\nfunction _parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {\n  function fixedFromCharCode(code) {\n    // String.prototype.fromCharCode does not supports\n    // > 2 bytes unicode chars directly\n    if (code > 0xffff) {\n      code -= 0x10000;\n      var surrogate1 = 0xd800 + (code >> 10),\n          surrogate2 = 0xdc00 + (code & 0x3ff);\n      return String.fromCharCode(surrogate1, surrogate2);\n    } else {\n      return String.fromCharCode(code);\n    }\n  }\n\n  function entityReplacer(a) {\n    var k = a.slice(1, -1);\n\n    if (k in entityMap) {\n      return entityMap[k];\n    } else if (k.charAt(0) === '#') {\n      return fixedFromCharCode(parseInt(k.substr(1).replace('x', '0x')));\n    } else {\n      errorHandler.error('entity not found:' + a);\n      return a;\n    }\n  }\n\n  function appendText(end) {\n    //has some bugs\n    if (end > start) {\n      var xt = source.substring(start, end).replace(/&#?\\w+;/g, entityReplacer);\n      locator && position(start);\n      domBuilder.characters(xt, 0, end - start);\n      start = end;\n    }\n  }\n\n  function position(p, m) {\n    while (p >= lineEnd && (m = linePattern.exec(source))) {\n      lineStart = m.index;\n      lineEnd = lineStart + m[0].length;\n      locator.lineNumber++; //console.log('line++:',locator,startPos,endPos)\n    }\n\n    locator.columnNumber = p - lineStart + 1;\n  }\n\n  var lineStart = 0;\n  var lineEnd = 0;\n  var linePattern = /.*(?:\\r\\n?|\\n)|.*$/g;\n  var locator = domBuilder.locator;\n  var parseStack = [{\n    currentNSMap: defaultNSMapCopy\n  }];\n  var closeMap = {};\n  var start = 0;\n\n  while (true) {\n    try {\n      var tagStart = source.indexOf('<', start);\n\n      if (tagStart < 0) {\n        if (!source.substr(start).match(/^\\s*$/)) {\n          var doc = domBuilder.doc;\n          var text = doc.createTextNode(source.substr(start));\n          doc.appendChild(text);\n          domBuilder.currentElement = text;\n        }\n\n        return;\n      }\n\n      if (tagStart > start) {\n        appendText(tagStart);\n      }\n\n      switch (source.charAt(tagStart + 1)) {\n        case '/':\n          var end = source.indexOf('>', tagStart + 3);\n          var tagName = source.substring(tagStart + 2, end).replace(/[ \\t\\n\\r]+$/g, '');\n          var config = parseStack.pop();\n\n          if (end < 0) {\n            tagName = source.substring(tagStart + 2).replace(/[\\s<].*/, '');\n            errorHandler.error(\"end tag name: \" + tagName + ' is not complete:' + config.tagName);\n            end = tagStart + 1 + tagName.length;\n          } else if (tagName.match(/\\s</)) {\n            tagName = tagName.replace(/[\\s<].*/, '');\n            errorHandler.error(\"end tag name: \" + tagName + ' maybe not complete');\n            end = tagStart + 1 + tagName.length;\n          }\n\n          var localNSMap = config.localNSMap;\n          var endMatch = config.tagName == tagName;\n          var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();\n\n          if (endIgnoreCaseMach) {\n            domBuilder.endElement(config.uri, config.localName, tagName);\n\n            if (localNSMap) {\n              for (var prefix in localNSMap) {\n                domBuilder.endPrefixMapping(prefix);\n              }\n            }\n\n            if (!endMatch) {\n              errorHandler.fatalError(\"end tag name: \" + tagName + ' is not match the current start tagName:' + config.tagName); // No known test case\n            }\n          } else {\n            parseStack.push(config);\n          }\n\n          end++;\n          break;\n        // end elment\n\n        case '?':\n          // <?...?>\n          locator && position(tagStart);\n          end = parseInstruction(source, tagStart, domBuilder);\n          break;\n\n        case '!':\n          // <!doctype,<![CDATA,<!--\n          locator && position(tagStart);\n          end = parseDCC(source, tagStart, domBuilder, errorHandler);\n          break;\n\n        default:\n          locator && position(tagStart);\n          var el = new ElementAttributes();\n          var currentNSMap = parseStack[parseStack.length - 1].currentNSMap; //elStartEnd\n\n          var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);\n          var len = el.length;\n\n          if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {\n            el.closed = true;\n\n            if (!entityMap.nbsp) {\n              errorHandler.warning('unclosed xml attribute');\n            }\n          }\n\n          if (locator && len) {\n            var locator2 = copyLocator(locator, {}); //try{//attribute position fixed\n\n            for (var i = 0; i < len; i++) {\n              var a = el[i];\n              position(a.offset);\n              a.locator = copyLocator(locator, {});\n            }\n\n            domBuilder.locator = locator2;\n\n            if (appendElement(el, domBuilder, currentNSMap)) {\n              parseStack.push(el);\n            }\n\n            domBuilder.locator = locator;\n          } else {\n            if (appendElement(el, domBuilder, currentNSMap)) {\n              parseStack.push(el);\n            }\n          }\n\n          if (NAMESPACE.isHTML(el.uri) && !el.closed) {\n            end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);\n          } else {\n            end++;\n          }\n\n      }\n    } catch (e) {\n      if (e instanceof ParseError) {\n        throw e;\n      }\n\n      errorHandler.error('element parse error: ' + e);\n      end = -1;\n    }\n\n    if (end > start) {\n      start = end;\n    } else {\n      //TODO: 这里有可能sax回退，有位置错误风险\n      appendText(Math.max(tagStart, start) + 1);\n    }\n  }\n}\n\nfunction copyLocator(f, t) {\n  t.lineNumber = f.lineNumber;\n  t.columnNumber = f.columnNumber;\n  return t;\n}\n/**\n * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);\n * @return end of the elementStartPart(end of elementEndPart for selfClosed el)\n */\n\n\nfunction parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {\n  /**\n   * @param {string} qname\n   * @param {string} value\n   * @param {number} startIndex\n   */\n  function addAttribute(qname, value, startIndex) {\n    if (el.attributeNames.hasOwnProperty(qname)) {\n      errorHandler.fatalError('Attribute ' + qname + ' redefined');\n    }\n\n    el.addValue(qname, value, startIndex);\n  }\n\n  var attrName;\n  var value;\n  var p = ++start;\n  var s = S_TAG; //status\n\n  while (true) {\n    var c = source.charAt(p);\n\n    switch (c) {\n      case '=':\n        if (s === S_ATTR) {\n          //attrName\n          attrName = source.slice(start, p);\n          s = S_EQ;\n        } else if (s === S_ATTR_SPACE) {\n          s = S_EQ;\n        } else {\n          //fatalError: equal must after attrName or space after attrName\n          throw new Error('attribute equal must after attrName'); // No known test case\n        }\n\n        break;\n\n      case '\\'':\n      case '\"':\n        if (s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE\n        ) {\n          //equal\n          if (s === S_ATTR) {\n            errorHandler.warning('attribute value must after \"=\"');\n            attrName = source.slice(start, p);\n          }\n\n          start = p + 1;\n          p = source.indexOf(c, start);\n\n          if (p > 0) {\n            value = source.slice(start, p).replace(/&#?\\w+;/g, entityReplacer);\n            addAttribute(attrName, value, start - 1);\n            s = S_ATTR_END;\n          } else {\n            //fatalError: no end quot match\n            throw new Error('attribute value no end \\'' + c + '\\' match');\n          }\n        } else if (s == S_ATTR_NOQUOT_VALUE) {\n          value = source.slice(start, p).replace(/&#?\\w+;/g, entityReplacer); //console.log(attrName,value,start,p)\n\n          addAttribute(attrName, value, start); //console.dir(el)\n\n          errorHandler.warning('attribute \"' + attrName + '\" missed start quot(' + c + ')!!');\n          start = p + 1;\n          s = S_ATTR_END;\n        } else {\n          //fatalError: no equal before\n          throw new Error('attribute value must after \"=\"'); // No known test case\n        }\n\n        break;\n\n      case '/':\n        switch (s) {\n          case S_TAG:\n            el.setTagName(source.slice(start, p));\n\n          case S_ATTR_END:\n          case S_TAG_SPACE:\n          case S_TAG_CLOSE:\n            s = S_TAG_CLOSE;\n            el.closed = true;\n\n          case S_ATTR_NOQUOT_VALUE:\n          case S_ATTR:\n          case S_ATTR_SPACE:\n            break;\n          //case S_EQ:\n\n          default:\n            throw new Error(\"attribute invalid close char('/')\");\n          // No known test case\n        }\n\n        break;\n\n      case '':\n        //end document\n        errorHandler.error('unexpected end of input');\n\n        if (s == S_TAG) {\n          el.setTagName(source.slice(start, p));\n        }\n\n        return p;\n\n      case '>':\n        switch (s) {\n          case S_TAG:\n            el.setTagName(source.slice(start, p));\n\n          case S_ATTR_END:\n          case S_TAG_SPACE:\n          case S_TAG_CLOSE:\n            break;\n          //normal\n\n          case S_ATTR_NOQUOT_VALUE: //Compatible state\n\n          case S_ATTR:\n            value = source.slice(start, p);\n\n            if (value.slice(-1) === '/') {\n              el.closed = true;\n              value = value.slice(0, -1);\n            }\n\n          case S_ATTR_SPACE:\n            if (s === S_ATTR_SPACE) {\n              value = attrName;\n            }\n\n            if (s == S_ATTR_NOQUOT_VALUE) {\n              errorHandler.warning('attribute \"' + value + '\" missed quot(\")!');\n              addAttribute(attrName, value.replace(/&#?\\w+;/g, entityReplacer), start);\n            } else {\n              if (!NAMESPACE.isHTML(currentNSMap['']) || !value.match(/^(?:disabled|checked|selected)$/i)) {\n                errorHandler.warning('attribute \"' + value + '\" missed value!! \"' + value + '\" instead!!');\n              }\n\n              addAttribute(value, value, start);\n            }\n\n            break;\n\n          case S_EQ:\n            throw new Error('attribute value missed!!');\n        } //\t\t\tconsole.log(tagName,tagNamePattern,tagNamePattern.test(tagName))\n\n\n        return p;\n\n      /*xml space '\\x20' | #x9 | #xD | #xA; */\n\n      case \"\\x80\":\n        c = ' ';\n\n      default:\n        if (c <= ' ') {\n          //space\n          switch (s) {\n            case S_TAG:\n              el.setTagName(source.slice(start, p)); //tagName\n\n              s = S_TAG_SPACE;\n              break;\n\n            case S_ATTR:\n              attrName = source.slice(start, p);\n              s = S_ATTR_SPACE;\n              break;\n\n            case S_ATTR_NOQUOT_VALUE:\n              var value = source.slice(start, p).replace(/&#?\\w+;/g, entityReplacer);\n              errorHandler.warning('attribute \"' + value + '\" missed quot(\")!!');\n              addAttribute(attrName, value, start);\n\n            case S_ATTR_END:\n              s = S_TAG_SPACE;\n              break;\n            //case S_TAG_SPACE:\n            //case S_EQ:\n            //case S_ATTR_SPACE:\n            //\tvoid();break;\n            //case S_TAG_CLOSE:\n            //ignore warning\n          }\n        } else {\n          //not space\n          //S_TAG,\tS_ATTR,\tS_EQ,\tS_ATTR_NOQUOT_VALUE\n          //S_ATTR_SPACE,\tS_ATTR_END,\tS_TAG_SPACE, S_TAG_CLOSE\n          switch (s) {\n            //case S_TAG:void();break;\n            //case S_ATTR:void();break;\n            //case S_ATTR_NOQUOT_VALUE:void();break;\n            case S_ATTR_SPACE:\n              var tagName = el.tagName;\n\n              if (!NAMESPACE.isHTML(currentNSMap['']) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {\n                errorHandler.warning('attribute \"' + attrName + '\" missed value!! \"' + attrName + '\" instead2!!');\n              }\n\n              addAttribute(attrName, attrName, start);\n              start = p;\n              s = S_ATTR;\n              break;\n\n            case S_ATTR_END:\n              errorHandler.warning('attribute space is required\"' + attrName + '\"!!');\n\n            case S_TAG_SPACE:\n              s = S_ATTR;\n              start = p;\n              break;\n\n            case S_EQ:\n              s = S_ATTR_NOQUOT_VALUE;\n              start = p;\n              break;\n\n            case S_TAG_CLOSE:\n              throw new Error(\"elements closed character '/' and '>' must be connected to\");\n          }\n        }\n\n    } //end outer switch\n    //console.log('p++',p)\n\n\n    p++;\n  }\n}\n/**\n * @return true if has new namespace define\n */\n\n\nfunction appendElement(el, domBuilder, currentNSMap) {\n  var tagName = el.tagName;\n  var localNSMap = null; //var currentNSMap = parseStack[parseStack.length-1].currentNSMap;\n\n  var i = el.length;\n\n  while (i--) {\n    var a = el[i];\n    var qName = a.qName;\n    var value = a.value;\n    var nsp = qName.indexOf(':');\n\n    if (nsp > 0) {\n      var prefix = a.prefix = qName.slice(0, nsp);\n      var localName = qName.slice(nsp + 1);\n      var nsPrefix = prefix === 'xmlns' && localName;\n    } else {\n      localName = qName;\n      prefix = null;\n      nsPrefix = qName === 'xmlns' && '';\n    } //can not set prefix,because prefix !== ''\n\n\n    a.localName = localName; //prefix == null for no ns prefix attribute \n\n    if (nsPrefix !== false) {\n      //hack!!\n      if (localNSMap == null) {\n        localNSMap = {}; //console.log(currentNSMap,0)\n\n        _copy(currentNSMap, currentNSMap = {}); //console.log(currentNSMap,1)\n\n      }\n\n      currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;\n      a.uri = NAMESPACE.XMLNS;\n      domBuilder.startPrefixMapping(nsPrefix, value);\n    }\n  }\n\n  var i = el.length;\n\n  while (i--) {\n    a = el[i];\n    var prefix = a.prefix;\n\n    if (prefix) {\n      //no prefix attribute has no namespace\n      if (prefix === 'xml') {\n        a.uri = NAMESPACE.XML;\n      }\n\n      if (prefix !== 'xmlns') {\n        a.uri = currentNSMap[prefix || '']; //{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}\n      }\n    }\n  }\n\n  var nsp = tagName.indexOf(':');\n\n  if (nsp > 0) {\n    prefix = el.prefix = tagName.slice(0, nsp);\n    localName = el.localName = tagName.slice(nsp + 1);\n  } else {\n    prefix = null; //important!!\n\n    localName = el.localName = tagName;\n  } //no prefix element has default namespace\n\n\n  var ns = el.uri = currentNSMap[prefix || ''];\n  domBuilder.startElement(ns, localName, tagName, el); //endPrefixMapping and startPrefixMapping have not any help for dom builder\n  //localNSMap = null\n\n  if (el.closed) {\n    domBuilder.endElement(ns, localName, tagName);\n\n    if (localNSMap) {\n      for (prefix in localNSMap) {\n        domBuilder.endPrefixMapping(prefix);\n      }\n    }\n  } else {\n    el.currentNSMap = currentNSMap;\n    el.localNSMap = localNSMap; //parseStack.push(el);\n\n    return true;\n  }\n}\n\nfunction parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {\n  if (/^(?:script|textarea)$/i.test(tagName)) {\n    var elEndStart = source.indexOf('</' + tagName + '>', elStartEnd);\n    var text = source.substring(elStartEnd + 1, elEndStart);\n\n    if (/[&<]/.test(text)) {\n      if (/^script$/i.test(tagName)) {\n        //if(!/\\]\\]>/.test(text)){\n        //lexHandler.startCDATA();\n        domBuilder.characters(text, 0, text.length); //lexHandler.endCDATA();\n\n        return elEndStart; //}\n      } //}else{//text area\n\n\n      text = text.replace(/&#?\\w+;/g, entityReplacer);\n      domBuilder.characters(text, 0, text.length);\n      return elEndStart; //}\n    }\n  }\n\n  return elStartEnd + 1;\n}\n\nfunction fixSelfClosed(source, elStartEnd, tagName, closeMap) {\n  //if(tagName in closeMap){\n  var pos = closeMap[tagName];\n\n  if (pos == null) {\n    //console.log(tagName)\n    pos = source.lastIndexOf('</' + tagName + '>');\n\n    if (pos < elStartEnd) {\n      //忘记闭合\n      pos = source.lastIndexOf('</' + tagName);\n    }\n\n    closeMap[tagName] = pos;\n  }\n\n  return pos < elStartEnd; //} \n}\n\nfunction _copy(source, target) {\n  for (var n in source) {\n    target[n] = source[n];\n  }\n}\n\nfunction parseDCC(source, start, domBuilder, errorHandler) {\n  //sure start with '<!'\n  var next = source.charAt(start + 2);\n\n  switch (next) {\n    case '-':\n      if (source.charAt(start + 3) === '-') {\n        var end = source.indexOf('-->', start + 4); //append comment source.substring(4,end)//<!--\n\n        if (end > start) {\n          domBuilder.comment(source, start + 4, end - start - 4);\n          return end + 3;\n        } else {\n          errorHandler.error(\"Unclosed comment\");\n          return -1;\n        }\n      } else {\n        //error\n        return -1;\n      }\n\n    default:\n      if (source.substr(start + 3, 6) == 'CDATA[') {\n        var end = source.indexOf(']]>', start + 9);\n        domBuilder.startCDATA();\n        domBuilder.characters(source, start + 9, end - start - 9);\n        domBuilder.endCDATA();\n        return end + 3;\n      } //<!DOCTYPE\n      //startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId) \n\n\n      var matchs = split(source, start);\n      var len = matchs.length;\n\n      if (len > 1 && /!doctype/i.test(matchs[0][0])) {\n        var name = matchs[1][0];\n        var pubid = false;\n        var sysid = false;\n\n        if (len > 3) {\n          if (/^public$/i.test(matchs[2][0])) {\n            pubid = matchs[3][0];\n            sysid = len > 4 && matchs[4][0];\n          } else if (/^system$/i.test(matchs[2][0])) {\n            sysid = matchs[3][0];\n          }\n        }\n\n        var lastMatch = matchs[len - 1];\n        domBuilder.startDTD(name, pubid, sysid);\n        domBuilder.endDTD();\n        return lastMatch.index + lastMatch[0].length;\n      }\n\n  }\n\n  return -1;\n}\n\nfunction parseInstruction(source, start, domBuilder) {\n  var end = source.indexOf('?>', start);\n\n  if (end) {\n    var match = source.substring(start, end).match(/^<\\?(\\S*)\\s*([\\s\\S]*?)\\s*$/);\n\n    if (match) {\n      var len = match[0].length;\n      domBuilder.processingInstruction(match[1], match[2]);\n      return end + 2;\n    } else {\n      //error\n      return -1;\n    }\n  }\n\n  return -1;\n}\n\nfunction ElementAttributes() {\n  this.attributeNames = {};\n}\n\nElementAttributes.prototype = {\n  setTagName: function setTagName(tagName) {\n    if (!tagNamePattern.test(tagName)) {\n      throw new Error('invalid tagName:' + tagName);\n    }\n\n    this.tagName = tagName;\n  },\n  addValue: function addValue(qName, value, offset) {\n    if (!tagNamePattern.test(qName)) {\n      throw new Error('invalid attribute:' + qName);\n    }\n\n    this.attributeNames[qName] = this.length;\n    this[this.length++] = {\n      qName: qName,\n      value: value,\n      offset: offset\n    };\n  },\n  length: 0,\n  getLocalName: function getLocalName(i) {\n    return this[i].localName;\n  },\n  getLocator: function getLocator(i) {\n    return this[i].locator;\n  },\n  getQName: function getQName(i) {\n    return this[i].qName;\n  },\n  getURI: function getURI(i) {\n    return this[i].uri;\n  },\n  getValue: function getValue(i) {\n    return this[i].value;\n  } //\t,getIndex:function(uri, localName)){\n  //\t\tif(localName){\n  //\t\t\t\n  //\t\t}else{\n  //\t\t\tvar qName = uri\n  //\t\t}\n  //\t},\n  //\tgetValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},\n  //\tgetType:function(uri,localName){}\n  //\tgetType:function(i){},\n\n};\n\nfunction split(source, start) {\n  var match;\n  var buf = [];\n  var reg = /'[^']+'|\"[^\"]+\"|[^\\s<>\\/=]+=?|(\\/?\\s*>|<)/g;\n  reg.lastIndex = start;\n  reg.exec(source); //skip <\n\n  while (match = reg.exec(source)) {\n    buf.push(match);\n    if (match[1]) return buf;\n  }\n}\n\nexports.XMLReader = XMLReader;\nexports.ParseError = ParseError;","var topLevel = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : {};\n\nvar minDoc = require('min-document');\n\nvar doccy;\n\nif (typeof document !== 'undefined') {\n  doccy = document;\n} else {\n  doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];\n\n  if (!doccy) {\n    doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;\n  }\n}\n\nmodule.exports = doccy;","var win;\n\nif (typeof window !== \"undefined\") {\n  win = window;\n} else if (typeof global !== \"undefined\") {\n  win = global;\n} else if (typeof self !== \"undefined\") {\n  win = self;\n} else {\n  win = {};\n}\n\nmodule.exports = win;","module.exports = isFunction;\nvar toString = Object.prototype.toString;\n\nfunction isFunction(fn) {\n  if (!fn) {\n    return false;\n  }\n\n  var string = toString.call(fn);\n  return string === '[object Function]' || typeof fn === 'function' && string !== '[object RegExp]' || typeof window !== 'undefined' && ( // IE8 and below\n  fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt);\n}\n\n;","// Source: http://jsfiddle.net/vWx8V/\n// http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes\n\n/**\n * Conenience method returns corresponding value for given keyName or keyCode.\n *\n * @param {Mixed} keyCode {Number} or keyName {String}\n * @return {Mixed}\n * @api public\n */\nfunction keyCode(searchInput) {\n  // Keyboard Events\n  if (searchInput && 'object' === typeof searchInput) {\n    var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode;\n    if (hasKeyCode) searchInput = hasKeyCode;\n  } // Numbers\n\n\n  if ('number' === typeof searchInput) return names[searchInput]; // Everything else (cast to string)\n\n  var search = String(searchInput); // check codes\n\n  var foundNamedKey = codes[search.toLowerCase()];\n  if (foundNamedKey) return foundNamedKey; // check aliases\n\n  var foundNamedKey = aliases[search.toLowerCase()];\n  if (foundNamedKey) return foundNamedKey; // weird character?\n\n  if (search.length === 1) return search.charCodeAt(0);\n  return undefined;\n}\n/**\n * Compares a keyboard event with a given keyCode or keyName.\n *\n * @param {Event} event Keyboard event that should be tested\n * @param {Mixed} keyCode {Number} or keyName {String}\n * @return {Boolean}\n * @api public\n */\n\n\nkeyCode.isEventKey = function isEventKey(event, nameOrCode) {\n  if (event && 'object' === typeof event) {\n    var keyCode = event.which || event.keyCode || event.charCode;\n\n    if (keyCode === null || keyCode === undefined) {\n      return false;\n    }\n\n    if (typeof nameOrCode === 'string') {\n      // check codes\n      var foundNamedKey = codes[nameOrCode.toLowerCase()];\n\n      if (foundNamedKey) {\n        return foundNamedKey === keyCode;\n      } // check aliases\n\n\n      var foundNamedKey = aliases[nameOrCode.toLowerCase()];\n\n      if (foundNamedKey) {\n        return foundNamedKey === keyCode;\n      }\n    } else if (typeof nameOrCode === 'number') {\n      return nameOrCode === keyCode;\n    }\n\n    return false;\n  }\n};\n\nexports = module.exports = keyCode;\n/**\n * Get by name\n *\n *   exports.code['enter'] // => 13\n */\n\nvar codes = exports.code = exports.codes = {\n  'backspace': 8,\n  'tab': 9,\n  'enter': 13,\n  'shift': 16,\n  'ctrl': 17,\n  'alt': 18,\n  'pause/break': 19,\n  'caps lock': 20,\n  'esc': 27,\n  'space': 32,\n  'page up': 33,\n  'page down': 34,\n  'end': 35,\n  'home': 36,\n  'left': 37,\n  'up': 38,\n  'right': 39,\n  'down': 40,\n  'insert': 45,\n  'delete': 46,\n  'command': 91,\n  'left command': 91,\n  'right command': 93,\n  'numpad *': 106,\n  'numpad +': 107,\n  'numpad -': 109,\n  'numpad .': 110,\n  'numpad /': 111,\n  'num lock': 144,\n  'scroll lock': 145,\n  'my computer': 182,\n  'my calculator': 183,\n  ';': 186,\n  '=': 187,\n  ',': 188,\n  '-': 189,\n  '.': 190,\n  '/': 191,\n  '`': 192,\n  '[': 219,\n  '\\\\': 220,\n  ']': 221,\n  \"'\": 222\n}; // Helper aliases\n\nvar aliases = exports.aliases = {\n  'windows': 91,\n  '⇧': 16,\n  '⌥': 18,\n  '⌃': 17,\n  '⌘': 91,\n  'ctl': 17,\n  'control': 17,\n  'option': 18,\n  'pause': 19,\n  'break': 19,\n  'caps': 20,\n  'return': 13,\n  'escape': 27,\n  'spc': 32,\n  'spacebar': 32,\n  'pgup': 33,\n  'pgdn': 34,\n  'ins': 45,\n  'del': 46,\n  'cmd': 91\n};\n/*!\n * Programatically add the following\n */\n// lower case chars\n\nfor (i = 97; i < 123; i++) {\n  codes[String.fromCharCode(i)] = i - 32;\n} // numbers\n\n\nfor (var i = 48; i < 58; i++) {\n  codes[i - 48] = i;\n} // function keys\n\n\nfor (i = 1; i < 13; i++) {\n  codes['f' + i] = i + 111;\n} // numpad keys\n\n\nfor (i = 0; i < 10; i++) {\n  codes['numpad ' + i] = i + 96;\n}\n/**\n * Get by code\n *\n *   exports.name[13] // => 'Enter'\n */\n\n\nvar names = exports.names = exports.title = {}; // title for backward compat\n// Create reverse mapping\n\nfor (i in codes) {\n  names[codes[i]] = i;\n} // Add aliases\n\n\nfor (var alias in aliases) {\n  codes[alias] = aliases[alias];\n}","/**\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 };","/*! @name m3u8-parser @version 4.7.0 @license Apache-2.0 */\nimport _inheritsLoose from '@babel/runtime/helpers/inheritsLoose';\nimport Stream from '@videojs/vhs-utils/es/stream.js';\nimport _extends from '@babel/runtime/helpers/extends';\nimport _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';\nimport decodeB64ToUint8Array from '@videojs/vhs-utils/es/decode-b64-to-uint8-array.js';\n/**\n * A stream that buffers string input and generates a `data` event for each\n * line.\n *\n * @class LineStream\n * @extends Stream\n */\n\nvar LineStream = /*#__PURE__*/function (_Stream) {\n  _inheritsLoose(LineStream, _Stream);\n\n  function LineStream() {\n    var _this;\n\n    _this = _Stream.call(this) || this;\n    _this.buffer = '';\n    return _this;\n  }\n  /**\n   * Add new data to be parsed.\n   *\n   * @param {string} data the text to process\n   */\n\n\n  var _proto = LineStream.prototype;\n\n  _proto.push = function push(data) {\n    var nextNewline;\n    this.buffer += data;\n    nextNewline = this.buffer.indexOf('\\n');\n\n    for (; nextNewline > -1; nextNewline = this.buffer.indexOf('\\n')) {\n      this.trigger('data', this.buffer.substring(0, nextNewline));\n      this.buffer = this.buffer.substring(nextNewline + 1);\n    }\n  };\n\n  return LineStream;\n}(Stream);\n\nvar TAB = String.fromCharCode(0x09);\n\nvar parseByterange = function parseByterange(byterangeString) {\n  // optionally match and capture 0+ digits before `@`\n  // optionally match and capture 0+ digits after `@`\n  var match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangeString || '');\n  var result = {};\n\n  if (match[1]) {\n    result.length = parseInt(match[1], 10);\n  }\n\n  if (match[2]) {\n    result.offset = parseInt(match[2], 10);\n  }\n\n  return result;\n};\n/**\n * \"forgiving\" attribute list psuedo-grammar:\n * attributes -> keyvalue (',' keyvalue)*\n * keyvalue   -> key '=' value\n * key        -> [^=]*\n * value      -> '\"' [^\"]* '\"' | [^,]*\n */\n\n\nvar attributeSeparator = function attributeSeparator() {\n  var key = '[^=]*';\n  var value = '\"[^\"]*\"|[^,]*';\n  var keyvalue = '(?:' + key + ')=(?:' + value + ')';\n  return new RegExp('(?:^|,)(' + keyvalue + ')');\n};\n/**\n * Parse attributes from a line given the separator\n *\n * @param {string} attributes the attribute line to parse\n */\n\n\nvar parseAttributes = function parseAttributes(attributes) {\n  // split the string using attributes as the separator\n  var attrs = attributes.split(attributeSeparator());\n  var result = {};\n  var i = attrs.length;\n  var attr;\n\n  while (i--) {\n    // filter out unmatched portions of the string\n    if (attrs[i] === '') {\n      continue;\n    } // split the key and value\n\n\n    attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1); // trim whitespace and remove optional quotes around the value\n\n    attr[0] = attr[0].replace(/^\\s+|\\s+$/g, '');\n    attr[1] = attr[1].replace(/^\\s+|\\s+$/g, '');\n    attr[1] = attr[1].replace(/^['\"](.*)['\"]$/g, '$1');\n    result[attr[0]] = attr[1];\n  }\n\n  return result;\n};\n/**\n * A line-level M3U8 parser event stream. It expects to receive input one\n * line at a time and performs a context-free parse of its contents. A stream\n * interpretation of a manifest can be useful if the manifest is expected to\n * be too large to fit comfortably into memory or the entirety of the input\n * is not immediately available. Otherwise, it's probably much easier to work\n * with a regular `Parser` object.\n *\n * Produces `data` events with an object that captures the parser's\n * interpretation of the input. That object has a property `tag` that is one\n * of `uri`, `comment`, or `tag`. URIs only have a single additional\n * property, `line`, which captures the entirety of the input without\n * interpretation. Comments similarly have a single additional property\n * `text` which is the input without the leading `#`.\n *\n * Tags always have a property `tagType` which is the lower-cased version of\n * the M3U8 directive without the `#EXT` or `#EXT-X-` prefix. For instance,\n * `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized\n * tags are given the tag type `unknown` and a single additional property\n * `data` with the remainder of the input.\n *\n * @class ParseStream\n * @extends Stream\n */\n\n\nvar ParseStream = /*#__PURE__*/function (_Stream) {\n  _inheritsLoose(ParseStream, _Stream);\n\n  function ParseStream() {\n    var _this;\n\n    _this = _Stream.call(this) || this;\n    _this.customParsers = [];\n    _this.tagMappers = [];\n    return _this;\n  }\n  /**\n   * Parses an additional line of input.\n   *\n   * @param {string} line a single line of an M3U8 file to parse\n   */\n\n\n  var _proto = ParseStream.prototype;\n\n  _proto.push = function push(line) {\n    var _this2 = this;\n\n    var match;\n    var event; // strip whitespace\n\n    line = line.trim();\n\n    if (line.length === 0) {\n      // ignore empty lines\n      return;\n    } // URIs\n\n\n    if (line[0] !== '#') {\n      this.trigger('data', {\n        type: 'uri',\n        uri: line\n      });\n      return;\n    } // map tags\n\n\n    var newLines = this.tagMappers.reduce(function (acc, mapper) {\n      var mappedLine = mapper(line); // skip if unchanged\n\n      if (mappedLine === line) {\n        return acc;\n      }\n\n      return acc.concat([mappedLine]);\n    }, [line]);\n    newLines.forEach(function (newLine) {\n      for (var i = 0; i < _this2.customParsers.length; i++) {\n        if (_this2.customParsers[i].call(_this2, newLine)) {\n          return;\n        }\n      } // Comments\n\n\n      if (newLine.indexOf('#EXT') !== 0) {\n        _this2.trigger('data', {\n          type: 'comment',\n          text: newLine.slice(1)\n        });\n\n        return;\n      } // strip off any carriage returns here so the regex matching\n      // doesn't have to account for them.\n\n\n      newLine = newLine.replace('\\r', ''); // Tags\n\n      match = /^#EXTM3U/.exec(newLine);\n\n      if (match) {\n        _this2.trigger('data', {\n          type: 'tag',\n          tagType: 'm3u'\n        });\n\n        return;\n      }\n\n      match = /^#EXTINF:?([0-9\\.]*)?,?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'inf'\n        };\n\n        if (match[1]) {\n          event.duration = parseFloat(match[1]);\n        }\n\n        if (match[2]) {\n          event.title = match[2];\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-TARGETDURATION:?([0-9.]*)?/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'targetduration'\n        };\n\n        if (match[1]) {\n          event.duration = parseInt(match[1], 10);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-VERSION:?([0-9.]*)?/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'version'\n        };\n\n        if (match[1]) {\n          event.version = parseInt(match[1], 10);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-MEDIA-SEQUENCE:?(\\-?[0-9.]*)?/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'media-sequence'\n        };\n\n        if (match[1]) {\n          event.number = parseInt(match[1], 10);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-DISCONTINUITY-SEQUENCE:?(\\-?[0-9.]*)?/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'discontinuity-sequence'\n        };\n\n        if (match[1]) {\n          event.number = parseInt(match[1], 10);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-PLAYLIST-TYPE:?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'playlist-type'\n        };\n\n        if (match[1]) {\n          event.playlistType = match[1];\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-BYTERANGE:?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = _extends(parseByterange(match[1]), {\n          type: 'tag',\n          tagType: 'byterange'\n        });\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-ALLOW-CACHE:?(YES|NO)?/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'allow-cache'\n        };\n\n        if (match[1]) {\n          event.allowed = !/NO/.test(match[1]);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-MAP:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'map'\n        };\n\n        if (match[1]) {\n          var attributes = parseAttributes(match[1]);\n\n          if (attributes.URI) {\n            event.uri = attributes.URI;\n          }\n\n          if (attributes.BYTERANGE) {\n            event.byterange = parseByterange(attributes.BYTERANGE);\n          }\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-STREAM-INF:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'stream-inf'\n        };\n\n        if (match[1]) {\n          event.attributes = parseAttributes(match[1]);\n\n          if (event.attributes.RESOLUTION) {\n            var split = event.attributes.RESOLUTION.split('x');\n            var resolution = {};\n\n            if (split[0]) {\n              resolution.width = parseInt(split[0], 10);\n            }\n\n            if (split[1]) {\n              resolution.height = parseInt(split[1], 10);\n            }\n\n            event.attributes.RESOLUTION = resolution;\n          }\n\n          if (event.attributes.BANDWIDTH) {\n            event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);\n          }\n\n          if (event.attributes['PROGRAM-ID']) {\n            event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);\n          }\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-MEDIA:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'media'\n        };\n\n        if (match[1]) {\n          event.attributes = parseAttributes(match[1]);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-ENDLIST/.exec(newLine);\n\n      if (match) {\n        _this2.trigger('data', {\n          type: 'tag',\n          tagType: 'endlist'\n        });\n\n        return;\n      }\n\n      match = /^#EXT-X-DISCONTINUITY/.exec(newLine);\n\n      if (match) {\n        _this2.trigger('data', {\n          type: 'tag',\n          tagType: 'discontinuity'\n        });\n\n        return;\n      }\n\n      match = /^#EXT-X-PROGRAM-DATE-TIME:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'program-date-time'\n        };\n\n        if (match[1]) {\n          event.dateTimeString = match[1];\n          event.dateTimeObject = new Date(match[1]);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-KEY:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'key'\n        };\n\n        if (match[1]) {\n          event.attributes = parseAttributes(match[1]); // parse the IV string into a Uint32Array\n\n          if (event.attributes.IV) {\n            if (event.attributes.IV.substring(0, 2).toLowerCase() === '0x') {\n              event.attributes.IV = event.attributes.IV.substring(2);\n            }\n\n            event.attributes.IV = event.attributes.IV.match(/.{8}/g);\n            event.attributes.IV[0] = parseInt(event.attributes.IV[0], 16);\n            event.attributes.IV[1] = parseInt(event.attributes.IV[1], 16);\n            event.attributes.IV[2] = parseInt(event.attributes.IV[2], 16);\n            event.attributes.IV[3] = parseInt(event.attributes.IV[3], 16);\n            event.attributes.IV = new Uint32Array(event.attributes.IV);\n          }\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-START:?(.*)$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'start'\n        };\n\n        if (match[1]) {\n          event.attributes = parseAttributes(match[1]);\n          event.attributes['TIME-OFFSET'] = parseFloat(event.attributes['TIME-OFFSET']);\n          event.attributes.PRECISE = /YES/.test(event.attributes.PRECISE);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-CUE-OUT-CONT:?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'cue-out-cont'\n        };\n\n        if (match[1]) {\n          event.data = match[1];\n        } else {\n          event.data = '';\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-CUE-OUT:?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'cue-out'\n        };\n\n        if (match[1]) {\n          event.data = match[1];\n        } else {\n          event.data = '';\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-CUE-IN:?(.*)?$/.exec(newLine);\n\n      if (match) {\n        event = {\n          type: 'tag',\n          tagType: 'cue-in'\n        };\n\n        if (match[1]) {\n          event.data = match[1];\n        } else {\n          event.data = '';\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-SKIP:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'skip'\n        };\n        event.attributes = parseAttributes(match[1]);\n\n        if (event.attributes.hasOwnProperty('SKIPPED-SEGMENTS')) {\n          event.attributes['SKIPPED-SEGMENTS'] = parseInt(event.attributes['SKIPPED-SEGMENTS'], 10);\n        }\n\n        if (event.attributes.hasOwnProperty('RECENTLY-REMOVED-DATERANGES')) {\n          event.attributes['RECENTLY-REMOVED-DATERANGES'] = event.attributes['RECENTLY-REMOVED-DATERANGES'].split(TAB);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-PART:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'part'\n        };\n        event.attributes = parseAttributes(match[1]);\n        ['DURATION'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = parseFloat(event.attributes[key]);\n          }\n        });\n        ['INDEPENDENT', 'GAP'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = /YES/.test(event.attributes[key]);\n          }\n        });\n\n        if (event.attributes.hasOwnProperty('BYTERANGE')) {\n          event.attributes.byterange = parseByterange(event.attributes.BYTERANGE);\n        }\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-SERVER-CONTROL:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'server-control'\n        };\n        event.attributes = parseAttributes(match[1]);\n        ['CAN-SKIP-UNTIL', 'PART-HOLD-BACK', 'HOLD-BACK'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = parseFloat(event.attributes[key]);\n          }\n        });\n        ['CAN-SKIP-DATERANGES', 'CAN-BLOCK-RELOAD'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = /YES/.test(event.attributes[key]);\n          }\n        });\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-PART-INF:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'part-inf'\n        };\n        event.attributes = parseAttributes(match[1]);\n        ['PART-TARGET'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = parseFloat(event.attributes[key]);\n          }\n        });\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-PRELOAD-HINT:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'preload-hint'\n        };\n        event.attributes = parseAttributes(match[1]);\n        ['BYTERANGE-START', 'BYTERANGE-LENGTH'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = parseInt(event.attributes[key], 10);\n            var subkey = key === 'BYTERANGE-LENGTH' ? 'length' : 'offset';\n            event.attributes.byterange = event.attributes.byterange || {};\n            event.attributes.byterange[subkey] = event.attributes[key]; // only keep the parsed byterange object.\n\n            delete event.attributes[key];\n          }\n        });\n\n        _this2.trigger('data', event);\n\n        return;\n      }\n\n      match = /^#EXT-X-RENDITION-REPORT:(.*)$/.exec(newLine);\n\n      if (match && match[1]) {\n        event = {\n          type: 'tag',\n          tagType: 'rendition-report'\n        };\n        event.attributes = parseAttributes(match[1]);\n        ['LAST-MSN', 'LAST-PART'].forEach(function (key) {\n          if (event.attributes.hasOwnProperty(key)) {\n            event.attributes[key] = parseInt(event.attributes[key], 10);\n          }\n        });\n\n        _this2.trigger('data', event);\n\n        return;\n      } // unknown tag type\n\n\n      _this2.trigger('data', {\n        type: 'tag',\n        data: newLine.slice(4)\n      });\n    });\n  }\n  /**\n   * Add a parser for custom headers\n   *\n   * @param {Object}   options              a map of options for the added parser\n   * @param {RegExp}   options.expression   a regular expression to match the custom header\n   * @param {string}   options.customType   the custom type to register to the output\n   * @param {Function} [options.dataParser] function to parse the line into an object\n   * @param {boolean}  [options.segment]    should tag data be attached to the segment object\n   */\n  ;\n\n  _proto.addParser = function addParser(_ref) {\n    var _this3 = this;\n\n    var expression = _ref.expression,\n        customType = _ref.customType,\n        dataParser = _ref.dataParser,\n        segment = _ref.segment;\n\n    if (typeof dataParser !== 'function') {\n      dataParser = function dataParser(line) {\n        return line;\n      };\n    }\n\n    this.customParsers.push(function (line) {\n      var match = expression.exec(line);\n\n      if (match) {\n        _this3.trigger('data', {\n          type: 'custom',\n          data: dataParser(line),\n          customType: customType,\n          segment: segment\n        });\n\n        return true;\n      }\n    });\n  }\n  /**\n   * Add a custom header mapper\n   *\n   * @param {Object}   options\n   * @param {RegExp}   options.expression   a regular expression to match the custom header\n   * @param {Function} options.map          function to translate tag into a different tag\n   */\n  ;\n\n  _proto.addTagMapper = function addTagMapper(_ref2) {\n    var expression = _ref2.expression,\n        map = _ref2.map;\n\n    var mapFn = function mapFn(line) {\n      if (expression.test(line)) {\n        return map(line);\n      }\n\n      return line;\n    };\n\n    this.tagMappers.push(mapFn);\n  };\n\n  return ParseStream;\n}(Stream);\n\nvar camelCase = function camelCase(str) {\n  return str.toLowerCase().replace(/-(\\w)/g, function (a) {\n    return a[1].toUpperCase();\n  });\n};\n\nvar camelCaseKeys = function camelCaseKeys(attributes) {\n  var result = {};\n  Object.keys(attributes).forEach(function (key) {\n    result[camelCase(key)] = attributes[key];\n  });\n  return result;\n}; // set SERVER-CONTROL hold back based upon targetDuration and partTargetDuration\n// we need this helper because defaults are based upon targetDuration and\n// partTargetDuration being set, but they may not be if SERVER-CONTROL appears before\n// target durations are set.\n\n\nvar setHoldBack = function setHoldBack(manifest) {\n  var serverControl = manifest.serverControl,\n      targetDuration = manifest.targetDuration,\n      partTargetDuration = manifest.partTargetDuration;\n\n  if (!serverControl) {\n    return;\n  }\n\n  var tag = '#EXT-X-SERVER-CONTROL';\n  var hb = 'holdBack';\n  var phb = 'partHoldBack';\n  var minTargetDuration = targetDuration && targetDuration * 3;\n  var minPartDuration = partTargetDuration && partTargetDuration * 2;\n\n  if (targetDuration && !serverControl.hasOwnProperty(hb)) {\n    serverControl[hb] = minTargetDuration;\n    this.trigger('info', {\n      message: tag + \" defaulting HOLD-BACK to targetDuration * 3 (\" + minTargetDuration + \").\"\n    });\n  }\n\n  if (minTargetDuration && serverControl[hb] < minTargetDuration) {\n    this.trigger('warn', {\n      message: tag + \" clamping HOLD-BACK (\" + serverControl[hb] + \") to targetDuration * 3 (\" + minTargetDuration + \")\"\n    });\n    serverControl[hb] = minTargetDuration;\n  } // default no part hold back to part target duration * 3\n\n\n  if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {\n    serverControl[phb] = partTargetDuration * 3;\n    this.trigger('info', {\n      message: tag + \" defaulting PART-HOLD-BACK to partTargetDuration * 3 (\" + serverControl[phb] + \").\"\n    });\n  } // if part hold back is too small default it to part target duration * 2\n\n\n  if (partTargetDuration && serverControl[phb] < minPartDuration) {\n    this.trigger('warn', {\n      message: tag + \" clamping PART-HOLD-BACK (\" + serverControl[phb] + \") to partTargetDuration * 2 (\" + minPartDuration + \").\"\n    });\n    serverControl[phb] = minPartDuration;\n  }\n};\n/**\n * A parser for M3U8 files. The current interpretation of the input is\n * exposed as a property `manifest` on parser objects. It's just two lines to\n * create and parse a manifest once you have the contents available as a string:\n *\n * ```js\n * var parser = new m3u8.Parser();\n * parser.push(xhr.responseText);\n * ```\n *\n * New input can later be applied to update the manifest object by calling\n * `push` again.\n *\n * The parser attempts to create a usable manifest object even if the\n * underlying input is somewhat nonsensical. It emits `info` and `warning`\n * events during the parse if it encounters input that seems invalid or\n * requires some property of the manifest object to be defaulted.\n *\n * @class Parser\n * @extends Stream\n */\n\n\nvar Parser = /*#__PURE__*/function (_Stream) {\n  _inheritsLoose(Parser, _Stream);\n\n  function Parser() {\n    var _this;\n\n    _this = _Stream.call(this) || this;\n    _this.lineStream = new LineStream();\n    _this.parseStream = new ParseStream();\n\n    _this.lineStream.pipe(_this.parseStream);\n    /* eslint-disable consistent-this */\n\n\n    var self = _assertThisInitialized(_this);\n    /* eslint-enable consistent-this */\n\n\n    var uris = [];\n    var currentUri = {}; // if specified, the active EXT-X-MAP definition\n\n    var currentMap; // if specified, the active decryption key\n\n    var _key;\n\n    var hasParts = false;\n\n    var noop = function noop() {};\n\n    var defaultMediaGroups = {\n      'AUDIO': {},\n      'VIDEO': {},\n      'CLOSED-CAPTIONS': {},\n      'SUBTITLES': {}\n    }; // This is the Widevine UUID from DASH IF IOP. The same exact string is\n    // used in MPDs with Widevine encrypted streams.\n\n    var widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities\n\n    var currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data\n\n    _this.manifest = {\n      allowCache: true,\n      discontinuityStarts: [],\n      segments: []\n    }; // keep track of the last seen segment's byte range end, as segments are not required\n    // to provide the offset, in which case it defaults to the next byte after the\n    // previous segment\n\n    var lastByterangeEnd = 0; // keep track of the last seen part's byte range end.\n\n    var lastPartByterangeEnd = 0;\n\n    _this.on('end', function () {\n      // only add preloadSegment if we don't yet have a uri for it.\n      // and we actually have parts/preloadHints\n      if (currentUri.uri || !currentUri.parts && !currentUri.preloadHints) {\n        return;\n      }\n\n      if (!currentUri.map && currentMap) {\n        currentUri.map = currentMap;\n      }\n\n      if (!currentUri.key && _key) {\n        currentUri.key = _key;\n      }\n\n      if (!currentUri.timeline && typeof currentTimeline === 'number') {\n        currentUri.timeline = currentTimeline;\n      }\n\n      _this.manifest.preloadSegment = currentUri;\n    }); // update the manifest with the m3u8 entry from the parse stream\n\n\n    _this.parseStream.on('data', function (entry) {\n      var mediaGroup;\n      var rendition;\n      ({\n        tag: function tag() {\n          // switch based on the tag type\n          (({\n            version: function version() {\n              if (entry.version) {\n                this.manifest.version = entry.version;\n              }\n            },\n            'allow-cache': function allowCache() {\n              this.manifest.allowCache = entry.allowed;\n\n              if (!('allowed' in entry)) {\n                this.trigger('info', {\n                  message: 'defaulting allowCache to YES'\n                });\n                this.manifest.allowCache = true;\n              }\n            },\n            byterange: function byterange() {\n              var byterange = {};\n\n              if ('length' in entry) {\n                currentUri.byterange = byterange;\n                byterange.length = entry.length;\n\n                if (!('offset' in entry)) {\n                  /*\n                   * From the latest spec (as of this writing):\n                   * https://tools.ietf.org/html/draft-pantos-http-live-streaming-23#section-4.3.2.2\n                   *\n                   * Same text since EXT-X-BYTERANGE's introduction in draft 7:\n                   * https://tools.ietf.org/html/draft-pantos-http-live-streaming-07#section-3.3.1)\n                   *\n                   * \"If o [offset] is not present, the sub-range begins at the next byte\n                   * following the sub-range of the previous media segment.\"\n                   */\n                  entry.offset = lastByterangeEnd;\n                }\n              }\n\n              if ('offset' in entry) {\n                currentUri.byterange = byterange;\n                byterange.offset = entry.offset;\n              }\n\n              lastByterangeEnd = byterange.offset + byterange.length;\n            },\n            endlist: function endlist() {\n              this.manifest.endList = true;\n            },\n            inf: function inf() {\n              if (!('mediaSequence' in this.manifest)) {\n                this.manifest.mediaSequence = 0;\n                this.trigger('info', {\n                  message: 'defaulting media sequence to zero'\n                });\n              }\n\n              if (!('discontinuitySequence' in this.manifest)) {\n                this.manifest.discontinuitySequence = 0;\n                this.trigger('info', {\n                  message: 'defaulting discontinuity sequence to zero'\n                });\n              }\n\n              if (entry.duration > 0) {\n                currentUri.duration = entry.duration;\n              }\n\n              if (entry.duration === 0) {\n                currentUri.duration = 0.01;\n                this.trigger('info', {\n                  message: 'updating zero segment duration to a small value'\n                });\n              }\n\n              this.manifest.segments = uris;\n            },\n            key: function key() {\n              if (!entry.attributes) {\n                this.trigger('warn', {\n                  message: 'ignoring key declaration without attribute list'\n                });\n                return;\n              } // clear the active encryption key\n\n\n              if (entry.attributes.METHOD === 'NONE') {\n                _key = null;\n                return;\n              }\n\n              if (!entry.attributes.URI) {\n                this.trigger('warn', {\n                  message: 'ignoring key declaration without URI'\n                });\n                return;\n              }\n\n              if (entry.attributes.KEYFORMAT === 'com.apple.streamingkeydelivery') {\n                this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.\n\n                this.manifest.contentProtection['com.apple.fps.1_0'] = {\n                  attributes: entry.attributes\n                };\n                return;\n              } // check if the content is encrypted for Widevine\n              // Widevine/HLS spec: https://storage.googleapis.com/wvdocs/Widevine_DRM_HLS.pdf\n\n\n              if (entry.attributes.KEYFORMAT === widevineUuid) {\n                var VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];\n\n                if (VALID_METHODS.indexOf(entry.attributes.METHOD) === -1) {\n                  this.trigger('warn', {\n                    message: 'invalid key method provided for Widevine'\n                  });\n                  return;\n                }\n\n                if (entry.attributes.METHOD === 'SAMPLE-AES-CENC') {\n                  this.trigger('warn', {\n                    message: 'SAMPLE-AES-CENC is deprecated, please use SAMPLE-AES-CTR instead'\n                  });\n                }\n\n                if (entry.attributes.URI.substring(0, 23) !== 'data:text/plain;base64,') {\n                  this.trigger('warn', {\n                    message: 'invalid key URI provided for Widevine'\n                  });\n                  return;\n                }\n\n                if (!(entry.attributes.KEYID && entry.attributes.KEYID.substring(0, 2) === '0x')) {\n                  this.trigger('warn', {\n                    message: 'invalid key ID provided for Widevine'\n                  });\n                  return;\n                } // if Widevine key attributes are valid, store them as `contentProtection`\n                // on the manifest to emulate Widevine tag structure in a DASH mpd\n\n\n                this.manifest.contentProtection = this.manifest.contentProtection || {};\n                this.manifest.contentProtection['com.widevine.alpha'] = {\n                  attributes: {\n                    schemeIdUri: entry.attributes.KEYFORMAT,\n                    // remove '0x' from the key id string\n                    keyId: entry.attributes.KEYID.substring(2)\n                  },\n                  // decode the base64-encoded PSSH box\n                  pssh: decodeB64ToUint8Array(entry.attributes.URI.split(',')[1])\n                };\n                return;\n              }\n\n              if (!entry.attributes.METHOD) {\n                this.trigger('warn', {\n                  message: 'defaulting key method to AES-128'\n                });\n              } // setup an encryption key for upcoming segments\n\n\n              _key = {\n                method: entry.attributes.METHOD || 'AES-128',\n                uri: entry.attributes.URI\n              };\n\n              if (typeof entry.attributes.IV !== 'undefined') {\n                _key.iv = entry.attributes.IV;\n              }\n            },\n            'media-sequence': function mediaSequence() {\n              if (!isFinite(entry.number)) {\n                this.trigger('warn', {\n                  message: 'ignoring invalid media sequence: ' + entry.number\n                });\n                return;\n              }\n\n              this.manifest.mediaSequence = entry.number;\n            },\n            'discontinuity-sequence': function discontinuitySequence() {\n              if (!isFinite(entry.number)) {\n                this.trigger('warn', {\n                  message: 'ignoring invalid discontinuity sequence: ' + entry.number\n                });\n                return;\n              }\n\n              this.manifest.discontinuitySequence = entry.number;\n              currentTimeline = entry.number;\n            },\n            'playlist-type': function playlistType() {\n              if (!/VOD|EVENT/.test(entry.playlistType)) {\n                this.trigger('warn', {\n                  message: 'ignoring unknown playlist type: ' + entry.playlist\n                });\n                return;\n              }\n\n              this.manifest.playlistType = entry.playlistType;\n            },\n            map: function map() {\n              currentMap = {};\n\n              if (entry.uri) {\n                currentMap.uri = entry.uri;\n              }\n\n              if (entry.byterange) {\n                currentMap.byterange = entry.byterange;\n              }\n\n              if (_key) {\n                currentMap.key = _key;\n              }\n            },\n            'stream-inf': function streamInf() {\n              this.manifest.playlists = uris;\n              this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;\n\n              if (!entry.attributes) {\n                this.trigger('warn', {\n                  message: 'ignoring empty stream-inf attributes'\n                });\n                return;\n              }\n\n              if (!currentUri.attributes) {\n                currentUri.attributes = {};\n              }\n\n              _extends(currentUri.attributes, entry.attributes);\n            },\n            media: function media() {\n              this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;\n\n              if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {\n                this.trigger('warn', {\n                  message: 'ignoring incomplete or missing media group'\n                });\n                return;\n              } // find the media group, creating defaults as necessary\n\n\n              var mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];\n              mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};\n              mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']]; // collect the rendition metadata\n\n              rendition = {\n                default: /yes/i.test(entry.attributes.DEFAULT)\n              };\n\n              if (rendition.default) {\n                rendition.autoselect = true;\n              } else {\n                rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);\n              }\n\n              if (entry.attributes.LANGUAGE) {\n                rendition.language = entry.attributes.LANGUAGE;\n              }\n\n              if (entry.attributes.URI) {\n                rendition.uri = entry.attributes.URI;\n              }\n\n              if (entry.attributes['INSTREAM-ID']) {\n                rendition.instreamId = entry.attributes['INSTREAM-ID'];\n              }\n\n              if (entry.attributes.CHARACTERISTICS) {\n                rendition.characteristics = entry.attributes.CHARACTERISTICS;\n              }\n\n              if (entry.attributes.FORCED) {\n                rendition.forced = /yes/i.test(entry.attributes.FORCED);\n              } // insert the new rendition\n\n\n              mediaGroup[entry.attributes.NAME] = rendition;\n            },\n            discontinuity: function discontinuity() {\n              currentTimeline += 1;\n              currentUri.discontinuity = true;\n              this.manifest.discontinuityStarts.push(uris.length);\n            },\n            'program-date-time': function programDateTime() {\n              if (typeof this.manifest.dateTimeString === 'undefined') {\n                // PROGRAM-DATE-TIME is a media-segment tag, but for backwards\n                // compatibility, we add the first occurence of the PROGRAM-DATE-TIME tag\n                // to the manifest object\n                // TODO: Consider removing this in future major version\n                this.manifest.dateTimeString = entry.dateTimeString;\n                this.manifest.dateTimeObject = entry.dateTimeObject;\n              }\n\n              currentUri.dateTimeString = entry.dateTimeString;\n              currentUri.dateTimeObject = entry.dateTimeObject;\n            },\n            targetduration: function targetduration() {\n              if (!isFinite(entry.duration) || entry.duration < 0) {\n                this.trigger('warn', {\n                  message: 'ignoring invalid target duration: ' + entry.duration\n                });\n                return;\n              }\n\n              this.manifest.targetDuration = entry.duration;\n              setHoldBack.call(this, this.manifest);\n            },\n            start: function start() {\n              if (!entry.attributes || isNaN(entry.attributes['TIME-OFFSET'])) {\n                this.trigger('warn', {\n                  message: 'ignoring start declaration without appropriate attribute list'\n                });\n                return;\n              }\n\n              this.manifest.start = {\n                timeOffset: entry.attributes['TIME-OFFSET'],\n                precise: entry.attributes.PRECISE\n              };\n            },\n            'cue-out': function cueOut() {\n              currentUri.cueOut = entry.data;\n            },\n            'cue-out-cont': function cueOutCont() {\n              currentUri.cueOutCont = entry.data;\n            },\n            'cue-in': function cueIn() {\n              currentUri.cueIn = entry.data;\n            },\n            'skip': function skip() {\n              this.manifest.skip = camelCaseKeys(entry.attributes);\n              this.warnOnMissingAttributes_('#EXT-X-SKIP', entry.attributes, ['SKIPPED-SEGMENTS']);\n            },\n            'part': function part() {\n              var _this2 = this;\n\n              hasParts = true; // parts are always specifed before a segment\n\n              var segmentIndex = this.manifest.segments.length;\n              var part = camelCaseKeys(entry.attributes);\n              currentUri.parts = currentUri.parts || [];\n              currentUri.parts.push(part);\n\n              if (part.byterange) {\n                if (!part.byterange.hasOwnProperty('offset')) {\n                  part.byterange.offset = lastPartByterangeEnd;\n                }\n\n                lastPartByterangeEnd = part.byterange.offset + part.byterange.length;\n              }\n\n              var partIndex = currentUri.parts.length - 1;\n              this.warnOnMissingAttributes_(\"#EXT-X-PART #\" + partIndex + \" for segment #\" + segmentIndex, entry.attributes, ['URI', 'DURATION']);\n\n              if (this.manifest.renditionReports) {\n                this.manifest.renditionReports.forEach(function (r, i) {\n                  if (!r.hasOwnProperty('lastPart')) {\n                    _this2.trigger('warn', {\n                      message: \"#EXT-X-RENDITION-REPORT #\" + i + \" lacks required attribute(s): LAST-PART\"\n                    });\n                  }\n                });\n              }\n            },\n            'server-control': function serverControl() {\n              var attrs = this.manifest.serverControl = camelCaseKeys(entry.attributes);\n\n              if (!attrs.hasOwnProperty('canBlockReload')) {\n                attrs.canBlockReload = false;\n                this.trigger('info', {\n                  message: '#EXT-X-SERVER-CONTROL defaulting CAN-BLOCK-RELOAD to false'\n                });\n              }\n\n              setHoldBack.call(this, this.manifest);\n\n              if (attrs.canSkipDateranges && !attrs.hasOwnProperty('canSkipUntil')) {\n                this.trigger('warn', {\n                  message: '#EXT-X-SERVER-CONTROL lacks required attribute CAN-SKIP-UNTIL which is required when CAN-SKIP-DATERANGES is set'\n                });\n              }\n            },\n            'preload-hint': function preloadHint() {\n              // parts are always specifed before a segment\n              var segmentIndex = this.manifest.segments.length;\n              var hint = camelCaseKeys(entry.attributes);\n              var isPart = hint.type && hint.type === 'PART';\n              currentUri.preloadHints = currentUri.preloadHints || [];\n              currentUri.preloadHints.push(hint);\n\n              if (hint.byterange) {\n                if (!hint.byterange.hasOwnProperty('offset')) {\n                  // use last part byterange end or zero if not a part.\n                  hint.byterange.offset = isPart ? lastPartByterangeEnd : 0;\n\n                  if (isPart) {\n                    lastPartByterangeEnd = hint.byterange.offset + hint.byterange.length;\n                  }\n                }\n              }\n\n              var index = currentUri.preloadHints.length - 1;\n              this.warnOnMissingAttributes_(\"#EXT-X-PRELOAD-HINT #\" + index + \" for segment #\" + segmentIndex, entry.attributes, ['TYPE', 'URI']);\n\n              if (!hint.type) {\n                return;\n              } // search through all preload hints except for the current one for\n              // a duplicate type.\n\n\n              for (var i = 0; i < currentUri.preloadHints.length - 1; i++) {\n                var otherHint = currentUri.preloadHints[i];\n\n                if (!otherHint.type) {\n                  continue;\n                }\n\n                if (otherHint.type === hint.type) {\n                  this.trigger('warn', {\n                    message: \"#EXT-X-PRELOAD-HINT #\" + index + \" for segment #\" + segmentIndex + \" has the same TYPE \" + hint.type + \" as preload hint #\" + i\n                  });\n                }\n              }\n            },\n            'rendition-report': function renditionReport() {\n              var report = camelCaseKeys(entry.attributes);\n              this.manifest.renditionReports = this.manifest.renditionReports || [];\n              this.manifest.renditionReports.push(report);\n              var index = this.manifest.renditionReports.length - 1;\n              var required = ['LAST-MSN', 'URI'];\n\n              if (hasParts) {\n                required.push('LAST-PART');\n              }\n\n              this.warnOnMissingAttributes_(\"#EXT-X-RENDITION-REPORT #\" + index, entry.attributes, required);\n            },\n            'part-inf': function partInf() {\n              this.manifest.partInf = camelCaseKeys(entry.attributes);\n              this.warnOnMissingAttributes_('#EXT-X-PART-INF', entry.attributes, ['PART-TARGET']);\n\n              if (this.manifest.partInf.partTarget) {\n                this.manifest.partTargetDuration = this.manifest.partInf.partTarget;\n              }\n\n              setHoldBack.call(this, this.manifest);\n            }\n          })[entry.tagType] || noop).call(self);\n        },\n        uri: function uri() {\n          currentUri.uri = entry.uri;\n          uris.push(currentUri); // if no explicit duration was declared, use the target duration\n\n          if (this.manifest.targetDuration && !('duration' in currentUri)) {\n            this.trigger('warn', {\n              message: 'defaulting segment duration to the target duration'\n            });\n            currentUri.duration = this.manifest.targetDuration;\n          } // annotate with encryption information, if necessary\n\n\n          if (_key) {\n            currentUri.key = _key;\n          }\n\n          currentUri.timeline = currentTimeline; // annotate with initialization segment information, if necessary\n\n          if (currentMap) {\n            currentUri.map = currentMap;\n          } // reset the last byterange end as it needs to be 0 between parts\n\n\n          lastPartByterangeEnd = 0; // prepare for the next URI\n\n          currentUri = {};\n        },\n        comment: function comment() {// comments are not important for playback\n        },\n        custom: function custom() {\n          // if this is segment-level data attach the output to the segment\n          if (entry.segment) {\n            currentUri.custom = currentUri.custom || {};\n            currentUri.custom[entry.customType] = entry.data; // if this is manifest-level data attach to the top level manifest object\n          } else {\n            this.manifest.custom = this.manifest.custom || {};\n            this.manifest.custom[entry.customType] = entry.data;\n          }\n        }\n      })[entry.type].call(self);\n    });\n\n    return _this;\n  }\n\n  var _proto = Parser.prototype;\n\n  _proto.warnOnMissingAttributes_ = function warnOnMissingAttributes_(identifier, attributes, required) {\n    var missing = [];\n    required.forEach(function (key) {\n      if (!attributes.hasOwnProperty(key)) {\n        missing.push(key);\n      }\n    });\n\n    if (missing.length) {\n      this.trigger('warn', {\n        message: identifier + \" lacks required attribute(s): \" + missing.join(', ')\n      });\n    }\n  }\n  /**\n   * Parse the input string and update the manifest object.\n   *\n   * @param {string} chunk a potentially incomplete portion of the manifest\n   */\n  ;\n\n  _proto.push = function push(chunk) {\n    this.lineStream.push(chunk);\n  }\n  /**\n   * Flush any remaining input. This can be handy if the last line of an M3U8\n   * manifest did not contain a trailing newline but the file has been\n   * completely received.\n   */\n  ;\n\n  _proto.end = function end() {\n    // flush any buffered input\n    this.lineStream.push('\\n');\n    this.trigger('end');\n  }\n  /**\n   * Add an additional parser for non-standard tags\n   *\n   * @param {Object}   options              a map of options for the added parser\n   * @param {RegExp}   options.expression   a regular expression to match the custom header\n   * @param {string}   options.type         the type to register to the output\n   * @param {Function} [options.dataParser] function to parse the line into an object\n   * @param {boolean}  [options.segment]    should tag data be attached to the segment object\n   */\n  ;\n\n  _proto.addParser = function addParser(options) {\n    this.parseStream.addParser(options);\n  }\n  /**\n   * Add a custom header mapper\n   *\n   * @param {Object}   options\n   * @param {RegExp}   options.expression   a regular expression to match the custom header\n   * @param {Function} options.map          function to translate tag into a different tag\n   */\n  ;\n\n  _proto.addTagMapper = function addTagMapper(options) {\n    this.parseStream.addTagMapper(options);\n  };\n\n  return Parser;\n}(Stream);\n\nexport { LineStream, ParseStream, Parser };","/*! @name mpd-parser @version 0.19.2 @license Apache-2.0 */\nimport resolveUrl from '@videojs/vhs-utils/es/resolve-url';\nimport window from 'global/window';\nimport decodeB64ToUint8Array from '@videojs/vhs-utils/es/decode-b64-to-uint8-array';\nimport { DOMParser } from '@xmldom/xmldom';\nvar version = \"0.19.2\";\n\nvar isObject = function isObject(obj) {\n  return !!obj && typeof obj === 'object';\n};\n\nvar merge = function merge() {\n  for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {\n    objects[_key] = arguments[_key];\n  }\n\n  return objects.reduce(function (result, source) {\n    if (typeof source !== 'object') {\n      return result;\n    }\n\n    Object.keys(source).forEach(function (key) {\n      if (Array.isArray(result[key]) && Array.isArray(source[key])) {\n        result[key] = result[key].concat(source[key]);\n      } else if (isObject(result[key]) && isObject(source[key])) {\n        result[key] = merge(result[key], source[key]);\n      } else {\n        result[key] = source[key];\n      }\n    });\n    return result;\n  }, {});\n};\n\nvar values = function values(o) {\n  return Object.keys(o).map(function (k) {\n    return o[k];\n  });\n};\n\nvar range = function range(start, end) {\n  var result = [];\n\n  for (var i = start; i < end; i++) {\n    result.push(i);\n  }\n\n  return result;\n};\n\nvar flatten = function flatten(lists) {\n  return lists.reduce(function (x, y) {\n    return x.concat(y);\n  }, []);\n};\n\nvar from = function from(list) {\n  if (!list.length) {\n    return [];\n  }\n\n  var result = [];\n\n  for (var i = 0; i < list.length; i++) {\n    result.push(list[i]);\n  }\n\n  return result;\n};\n\nvar findIndexes = function findIndexes(l, key) {\n  return l.reduce(function (a, e, i) {\n    if (e[key]) {\n      a.push(i);\n    }\n\n    return a;\n  }, []);\n};\n\nvar errors = {\n  INVALID_NUMBER_OF_PERIOD: 'INVALID_NUMBER_OF_PERIOD',\n  DASH_EMPTY_MANIFEST: 'DASH_EMPTY_MANIFEST',\n  DASH_INVALID_XML: 'DASH_INVALID_XML',\n  NO_BASE_URL: 'NO_BASE_URL',\n  MISSING_SEGMENT_INFORMATION: 'MISSING_SEGMENT_INFORMATION',\n  SEGMENT_TIME_UNSPECIFIED: 'SEGMENT_TIME_UNSPECIFIED',\n  UNSUPPORTED_UTC_TIMING_SCHEME: 'UNSUPPORTED_UTC_TIMING_SCHEME'\n};\n/**\n * @typedef {Object} SingleUri\n * @property {string} uri - relative location of segment\n * @property {string} resolvedUri - resolved location of segment\n * @property {Object} byterange - Object containing information on how to make byte range\n *   requests following byte-range-spec per RFC2616.\n * @property {String} byterange.length - length of range request\n * @property {String} byterange.offset - byte offset of range request\n *\n * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1\n */\n\n/**\n * Converts a URLType node (5.3.9.2.3 Table 13) to a segment object\n * that conforms to how m3u8-parser is structured\n *\n * @see https://github.com/videojs/m3u8-parser\n *\n * @param {string} baseUrl - baseUrl provided by <BaseUrl> nodes\n * @param {string} source - source url for segment\n * @param {string} range - optional range used for range calls,\n *   follows  RFC 2616, Clause 14.35.1\n * @return {SingleUri} full segment information transformed into a format similar\n *   to m3u8-parser\n */\n\nvar urlTypeToSegment = function urlTypeToSegment(_ref) {\n  var _ref$baseUrl = _ref.baseUrl,\n      baseUrl = _ref$baseUrl === void 0 ? '' : _ref$baseUrl,\n      _ref$source = _ref.source,\n      source = _ref$source === void 0 ? '' : _ref$source,\n      _ref$range = _ref.range,\n      range = _ref$range === void 0 ? '' : _ref$range,\n      _ref$indexRange = _ref.indexRange,\n      indexRange = _ref$indexRange === void 0 ? '' : _ref$indexRange;\n  var segment = {\n    uri: source,\n    resolvedUri: resolveUrl(baseUrl || '', source)\n  };\n\n  if (range || indexRange) {\n    var rangeStr = range ? range : indexRange;\n    var ranges = rangeStr.split('-');\n    var startRange = parseInt(ranges[0], 10);\n    var endRange = parseInt(ranges[1], 10); // byterange should be inclusive according to\n    // RFC 2616, Clause 14.35.1\n\n    segment.byterange = {\n      length: endRange - startRange + 1,\n      offset: startRange\n    };\n  }\n\n  return segment;\n};\n\nvar byteRangeToString = function byteRangeToString(byterange) {\n  // `endRange` is one less than `offset + length` because the HTTP range\n  // header uses inclusive ranges\n  var endRange = byterange.offset + byterange.length - 1;\n  return byterange.offset + \"-\" + endRange;\n};\n/**\n * parse the end number attribue that can be a string\n * number, or undefined.\n *\n * @param {string|number|undefined} endNumber\n *        The end number attribute.\n *\n * @return {number|null}\n *          The result of parsing the end number.\n */\n\n\nvar parseEndNumber = function parseEndNumber(endNumber) {\n  if (endNumber && typeof endNumber !== 'number') {\n    endNumber = parseInt(endNumber, 10);\n  }\n\n  if (isNaN(endNumber)) {\n    return null;\n  }\n\n  return endNumber;\n};\n/**\n * Functions for calculating the range of available segments in static and dynamic\n * manifests.\n */\n\n\nvar segmentRange = {\n  /**\n   * Returns the entire range of available segments for a static MPD\n   *\n   * @param {Object} attributes\n   *        Inheritied MPD attributes\n   * @return {{ start: number, end: number }}\n   *         The start and end numbers for available segments\n   */\n  static: function _static(attributes) {\n    var duration = attributes.duration,\n        _attributes$timescale = attributes.timescale,\n        timescale = _attributes$timescale === void 0 ? 1 : _attributes$timescale,\n        sourceDuration = attributes.sourceDuration,\n        periodDuration = attributes.periodDuration;\n    var endNumber = parseEndNumber(attributes.endNumber);\n    var segmentDuration = duration / timescale;\n\n    if (typeof endNumber === 'number') {\n      return {\n        start: 0,\n        end: endNumber\n      };\n    }\n\n    if (typeof periodDuration === 'number') {\n      return {\n        start: 0,\n        end: periodDuration / segmentDuration\n      };\n    }\n\n    return {\n      start: 0,\n      end: sourceDuration / segmentDuration\n    };\n  },\n\n  /**\n   * Returns the current live window range of available segments for a dynamic MPD\n   *\n   * @param {Object} attributes\n   *        Inheritied MPD attributes\n   * @return {{ start: number, end: number }}\n   *         The start and end numbers for available segments\n   */\n  dynamic: function dynamic(attributes) {\n    var NOW = attributes.NOW,\n        clientOffset = attributes.clientOffset,\n        availabilityStartTime = attributes.availabilityStartTime,\n        _attributes$timescale2 = attributes.timescale,\n        timescale = _attributes$timescale2 === void 0 ? 1 : _attributes$timescale2,\n        duration = attributes.duration,\n        _attributes$start = attributes.start,\n        start = _attributes$start === void 0 ? 0 : _attributes$start,\n        _attributes$minimumUp = attributes.minimumUpdatePeriod,\n        minimumUpdatePeriod = _attributes$minimumUp === void 0 ? 0 : _attributes$minimumUp,\n        _attributes$timeShift = attributes.timeShiftBufferDepth,\n        timeShiftBufferDepth = _attributes$timeShift === void 0 ? Infinity : _attributes$timeShift;\n    var endNumber = parseEndNumber(attributes.endNumber);\n    var now = (NOW + clientOffset) / 1000;\n    var periodStartWC = availabilityStartTime + start;\n    var periodEndWC = now + minimumUpdatePeriod;\n    var periodDuration = periodEndWC - periodStartWC;\n    var segmentCount = Math.ceil(periodDuration * timescale / duration);\n    var availableStart = Math.floor((now - periodStartWC - timeShiftBufferDepth) * timescale / duration);\n    var availableEnd = Math.floor((now - periodStartWC) * timescale / duration);\n    return {\n      start: Math.max(0, availableStart),\n      end: typeof endNumber === 'number' ? endNumber : Math.min(segmentCount, availableEnd)\n    };\n  }\n};\n/**\n * Maps a range of numbers to objects with information needed to build the corresponding\n * segment list\n *\n * @name toSegmentsCallback\n * @function\n * @param {number} number\n *        Number of the segment\n * @param {number} index\n *        Index of the number in the range list\n * @return {{ number: Number, duration: Number, timeline: Number, time: Number }}\n *         Object with segment timing and duration info\n */\n\n/**\n * Returns a callback for Array.prototype.map for mapping a range of numbers to\n * information needed to build the segment list.\n *\n * @param {Object} attributes\n *        Inherited MPD attributes\n * @return {toSegmentsCallback}\n *         Callback map function\n */\n\nvar toSegments = function toSegments(attributes) {\n  return function (number, index) {\n    var duration = attributes.duration,\n        _attributes$timescale3 = attributes.timescale,\n        timescale = _attributes$timescale3 === void 0 ? 1 : _attributes$timescale3,\n        periodIndex = attributes.periodIndex,\n        _attributes$startNumb = attributes.startNumber,\n        startNumber = _attributes$startNumb === void 0 ? 1 : _attributes$startNumb;\n    return {\n      number: startNumber + number,\n      duration: duration / timescale,\n      timeline: periodIndex,\n      time: index * duration\n    };\n  };\n};\n/**\n * Returns a list of objects containing segment timing and duration info used for\n * building the list of segments. This uses the @duration attribute specified\n * in the MPD manifest to derive the range of segments.\n *\n * @param {Object} attributes\n *        Inherited MPD attributes\n * @return {{number: number, duration: number, time: number, timeline: number}[]}\n *         List of Objects with segment timing and duration info\n */\n\n\nvar parseByDuration = function parseByDuration(attributes) {\n  var type = attributes.type,\n      duration = attributes.duration,\n      _attributes$timescale4 = attributes.timescale,\n      timescale = _attributes$timescale4 === void 0 ? 1 : _attributes$timescale4,\n      periodDuration = attributes.periodDuration,\n      sourceDuration = attributes.sourceDuration;\n\n  var _segmentRange$type = segmentRange[type](attributes),\n      start = _segmentRange$type.start,\n      end = _segmentRange$type.end;\n\n  var segments = range(start, end).map(toSegments(attributes));\n\n  if (type === 'static') {\n    var index = segments.length - 1; // section is either a period or the full source\n\n    var sectionDuration = typeof periodDuration === 'number' ? periodDuration : sourceDuration; // final segment may be less than full segment duration\n\n    segments[index].duration = sectionDuration - duration / timescale * index;\n  }\n\n  return segments;\n};\n/**\n * Translates SegmentBase into a set of segments.\n * (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each\n * node should be translated into segment.\n *\n * @param {Object} attributes\n *   Object containing all inherited attributes from parent elements with attribute\n *   names as keys\n * @return {Object.<Array>} list of segments\n */\n\n\nvar segmentsFromBase = function segmentsFromBase(attributes) {\n  var baseUrl = attributes.baseUrl,\n      _attributes$initializ = attributes.initialization,\n      initialization = _attributes$initializ === void 0 ? {} : _attributes$initializ,\n      sourceDuration = attributes.sourceDuration,\n      _attributes$indexRang = attributes.indexRange,\n      indexRange = _attributes$indexRang === void 0 ? '' : _attributes$indexRang,\n      duration = attributes.duration; // base url is required for SegmentBase to work, per spec (Section 5.3.9.2.1)\n\n  if (!baseUrl) {\n    throw new Error(errors.NO_BASE_URL);\n  }\n\n  var initSegment = urlTypeToSegment({\n    baseUrl: baseUrl,\n    source: initialization.sourceURL,\n    range: initialization.range\n  });\n  var segment = urlTypeToSegment({\n    baseUrl: baseUrl,\n    source: baseUrl,\n    indexRange: indexRange\n  });\n  segment.map = initSegment; // If there is a duration, use it, otherwise use the given duration of the source\n  // (since SegmentBase is only for one total segment)\n\n  if (duration) {\n    var segmentTimeInfo = parseByDuration(attributes);\n\n    if (segmentTimeInfo.length) {\n      segment.duration = segmentTimeInfo[0].duration;\n      segment.timeline = segmentTimeInfo[0].timeline;\n    }\n  } else if (sourceDuration) {\n    segment.duration = sourceDuration;\n    segment.timeline = 0;\n  } // This is used for mediaSequence\n\n\n  segment.number = 0;\n  return [segment];\n};\n/**\n * Given a playlist, a sidx box, and a baseUrl, update the segment list of the playlist\n * according to the sidx information given.\n *\n * playlist.sidx has metadadata about the sidx where-as the sidx param\n * is the parsed sidx box itself.\n *\n * @param {Object} playlist the playlist to update the sidx information for\n * @param {Object} sidx the parsed sidx box\n * @return {Object} the playlist object with the updated sidx information\n */\n\n\nvar addSidxSegmentsToPlaylist = function addSidxSegmentsToPlaylist(playlist, sidx, baseUrl) {\n  // Retain init segment information\n  var initSegment = playlist.sidx.map ? playlist.sidx.map : null; // Retain source duration from initial main manifest parsing\n\n  var sourceDuration = playlist.sidx.duration; // Retain source timeline\n\n  var timeline = playlist.timeline || 0;\n  var sidxByteRange = playlist.sidx.byterange;\n  var sidxEnd = sidxByteRange.offset + sidxByteRange.length; // Retain timescale of the parsed sidx\n\n  var timescale = sidx.timescale; // referenceType 1 refers to other sidx boxes\n\n  var mediaReferences = sidx.references.filter(function (r) {\n    return r.referenceType !== 1;\n  });\n  var segments = [];\n  var type = playlist.endList ? 'static' : 'dynamic'; // firstOffset is the offset from the end of the sidx box\n\n  var startIndex = sidxEnd + sidx.firstOffset;\n\n  for (var i = 0; i < mediaReferences.length; i++) {\n    var reference = sidx.references[i]; // size of the referenced (sub)segment\n\n    var size = reference.referencedSize; // duration of the referenced (sub)segment, in  the  timescale\n    // this will be converted to seconds when generating segments\n\n    var duration = reference.subsegmentDuration; // should be an inclusive range\n\n    var endIndex = startIndex + size - 1;\n    var indexRange = startIndex + \"-\" + endIndex;\n    var attributes = {\n      baseUrl: baseUrl,\n      timescale: timescale,\n      timeline: timeline,\n      // this is used in parseByDuration\n      periodIndex: timeline,\n      duration: duration,\n      sourceDuration: sourceDuration,\n      indexRange: indexRange,\n      type: type\n    };\n    var segment = segmentsFromBase(attributes)[0];\n\n    if (initSegment) {\n      segment.map = initSegment;\n    }\n\n    segments.push(segment);\n    startIndex += size;\n  }\n\n  playlist.segments = segments;\n  return playlist;\n};\n\nvar generateSidxKey = function generateSidxKey(sidx) {\n  return sidx && sidx.uri + '-' + byteRangeToString(sidx.byterange);\n};\n\nvar mergeDiscontiguousPlaylists = function mergeDiscontiguousPlaylists(playlists) {\n  var mergedPlaylists = values(playlists.reduce(function (acc, playlist) {\n    // assuming playlist IDs are the same across periods\n    // TODO: handle multiperiod where representation sets are not the same\n    // across periods\n    var name = playlist.attributes.id + (playlist.attributes.lang || ''); // Periods after first\n\n    if (acc[name]) {\n      var _acc$name$segments; // first segment of subsequent periods signal a discontinuity\n\n\n      if (playlist.segments[0]) {\n        playlist.segments[0].discontinuity = true;\n      }\n\n      (_acc$name$segments = acc[name].segments).push.apply(_acc$name$segments, playlist.segments); // bubble up contentProtection, this assumes all DRM content\n      // has the same contentProtection\n\n\n      if (playlist.attributes.contentProtection) {\n        acc[name].attributes.contentProtection = playlist.attributes.contentProtection;\n      }\n    } else {\n      // first Period\n      acc[name] = playlist;\n    }\n\n    return acc;\n  }, {}));\n  return mergedPlaylists.map(function (playlist) {\n    playlist.discontinuityStarts = findIndexes(playlist.segments, 'discontinuity');\n    return playlist;\n  });\n};\n\nvar addSidxSegmentsToPlaylist$1 = function addSidxSegmentsToPlaylist$1(playlist, sidxMapping) {\n  var sidxKey = generateSidxKey(playlist.sidx);\n  var sidxMatch = sidxKey && sidxMapping[sidxKey] && sidxMapping[sidxKey].sidx;\n\n  if (sidxMatch) {\n    addSidxSegmentsToPlaylist(playlist, sidxMatch, playlist.sidx.resolvedUri);\n  }\n\n  return playlist;\n};\n\nvar addSidxSegmentsToPlaylists = function addSidxSegmentsToPlaylists(playlists, sidxMapping) {\n  if (sidxMapping === void 0) {\n    sidxMapping = {};\n  }\n\n  if (!Object.keys(sidxMapping).length) {\n    return playlists;\n  }\n\n  for (var i in playlists) {\n    playlists[i] = addSidxSegmentsToPlaylist$1(playlists[i], sidxMapping);\n  }\n\n  return playlists;\n};\n\nvar formatAudioPlaylist = function formatAudioPlaylist(_ref, isAudioOnly) {\n  var _attributes;\n\n  var attributes = _ref.attributes,\n      segments = _ref.segments,\n      sidx = _ref.sidx;\n  var playlist = {\n    attributes: (_attributes = {\n      NAME: attributes.id,\n      BANDWIDTH: attributes.bandwidth,\n      CODECS: attributes.codecs\n    }, _attributes['PROGRAM-ID'] = 1, _attributes),\n    uri: '',\n    endList: attributes.type === 'static',\n    timeline: attributes.periodIndex,\n    resolvedUri: '',\n    targetDuration: attributes.duration,\n    segments: segments,\n    mediaSequence: segments.length ? segments[0].number : 1\n  };\n\n  if (attributes.contentProtection) {\n    playlist.contentProtection = attributes.contentProtection;\n  }\n\n  if (sidx) {\n    playlist.sidx = sidx;\n  }\n\n  if (isAudioOnly) {\n    playlist.attributes.AUDIO = 'audio';\n    playlist.attributes.SUBTITLES = 'subs';\n  }\n\n  return playlist;\n};\n\nvar formatVttPlaylist = function formatVttPlaylist(_ref2) {\n  var _m3u8Attributes;\n\n  var attributes = _ref2.attributes,\n      segments = _ref2.segments;\n\n  if (typeof segments === 'undefined') {\n    // vtt tracks may use single file in BaseURL\n    segments = [{\n      uri: attributes.baseUrl,\n      timeline: attributes.periodIndex,\n      resolvedUri: attributes.baseUrl || '',\n      duration: attributes.sourceDuration,\n      number: 0\n    }]; // targetDuration should be the same duration as the only segment\n\n    attributes.duration = attributes.sourceDuration;\n  }\n\n  var m3u8Attributes = (_m3u8Attributes = {\n    NAME: attributes.id,\n    BANDWIDTH: attributes.bandwidth\n  }, _m3u8Attributes['PROGRAM-ID'] = 1, _m3u8Attributes);\n\n  if (attributes.codecs) {\n    m3u8Attributes.CODECS = attributes.codecs;\n  }\n\n  return {\n    attributes: m3u8Attributes,\n    uri: '',\n    endList: attributes.type === 'static',\n    timeline: attributes.periodIndex,\n    resolvedUri: attributes.baseUrl || '',\n    targetDuration: attributes.duration,\n    segments: segments,\n    mediaSequence: segments.length ? segments[0].number : 1\n  };\n};\n\nvar organizeAudioPlaylists = function organizeAudioPlaylists(playlists, sidxMapping, isAudioOnly) {\n  if (sidxMapping === void 0) {\n    sidxMapping = {};\n  }\n\n  if (isAudioOnly === void 0) {\n    isAudioOnly = false;\n  }\n\n  var mainPlaylist;\n  var formattedPlaylists = playlists.reduce(function (a, playlist) {\n    var role = playlist.attributes.role && playlist.attributes.role.value || '';\n    var language = playlist.attributes.lang || '';\n    var label = playlist.attributes.label || 'main';\n\n    if (language && !playlist.attributes.label) {\n      var roleLabel = role ? \" (\" + role + \")\" : '';\n      label = \"\" + playlist.attributes.lang + roleLabel;\n    }\n\n    if (!a[label]) {\n      a[label] = {\n        language: language,\n        autoselect: true,\n        default: role === 'main',\n        playlists: [],\n        uri: ''\n      };\n    }\n\n    var formatted = addSidxSegmentsToPlaylist$1(formatAudioPlaylist(playlist, isAudioOnly), sidxMapping);\n    a[label].playlists.push(formatted);\n\n    if (typeof mainPlaylist === 'undefined' && role === 'main') {\n      mainPlaylist = playlist;\n      mainPlaylist.default = true;\n    }\n\n    return a;\n  }, {}); // if no playlists have role \"main\", mark the first as main\n\n  if (!mainPlaylist) {\n    var firstLabel = Object.keys(formattedPlaylists)[0];\n    formattedPlaylists[firstLabel].default = true;\n  }\n\n  return formattedPlaylists;\n};\n\nvar organizeVttPlaylists = function organizeVttPlaylists(playlists, sidxMapping) {\n  if (sidxMapping === void 0) {\n    sidxMapping = {};\n  }\n\n  return playlists.reduce(function (a, playlist) {\n    var label = playlist.attributes.lang || 'text';\n\n    if (!a[label]) {\n      a[label] = {\n        language: label,\n        default: false,\n        autoselect: false,\n        playlists: [],\n        uri: ''\n      };\n    }\n\n    a[label].playlists.push(addSidxSegmentsToPlaylist$1(formatVttPlaylist(playlist), sidxMapping));\n    return a;\n  }, {});\n};\n\nvar organizeCaptionServices = function organizeCaptionServices(captionServices) {\n  return captionServices.reduce(function (svcObj, svc) {\n    if (!svc) {\n      return svcObj;\n    }\n\n    svc.forEach(function (service) {\n      var channel = service.channel,\n          language = service.language;\n      svcObj[language] = {\n        autoselect: false,\n        default: false,\n        instreamId: channel,\n        language: language\n      };\n\n      if (service.hasOwnProperty('aspectRatio')) {\n        svcObj[language].aspectRatio = service.aspectRatio;\n      }\n\n      if (service.hasOwnProperty('easyReader')) {\n        svcObj[language].easyReader = service.easyReader;\n      }\n\n      if (service.hasOwnProperty('3D')) {\n        svcObj[language]['3D'] = service['3D'];\n      }\n    });\n    return svcObj;\n  }, {});\n};\n\nvar formatVideoPlaylist = function formatVideoPlaylist(_ref3) {\n  var _attributes2;\n\n  var attributes = _ref3.attributes,\n      segments = _ref3.segments,\n      sidx = _ref3.sidx;\n  var playlist = {\n    attributes: (_attributes2 = {\n      NAME: attributes.id,\n      AUDIO: 'audio',\n      SUBTITLES: 'subs',\n      RESOLUTION: {\n        width: attributes.width,\n        height: attributes.height\n      },\n      CODECS: attributes.codecs,\n      BANDWIDTH: attributes.bandwidth\n    }, _attributes2['PROGRAM-ID'] = 1, _attributes2),\n    uri: '',\n    endList: attributes.type === 'static',\n    timeline: attributes.periodIndex,\n    resolvedUri: '',\n    targetDuration: attributes.duration,\n    segments: segments,\n    mediaSequence: segments.length ? segments[0].number : 1\n  };\n\n  if (attributes.contentProtection) {\n    playlist.contentProtection = attributes.contentProtection;\n  }\n\n  if (sidx) {\n    playlist.sidx = sidx;\n  }\n\n  return playlist;\n};\n\nvar videoOnly = function videoOnly(_ref4) {\n  var attributes = _ref4.attributes;\n  return attributes.mimeType === 'video/mp4' || attributes.mimeType === 'video/webm' || attributes.contentType === 'video';\n};\n\nvar audioOnly = function audioOnly(_ref5) {\n  var attributes = _ref5.attributes;\n  return attributes.mimeType === 'audio/mp4' || attributes.mimeType === 'audio/webm' || attributes.contentType === 'audio';\n};\n\nvar vttOnly = function vttOnly(_ref6) {\n  var attributes = _ref6.attributes;\n  return attributes.mimeType === 'text/vtt' || attributes.contentType === 'text';\n};\n\nvar toM3u8 = function toM3u8(dashPlaylists, locations, sidxMapping) {\n  var _mediaGroups;\n\n  if (sidxMapping === void 0) {\n    sidxMapping = {};\n  }\n\n  if (!dashPlaylists.length) {\n    return {};\n  } // grab all main manifest attributes\n\n\n  var _dashPlaylists$0$attr = dashPlaylists[0].attributes,\n      duration = _dashPlaylists$0$attr.sourceDuration,\n      type = _dashPlaylists$0$attr.type,\n      suggestedPresentationDelay = _dashPlaylists$0$attr.suggestedPresentationDelay,\n      minimumUpdatePeriod = _dashPlaylists$0$attr.minimumUpdatePeriod;\n  var videoPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(videoOnly)).map(formatVideoPlaylist);\n  var audioPlaylists = mergeDiscontiguousPlaylists(dashPlaylists.filter(audioOnly));\n  var vttPlaylists = dashPlaylists.filter(vttOnly);\n  var captions = dashPlaylists.map(function (playlist) {\n    return playlist.attributes.captionServices;\n  }).filter(Boolean);\n  var manifest = {\n    allowCache: true,\n    discontinuityStarts: [],\n    segments: [],\n    endList: true,\n    mediaGroups: (_mediaGroups = {\n      AUDIO: {},\n      VIDEO: {}\n    }, _mediaGroups['CLOSED-CAPTIONS'] = {}, _mediaGroups.SUBTITLES = {}, _mediaGroups),\n    uri: '',\n    duration: duration,\n    playlists: addSidxSegmentsToPlaylists(videoPlaylists, sidxMapping)\n  };\n\n  if (minimumUpdatePeriod >= 0) {\n    manifest.minimumUpdatePeriod = minimumUpdatePeriod * 1000;\n  }\n\n  if (locations) {\n    manifest.locations = locations;\n  }\n\n  if (type === 'dynamic') {\n    manifest.suggestedPresentationDelay = suggestedPresentationDelay;\n  }\n\n  var isAudioOnly = manifest.playlists.length === 0;\n\n  if (audioPlaylists.length) {\n    manifest.mediaGroups.AUDIO.audio = organizeAudioPlaylists(audioPlaylists, sidxMapping, isAudioOnly);\n  }\n\n  if (vttPlaylists.length) {\n    manifest.mediaGroups.SUBTITLES.subs = organizeVttPlaylists(vttPlaylists, sidxMapping);\n  }\n\n  if (captions.length) {\n    manifest.mediaGroups['CLOSED-CAPTIONS'].cc = organizeCaptionServices(captions);\n  }\n\n  return manifest;\n};\n/**\n * Calculates the R (repetition) value for a live stream (for the final segment\n * in a manifest where the r value is negative 1)\n *\n * @param {Object} attributes\n *        Object containing all inherited attributes from parent elements with attribute\n *        names as keys\n * @param {number} time\n *        current time (typically the total time up until the final segment)\n * @param {number} duration\n *        duration property for the given <S />\n *\n * @return {number}\n *        R value to reach the end of the given period\n */\n\n\nvar getLiveRValue = function getLiveRValue(attributes, time, duration) {\n  var NOW = attributes.NOW,\n      clientOffset = attributes.clientOffset,\n      availabilityStartTime = attributes.availabilityStartTime,\n      _attributes$timescale = attributes.timescale,\n      timescale = _attributes$timescale === void 0 ? 1 : _attributes$timescale,\n      _attributes$start = attributes.start,\n      start = _attributes$start === void 0 ? 0 : _attributes$start,\n      _attributes$minimumUp = attributes.minimumUpdatePeriod,\n      minimumUpdatePeriod = _attributes$minimumUp === void 0 ? 0 : _attributes$minimumUp;\n  var now = (NOW + clientOffset) / 1000;\n  var periodStartWC = availabilityStartTime + start;\n  var periodEndWC = now + minimumUpdatePeriod;\n  var periodDuration = periodEndWC - periodStartWC;\n  return Math.ceil((periodDuration * timescale - time) / duration);\n};\n/**\n * Uses information provided by SegmentTemplate.SegmentTimeline to determine segment\n * timing and duration\n *\n * @param {Object} attributes\n *        Object containing all inherited attributes from parent elements with attribute\n *        names as keys\n * @param {Object[]} segmentTimeline\n *        List of objects representing the attributes of each S element contained within\n *\n * @return {{number: number, duration: number, time: number, timeline: number}[]}\n *         List of Objects with segment timing and duration info\n */\n\n\nvar parseByTimeline = function parseByTimeline(attributes, segmentTimeline) {\n  var type = attributes.type,\n      _attributes$minimumUp2 = attributes.minimumUpdatePeriod,\n      minimumUpdatePeriod = _attributes$minimumUp2 === void 0 ? 0 : _attributes$minimumUp2,\n      _attributes$media = attributes.media,\n      media = _attributes$media === void 0 ? '' : _attributes$media,\n      sourceDuration = attributes.sourceDuration,\n      _attributes$timescale2 = attributes.timescale,\n      timescale = _attributes$timescale2 === void 0 ? 1 : _attributes$timescale2,\n      _attributes$startNumb = attributes.startNumber,\n      startNumber = _attributes$startNumb === void 0 ? 1 : _attributes$startNumb,\n      timeline = attributes.periodIndex;\n  var segments = [];\n  var time = -1;\n\n  for (var sIndex = 0; sIndex < segmentTimeline.length; sIndex++) {\n    var S = segmentTimeline[sIndex];\n    var duration = S.d;\n    var repeat = S.r || 0;\n    var segmentTime = S.t || 0;\n\n    if (time < 0) {\n      // first segment\n      time = segmentTime;\n    }\n\n    if (segmentTime && segmentTime > time) {\n      // discontinuity\n      // TODO: How to handle this type of discontinuity\n      // timeline++ here would treat it like HLS discontuity and content would\n      // get appended without gap\n      // E.G.\n      //  <S t=\"0\" d=\"1\" />\n      //  <S d=\"1\" />\n      //  <S d=\"1\" />\n      //  <S t=\"5\" d=\"1\" />\n      // would have $Time$ values of [0, 1, 2, 5]\n      // should this be appened at time positions [0, 1, 2, 3],(#EXT-X-DISCONTINUITY)\n      // or [0, 1, 2, gap, gap, 5]? (#EXT-X-GAP)\n      // does the value of sourceDuration consider this when calculating arbitrary\n      // negative @r repeat value?\n      // E.G. Same elements as above with this added at the end\n      //  <S d=\"1\" r=\"-1\" />\n      //  with a sourceDuration of 10\n      // Would the 2 gaps be included in the time duration calculations resulting in\n      // 8 segments with $Time$ values of [0, 1, 2, 5, 6, 7, 8, 9] or 10 segments\n      // with $Time$ values of [0, 1, 2, 5, 6, 7, 8, 9, 10, 11] ?\n      time = segmentTime;\n    }\n\n    var count = void 0;\n\n    if (repeat < 0) {\n      var nextS = sIndex + 1;\n\n      if (nextS === segmentTimeline.length) {\n        // last segment\n        if (type === 'dynamic' && minimumUpdatePeriod > 0 && media.indexOf('$Number$') > 0) {\n          count = getLiveRValue(attributes, time, duration);\n        } else {\n          // TODO: This may be incorrect depending on conclusion of TODO above\n          count = (sourceDuration * timescale - time) / duration;\n        }\n      } else {\n        count = (segmentTimeline[nextS].t - time) / duration;\n      }\n    } else {\n      count = repeat + 1;\n    }\n\n    var end = startNumber + segments.length + count;\n    var number = startNumber + segments.length;\n\n    while (number < end) {\n      segments.push({\n        number: number,\n        duration: duration / timescale,\n        time: time,\n        timeline: timeline\n      });\n      time += duration;\n      number++;\n    }\n  }\n\n  return segments;\n};\n\nvar identifierPattern = /\\$([A-z]*)(?:(%0)([0-9]+)d)?\\$/g;\n/**\n * Replaces template identifiers with corresponding values. To be used as the callback\n * for String.prototype.replace\n *\n * @name replaceCallback\n * @function\n * @param {string} match\n *        Entire match of identifier\n * @param {string} identifier\n *        Name of matched identifier\n * @param {string} format\n *        Format tag string. Its presence indicates that padding is expected\n * @param {string} width\n *        Desired length of the replaced value. Values less than this width shall be left\n *        zero padded\n * @return {string}\n *         Replacement for the matched identifier\n */\n\n/**\n * Returns a function to be used as a callback for String.prototype.replace to replace\n * template identifiers\n *\n * @param {Obect} values\n *        Object containing values that shall be used to replace known identifiers\n * @param {number} values.RepresentationID\n *        Value of the Representation@id attribute\n * @param {number} values.Number\n *        Number of the corresponding segment\n * @param {number} values.Bandwidth\n *        Value of the Representation@bandwidth attribute.\n * @param {number} values.Time\n *        Timestamp value of the corresponding segment\n * @return {replaceCallback}\n *         Callback to be used with String.prototype.replace to replace identifiers\n */\n\nvar identifierReplacement = function identifierReplacement(values) {\n  return function (match, identifier, format, width) {\n    if (match === '$$') {\n      // escape sequence\n      return '$';\n    }\n\n    if (typeof values[identifier] === 'undefined') {\n      return match;\n    }\n\n    var value = '' + values[identifier];\n\n    if (identifier === 'RepresentationID') {\n      // Format tag shall not be present with RepresentationID\n      return value;\n    }\n\n    if (!format) {\n      width = 1;\n    } else {\n      width = parseInt(width, 10);\n    }\n\n    if (value.length >= width) {\n      return value;\n    }\n\n    return \"\" + new Array(width - value.length + 1).join('0') + value;\n  };\n};\n/**\n * Constructs a segment url from a template string\n *\n * @param {string} url\n *        Template string to construct url from\n * @param {Obect} values\n *        Object containing values that shall be used to replace known identifiers\n * @param {number} values.RepresentationID\n *        Value of the Representation@id attribute\n * @param {number} values.Number\n *        Number of the corresponding segment\n * @param {number} values.Bandwidth\n *        Value of the Representation@bandwidth attribute.\n * @param {number} values.Time\n *        Timestamp value of the corresponding segment\n * @return {string}\n *         Segment url with identifiers replaced\n */\n\n\nvar constructTemplateUrl = function constructTemplateUrl(url, values) {\n  return url.replace(identifierPattern, identifierReplacement(values));\n};\n/**\n * Generates a list of objects containing timing and duration information about each\n * segment needed to generate segment uris and the complete segment object\n *\n * @param {Object} attributes\n *        Object containing all inherited attributes from parent elements with attribute\n *        names as keys\n * @param {Object[]|undefined} segmentTimeline\n *        List of objects representing the attributes of each S element contained within\n *        the SegmentTimeline element\n * @return {{number: number, duration: number, time: number, timeline: number}[]}\n *         List of Objects with segment timing and duration info\n */\n\n\nvar parseTemplateInfo = function parseTemplateInfo(attributes, segmentTimeline) {\n  if (!attributes.duration && !segmentTimeline) {\n    // if neither @duration or SegmentTimeline are present, then there shall be exactly\n    // one media segment\n    return [{\n      number: attributes.startNumber || 1,\n      duration: attributes.sourceDuration,\n      time: 0,\n      timeline: attributes.periodIndex\n    }];\n  }\n\n  if (attributes.duration) {\n    return parseByDuration(attributes);\n  }\n\n  return parseByTimeline(attributes, segmentTimeline);\n};\n/**\n * Generates a list of segments using information provided by the SegmentTemplate element\n *\n * @param {Object} attributes\n *        Object containing all inherited attributes from parent elements with attribute\n *        names as keys\n * @param {Object[]|undefined} segmentTimeline\n *        List of objects representing the attributes of each S element contained within\n *        the SegmentTimeline element\n * @return {Object[]}\n *         List of segment objects\n */\n\n\nvar segmentsFromTemplate = function segmentsFromTemplate(attributes, segmentTimeline) {\n  var templateValues = {\n    RepresentationID: attributes.id,\n    Bandwidth: attributes.bandwidth || 0\n  };\n  var _attributes$initializ = attributes.initialization,\n      initialization = _attributes$initializ === void 0 ? {\n    sourceURL: '',\n    range: ''\n  } : _attributes$initializ;\n  var mapSegment = urlTypeToSegment({\n    baseUrl: attributes.baseUrl,\n    source: constructTemplateUrl(initialization.sourceURL, templateValues),\n    range: initialization.range\n  });\n  var segments = parseTemplateInfo(attributes, segmentTimeline);\n  return segments.map(function (segment) {\n    templateValues.Number = segment.number;\n    templateValues.Time = segment.time;\n    var uri = constructTemplateUrl(attributes.media || '', templateValues); // See DASH spec section 5.3.9.2.2\n    // - if timescale isn't present on any level, default to 1.\n\n    var timescale = attributes.timescale || 1; // - if presentationTimeOffset isn't present on any level, default to 0\n\n    var presentationTimeOffset = attributes.presentationTimeOffset || 0;\n    var presentationTime = // Even if the @t attribute is not specified for the segment, segment.time is\n    // calculated in mpd-parser prior to this, so it's assumed to be available.\n    attributes.periodStart + (segment.time - presentationTimeOffset) / timescale;\n    var map = {\n      uri: uri,\n      timeline: segment.timeline,\n      duration: segment.duration,\n      resolvedUri: resolveUrl(attributes.baseUrl || '', uri),\n      map: mapSegment,\n      number: segment.number,\n      presentationTime: presentationTime\n    };\n    return map;\n  });\n};\n/**\n * Converts a <SegmentUrl> (of type URLType from the DASH spec 5.3.9.2 Table 14)\n * to an object that matches the output of a segment in videojs/mpd-parser\n *\n * @param {Object} attributes\n *   Object containing all inherited attributes from parent elements with attribute\n *   names as keys\n * @param {Object} segmentUrl\n *   <SegmentURL> node to translate into a segment object\n * @return {Object} translated segment object\n */\n\n\nvar SegmentURLToSegmentObject = function SegmentURLToSegmentObject(attributes, segmentUrl) {\n  var baseUrl = attributes.baseUrl,\n      _attributes$initializ = attributes.initialization,\n      initialization = _attributes$initializ === void 0 ? {} : _attributes$initializ;\n  var initSegment = urlTypeToSegment({\n    baseUrl: baseUrl,\n    source: initialization.sourceURL,\n    range: initialization.range\n  });\n  var segment = urlTypeToSegment({\n    baseUrl: baseUrl,\n    source: segmentUrl.media,\n    range: segmentUrl.mediaRange\n  });\n  segment.map = initSegment;\n  return segment;\n};\n/**\n * Generates a list of segments using information provided by the SegmentList element\n * SegmentList (DASH SPEC Section 5.3.9.3.2) contains a set of <SegmentURL> nodes.  Each\n * node should be translated into segment.\n *\n * @param {Object} attributes\n *   Object containing all inherited attributes from parent elements with attribute\n *   names as keys\n * @param {Object[]|undefined} segmentTimeline\n *        List of objects representing the attributes of each S element contained within\n *        the SegmentTimeline element\n * @return {Object.<Array>} list of segments\n */\n\n\nvar segmentsFromList = function segmentsFromList(attributes, segmentTimeline) {\n  var duration = attributes.duration,\n      _attributes$segmentUr = attributes.segmentUrls,\n      segmentUrls = _attributes$segmentUr === void 0 ? [] : _attributes$segmentUr,\n      periodStart = attributes.periodStart; // Per spec (5.3.9.2.1) no way to determine segment duration OR\n  // if both SegmentTimeline and @duration are defined, it is outside of spec.\n\n  if (!duration && !segmentTimeline || duration && segmentTimeline) {\n    throw new Error(errors.SEGMENT_TIME_UNSPECIFIED);\n  }\n\n  var segmentUrlMap = segmentUrls.map(function (segmentUrlObject) {\n    return SegmentURLToSegmentObject(attributes, segmentUrlObject);\n  });\n  var segmentTimeInfo;\n\n  if (duration) {\n    segmentTimeInfo = parseByDuration(attributes);\n  }\n\n  if (segmentTimeline) {\n    segmentTimeInfo = parseByTimeline(attributes, segmentTimeline);\n  }\n\n  var segments = segmentTimeInfo.map(function (segmentTime, index) {\n    if (segmentUrlMap[index]) {\n      var segment = segmentUrlMap[index]; // See DASH spec section 5.3.9.2.2\n      // - if timescale isn't present on any level, default to 1.\n\n      var timescale = attributes.timescale || 1; // - if presentationTimeOffset isn't present on any level, default to 0\n\n      var presentationTimeOffset = attributes.presentationTimeOffset || 0;\n      segment.timeline = segmentTime.timeline;\n      segment.duration = segmentTime.duration;\n      segment.number = segmentTime.number;\n      segment.presentationTime = periodStart + (segmentTime.time - presentationTimeOffset) / timescale;\n      return segment;\n    } // Since we're mapping we should get rid of any blank segments (in case\n    // the given SegmentTimeline is handling for more elements than we have\n    // SegmentURLs for).\n\n  }).filter(function (segment) {\n    return segment;\n  });\n  return segments;\n};\n\nvar generateSegments = function generateSegments(_ref) {\n  var attributes = _ref.attributes,\n      segmentInfo = _ref.segmentInfo;\n  var segmentAttributes;\n  var segmentsFn;\n\n  if (segmentInfo.template) {\n    segmentsFn = segmentsFromTemplate;\n    segmentAttributes = merge(attributes, segmentInfo.template);\n  } else if (segmentInfo.base) {\n    segmentsFn = segmentsFromBase;\n    segmentAttributes = merge(attributes, segmentInfo.base);\n  } else if (segmentInfo.list) {\n    segmentsFn = segmentsFromList;\n    segmentAttributes = merge(attributes, segmentInfo.list);\n  }\n\n  var segmentsInfo = {\n    attributes: attributes\n  };\n\n  if (!segmentsFn) {\n    return segmentsInfo;\n  }\n\n  var segments = segmentsFn(segmentAttributes, segmentInfo.segmentTimeline); // The @duration attribute will be used to determin the playlist's targetDuration which\n  // must be in seconds. Since we've generated the segment list, we no longer need\n  // @duration to be in @timescale units, so we can convert it here.\n\n  if (segmentAttributes.duration) {\n    var _segmentAttributes = segmentAttributes,\n        duration = _segmentAttributes.duration,\n        _segmentAttributes$ti = _segmentAttributes.timescale,\n        timescale = _segmentAttributes$ti === void 0 ? 1 : _segmentAttributes$ti;\n    segmentAttributes.duration = duration / timescale;\n  } else if (segments.length) {\n    // if there is no @duration attribute, use the largest segment duration as\n    // as target duration\n    segmentAttributes.duration = segments.reduce(function (max, segment) {\n      return Math.max(max, Math.ceil(segment.duration));\n    }, 0);\n  } else {\n    segmentAttributes.duration = 0;\n  }\n\n  segmentsInfo.attributes = segmentAttributes;\n  segmentsInfo.segments = segments; // This is a sidx box without actual segment information\n\n  if (segmentInfo.base && segmentAttributes.indexRange) {\n    segmentsInfo.sidx = segments[0];\n    segmentsInfo.segments = [];\n  }\n\n  return segmentsInfo;\n};\n\nvar toPlaylists = function toPlaylists(representations) {\n  return representations.map(generateSegments);\n};\n\nvar findChildren = function findChildren(element, name) {\n  return from(element.childNodes).filter(function (_ref) {\n    var tagName = _ref.tagName;\n    return tagName === name;\n  });\n};\n\nvar getContent = function getContent(element) {\n  return element.textContent.trim();\n};\n\nvar parseDuration = function parseDuration(str) {\n  var SECONDS_IN_YEAR = 365 * 24 * 60 * 60;\n  var SECONDS_IN_MONTH = 30 * 24 * 60 * 60;\n  var SECONDS_IN_DAY = 24 * 60 * 60;\n  var SECONDS_IN_HOUR = 60 * 60;\n  var SECONDS_IN_MIN = 60; // P10Y10M10DT10H10M10.1S\n\n  var durationRegex = /P(?:(\\d*)Y)?(?:(\\d*)M)?(?:(\\d*)D)?(?:T(?:(\\d*)H)?(?:(\\d*)M)?(?:([\\d.]*)S)?)?/;\n  var match = durationRegex.exec(str);\n\n  if (!match) {\n    return 0;\n  }\n\n  var _match$slice = match.slice(1),\n      year = _match$slice[0],\n      month = _match$slice[1],\n      day = _match$slice[2],\n      hour = _match$slice[3],\n      minute = _match$slice[4],\n      second = _match$slice[5];\n\n  return parseFloat(year || 0) * SECONDS_IN_YEAR + parseFloat(month || 0) * SECONDS_IN_MONTH + parseFloat(day || 0) * SECONDS_IN_DAY + parseFloat(hour || 0) * SECONDS_IN_HOUR + parseFloat(minute || 0) * SECONDS_IN_MIN + parseFloat(second || 0);\n};\n\nvar parseDate = function parseDate(str) {\n  // Date format without timezone according to ISO 8601\n  // YYY-MM-DDThh:mm:ss.ssssss\n  var dateRegex = /^\\d+-\\d+-\\d+T\\d+:\\d+:\\d+(\\.\\d+)?$/; // If the date string does not specifiy a timezone, we must specifiy UTC. This is\n  // expressed by ending with 'Z'\n\n  if (dateRegex.test(str)) {\n    str += 'Z';\n  }\n\n  return Date.parse(str);\n};\n\nvar parsers = {\n  /**\n   * Specifies the duration of the entire Media Presentation. Format is a duration string\n   * as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The duration in seconds\n   */\n  mediaPresentationDuration: function mediaPresentationDuration(value) {\n    return parseDuration(value);\n  },\n\n  /**\n   * Specifies the Segment availability start time for all Segments referred to in this\n   * MPD. For a dynamic manifest, it specifies the anchor for the earliest availability\n   * time. Format is a date string as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The date as seconds from unix epoch\n   */\n  availabilityStartTime: function availabilityStartTime(value) {\n    return parseDate(value) / 1000;\n  },\n\n  /**\n   * Specifies the smallest period between potential changes to the MPD. Format is a\n   * duration string as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The duration in seconds\n   */\n  minimumUpdatePeriod: function minimumUpdatePeriod(value) {\n    return parseDuration(value);\n  },\n\n  /**\n   * Specifies the suggested presentation delay. Format is a\n   * duration string as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The duration in seconds\n   */\n  suggestedPresentationDelay: function suggestedPresentationDelay(value) {\n    return parseDuration(value);\n  },\n\n  /**\n   * specifices the type of mpd. Can be either \"static\" or \"dynamic\"\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   *\n   * @return {string}\n   *         The type as a string\n   */\n  type: function type(value) {\n    return value;\n  },\n\n  /**\n   * Specifies the duration of the smallest time shifting buffer for any Representation\n   * in the MPD. Format is a duration string as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The duration in seconds\n   */\n  timeShiftBufferDepth: function timeShiftBufferDepth(value) {\n    return parseDuration(value);\n  },\n\n  /**\n   * Specifies the PeriodStart time of the Period relative to the availabilityStarttime.\n   * Format is a duration string as specified in ISO 8601\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The duration in seconds\n   */\n  start: function start(value) {\n    return parseDuration(value);\n  },\n\n  /**\n   * Specifies the width of the visual presentation\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed width\n   */\n  width: function width(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the height of the visual presentation\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed height\n   */\n  height: function height(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the bitrate of the representation\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed bandwidth\n   */\n  bandwidth: function bandwidth(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the number of the first Media Segment in this Representation in the Period\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed number\n   */\n  startNumber: function startNumber(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the timescale in units per seconds\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed timescale\n   */\n  timescale: function timescale(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the presentationTimeOffset.\n   *\n   * @param {string} value\n   *        value of the attribute as a string\n   *\n   * @return {number}\n   *         The parsed presentationTimeOffset\n   */\n  presentationTimeOffset: function presentationTimeOffset(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the constant approximate Segment duration\n   * NOTE: The <Period> element also contains an @duration attribute. This duration\n   *       specifies the duration of the Period. This attribute is currently not\n   *       supported by the rest of the parser, however we still check for it to prevent\n   *       errors.\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed duration\n   */\n  duration: function duration(value) {\n    var parsedValue = parseInt(value, 10);\n\n    if (isNaN(parsedValue)) {\n      return parseDuration(value);\n    }\n\n    return parsedValue;\n  },\n\n  /**\n   * Specifies the Segment duration, in units of the value of the @timescale.\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed duration\n   */\n  d: function d(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the MPD start time, in @timescale units, the first Segment in the series\n   * starts relative to the beginning of the Period\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed time\n   */\n  t: function t(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Specifies the repeat count of the number of following contiguous Segments with the\n   * same duration expressed by the value of @d\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {number}\n   *         The parsed number\n   */\n  r: function r(value) {\n    return parseInt(value, 10);\n  },\n\n  /**\n   * Default parser for all other attributes. Acts as a no-op and just returns the value\n   * as a string\n   *\n   * @param {string} value\n   *        value of attribute as a string\n   * @return {string}\n   *         Unparsed value\n   */\n  DEFAULT: function DEFAULT(value) {\n    return value;\n  }\n};\n/**\n * Gets all the attributes and values of the provided node, parses attributes with known\n * types, and returns an object with attribute names mapped to values.\n *\n * @param {Node} el\n *        The node to parse attributes from\n * @return {Object}\n *         Object with all attributes of el parsed\n */\n\nvar parseAttributes = function parseAttributes(el) {\n  if (!(el && el.attributes)) {\n    return {};\n  }\n\n  return from(el.attributes).reduce(function (a, e) {\n    var parseFn = parsers[e.name] || parsers.DEFAULT;\n    a[e.name] = parseFn(e.value);\n    return a;\n  }, {});\n};\n\nvar keySystemsMap = {\n  'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b': 'org.w3.clearkey',\n  'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed': 'com.widevine.alpha',\n  'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready',\n  'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb': 'com.adobe.primetime'\n};\n/**\n * Builds a list of urls that is the product of the reference urls and BaseURL values\n *\n * @param {string[]} referenceUrls\n *        List of reference urls to resolve to\n * @param {Node[]} baseUrlElements\n *        List of BaseURL nodes from the mpd\n * @return {string[]}\n *         List of resolved urls\n */\n\nvar buildBaseUrls = function buildBaseUrls(referenceUrls, baseUrlElements) {\n  if (!baseUrlElements.length) {\n    return referenceUrls;\n  }\n\n  return flatten(referenceUrls.map(function (reference) {\n    return baseUrlElements.map(function (baseUrlElement) {\n      return resolveUrl(reference, getContent(baseUrlElement));\n    });\n  }));\n};\n/**\n * Contains all Segment information for its containing AdaptationSet\n *\n * @typedef {Object} SegmentInformation\n * @property {Object|undefined} template\n *           Contains the attributes for the SegmentTemplate node\n * @property {Object[]|undefined} segmentTimeline\n *           Contains a list of atrributes for each S node within the SegmentTimeline node\n * @property {Object|undefined} list\n *           Contains the attributes for the SegmentList node\n * @property {Object|undefined} base\n *           Contains the attributes for the SegmentBase node\n */\n\n/**\n * Returns all available Segment information contained within the AdaptationSet node\n *\n * @param {Node} adaptationSet\n *        The AdaptationSet node to get Segment information from\n * @return {SegmentInformation}\n *         The Segment information contained within the provided AdaptationSet\n */\n\n\nvar getSegmentInformation = function getSegmentInformation(adaptationSet) {\n  var segmentTemplate = findChildren(adaptationSet, 'SegmentTemplate')[0];\n  var segmentList = findChildren(adaptationSet, 'SegmentList')[0];\n  var segmentUrls = segmentList && findChildren(segmentList, 'SegmentURL').map(function (s) {\n    return merge({\n      tag: 'SegmentURL'\n    }, parseAttributes(s));\n  });\n  var segmentBase = findChildren(adaptationSet, 'SegmentBase')[0];\n  var segmentTimelineParentNode = segmentList || segmentTemplate;\n  var segmentTimeline = segmentTimelineParentNode && findChildren(segmentTimelineParentNode, 'SegmentTimeline')[0];\n  var segmentInitializationParentNode = segmentList || segmentBase || segmentTemplate;\n  var segmentInitialization = segmentInitializationParentNode && findChildren(segmentInitializationParentNode, 'Initialization')[0]; // SegmentTemplate is handled slightly differently, since it can have both\n  // @initialization and an <Initialization> node.  @initialization can be templated,\n  // while the node can have a url and range specified.  If the <SegmentTemplate> has\n  // both @initialization and an <Initialization> subelement we opt to override with\n  // the node, as this interaction is not defined in the spec.\n\n  var template = segmentTemplate && parseAttributes(segmentTemplate);\n\n  if (template && segmentInitialization) {\n    template.initialization = segmentInitialization && parseAttributes(segmentInitialization);\n  } else if (template && template.initialization) {\n    // If it is @initialization we convert it to an object since this is the format that\n    // later functions will rely on for the initialization segment.  This is only valid\n    // for <SegmentTemplate>\n    template.initialization = {\n      sourceURL: template.initialization\n    };\n  }\n\n  var segmentInfo = {\n    template: template,\n    segmentTimeline: segmentTimeline && findChildren(segmentTimeline, 'S').map(function (s) {\n      return parseAttributes(s);\n    }),\n    list: segmentList && merge(parseAttributes(segmentList), {\n      segmentUrls: segmentUrls,\n      initialization: parseAttributes(segmentInitialization)\n    }),\n    base: segmentBase && merge(parseAttributes(segmentBase), {\n      initialization: parseAttributes(segmentInitialization)\n    })\n  };\n  Object.keys(segmentInfo).forEach(function (key) {\n    if (!segmentInfo[key]) {\n      delete segmentInfo[key];\n    }\n  });\n  return segmentInfo;\n};\n/**\n * Contains Segment information and attributes needed to construct a Playlist object\n * from a Representation\n *\n * @typedef {Object} RepresentationInformation\n * @property {SegmentInformation} segmentInfo\n *           Segment information for this Representation\n * @property {Object} attributes\n *           Inherited attributes for this Representation\n */\n\n/**\n * Maps a Representation node to an object containing Segment information and attributes\n *\n * @name inheritBaseUrlsCallback\n * @function\n * @param {Node} representation\n *        Representation node from the mpd\n * @return {RepresentationInformation}\n *         Representation information needed to construct a Playlist object\n */\n\n/**\n * Returns a callback for Array.prototype.map for mapping Representation nodes to\n * Segment information and attributes using inherited BaseURL nodes.\n *\n * @param {Object} adaptationSetAttributes\n *        Contains attributes inherited by the AdaptationSet\n * @param {string[]} adaptationSetBaseUrls\n *        Contains list of resolved base urls inherited by the AdaptationSet\n * @param {SegmentInformation} adaptationSetSegmentInfo\n *        Contains Segment information for the AdaptationSet\n * @return {inheritBaseUrlsCallback}\n *         Callback map function\n */\n\n\nvar inheritBaseUrls = function inheritBaseUrls(adaptationSetAttributes, adaptationSetBaseUrls, adaptationSetSegmentInfo) {\n  return function (representation) {\n    var repBaseUrlElements = findChildren(representation, 'BaseURL');\n    var repBaseUrls = buildBaseUrls(adaptationSetBaseUrls, repBaseUrlElements);\n    var attributes = merge(adaptationSetAttributes, parseAttributes(representation));\n    var representationSegmentInfo = getSegmentInformation(representation);\n    return repBaseUrls.map(function (baseUrl) {\n      return {\n        segmentInfo: merge(adaptationSetSegmentInfo, representationSegmentInfo),\n        attributes: merge(attributes, {\n          baseUrl: baseUrl\n        })\n      };\n    });\n  };\n};\n/**\n * Tranforms a series of content protection nodes to\n * an object containing pssh data by key system\n *\n * @param {Node[]} contentProtectionNodes\n *        Content protection nodes\n * @return {Object}\n *        Object containing pssh data by key system\n */\n\n\nvar generateKeySystemInformation = function generateKeySystemInformation(contentProtectionNodes) {\n  return contentProtectionNodes.reduce(function (acc, node) {\n    var attributes = parseAttributes(node);\n    var keySystem = keySystemsMap[attributes.schemeIdUri];\n\n    if (keySystem) {\n      acc[keySystem] = {\n        attributes: attributes\n      };\n      var psshNode = findChildren(node, 'cenc:pssh')[0];\n\n      if (psshNode) {\n        var pssh = getContent(psshNode);\n        var psshBuffer = pssh && decodeB64ToUint8Array(pssh);\n        acc[keySystem].pssh = psshBuffer;\n      }\n    }\n\n    return acc;\n  }, {});\n}; // defined in ANSI_SCTE 214-1 2016\n\n\nvar parseCaptionServiceMetadata = function parseCaptionServiceMetadata(service) {\n  // 608 captions\n  if (service.schemeIdUri === 'urn:scte:dash:cc:cea-608:2015') {\n    var values = typeof service.value !== 'string' ? [] : service.value.split(';');\n    return values.map(function (value) {\n      var channel;\n      var language; // default language to value\n\n      language = value;\n\n      if (/^CC\\d=/.test(value)) {\n        var _value$split = value.split('=');\n\n        channel = _value$split[0];\n        language = _value$split[1];\n      } else if (/^CC\\d$/.test(value)) {\n        channel = value;\n      }\n\n      return {\n        channel: channel,\n        language: language\n      };\n    });\n  } else if (service.schemeIdUri === 'urn:scte:dash:cc:cea-708:2015') {\n    var _values = typeof service.value !== 'string' ? [] : service.value.split(';');\n\n    return _values.map(function (value) {\n      var flags = {\n        // service or channel number 1-63\n        'channel': undefined,\n        // language is a 3ALPHA per ISO 639.2/B\n        // field is required\n        'language': undefined,\n        // BIT 1/0 or ?\n        // default value is 1, meaning 16:9 aspect ratio, 0 is 4:3, ? is unknown\n        'aspectRatio': 1,\n        // BIT 1/0\n        // easy reader flag indicated the text is tailed to the needs of beginning readers\n        // default 0, or off\n        'easyReader': 0,\n        // BIT 1/0\n        // If 3d metadata is present (CEA-708.1) then 1\n        // default 0\n        '3D': 0\n      };\n\n      if (/=/.test(value)) {\n        var _value$split2 = value.split('='),\n            channel = _value$split2[0],\n            _value$split2$ = _value$split2[1],\n            opts = _value$split2$ === void 0 ? '' : _value$split2$;\n\n        flags.channel = channel;\n        flags.language = value;\n        opts.split(',').forEach(function (opt) {\n          var _opt$split = opt.split(':'),\n              name = _opt$split[0],\n              val = _opt$split[1];\n\n          if (name === 'lang') {\n            flags.language = val; // er for easyReadery\n          } else if (name === 'er') {\n            flags.easyReader = Number(val); // war for wide aspect ratio\n          } else if (name === 'war') {\n            flags.aspectRatio = Number(val);\n          } else if (name === '3D') {\n            flags['3D'] = Number(val);\n          }\n        });\n      } else {\n        flags.language = value;\n      }\n\n      if (flags.channel) {\n        flags.channel = 'SERVICE' + flags.channel;\n      }\n\n      return flags;\n    });\n  }\n};\n/**\n * Maps an AdaptationSet node to a list of Representation information objects\n *\n * @name toRepresentationsCallback\n * @function\n * @param {Node} adaptationSet\n *        AdaptationSet node from the mpd\n * @return {RepresentationInformation[]}\n *         List of objects containing Representaion information\n */\n\n/**\n * Returns a callback for Array.prototype.map for mapping AdaptationSet nodes to a list of\n * Representation information objects\n *\n * @param {Object} periodAttributes\n *        Contains attributes inherited by the Period\n * @param {string[]} periodBaseUrls\n *        Contains list of resolved base urls inherited by the Period\n * @param {string[]} periodSegmentInfo\n *        Contains Segment Information at the period level\n * @return {toRepresentationsCallback}\n *         Callback map function\n */\n\n\nvar toRepresentations = function toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo) {\n  return function (adaptationSet) {\n    var adaptationSetAttributes = parseAttributes(adaptationSet);\n    var adaptationSetBaseUrls = buildBaseUrls(periodBaseUrls, findChildren(adaptationSet, 'BaseURL'));\n    var role = findChildren(adaptationSet, 'Role')[0];\n    var roleAttributes = {\n      role: parseAttributes(role)\n    };\n    var attrs = merge(periodAttributes, adaptationSetAttributes, roleAttributes);\n    var accessibility = findChildren(adaptationSet, 'Accessibility')[0];\n    var captionServices = parseCaptionServiceMetadata(parseAttributes(accessibility));\n\n    if (captionServices) {\n      attrs = merge(attrs, {\n        captionServices: captionServices\n      });\n    }\n\n    var label = findChildren(adaptationSet, 'Label')[0];\n\n    if (label && label.childNodes.length) {\n      var labelVal = label.childNodes[0].nodeValue.trim();\n      attrs = merge(attrs, {\n        label: labelVal\n      });\n    }\n\n    var contentProtection = generateKeySystemInformation(findChildren(adaptationSet, 'ContentProtection'));\n\n    if (Object.keys(contentProtection).length) {\n      attrs = merge(attrs, {\n        contentProtection: contentProtection\n      });\n    }\n\n    var segmentInfo = getSegmentInformation(adaptationSet);\n    var representations = findChildren(adaptationSet, 'Representation');\n    var adaptationSetSegmentInfo = merge(periodSegmentInfo, segmentInfo);\n    return flatten(representations.map(inheritBaseUrls(attrs, adaptationSetBaseUrls, adaptationSetSegmentInfo)));\n  };\n};\n/**\n * Contains all period information for mapping nodes onto adaptation sets.\n *\n * @typedef {Object} PeriodInformation\n * @property {Node} period.node\n *           Period node from the mpd\n * @property {Object} period.attributes\n *           Parsed period attributes from node plus any added\n */\n\n/**\n * Maps a PeriodInformation object to a list of Representation information objects for all\n * AdaptationSet nodes contained within the Period.\n *\n * @name toAdaptationSetsCallback\n * @function\n * @param {PeriodInformation} period\n *        Period object containing necessary period information\n * @param {number} periodIndex\n *        Index of the Period within the mpd\n * @return {RepresentationInformation[]}\n *         List of objects containing Representaion information\n */\n\n/**\n * Returns a callback for Array.prototype.map for mapping Period nodes to a list of\n * Representation information objects\n *\n * @param {Object} mpdAttributes\n *        Contains attributes inherited by the mpd\n * @param {string[]} mpdBaseUrls\n *        Contains list of resolved base urls inherited by the mpd\n * @return {toAdaptationSetsCallback}\n *         Callback map function\n */\n\n\nvar toAdaptationSets = function toAdaptationSets(mpdAttributes, mpdBaseUrls) {\n  return function (period, index) {\n    var periodBaseUrls = buildBaseUrls(mpdBaseUrls, findChildren(period.node, 'BaseURL'));\n    var parsedPeriodId = parseInt(period.attributes.id, 10); // fallback to mapping index if Period@id is not a number\n\n    var periodIndex = window.isNaN(parsedPeriodId) ? index : parsedPeriodId;\n    var periodAttributes = merge(mpdAttributes, {\n      periodIndex: periodIndex,\n      periodStart: period.attributes.start\n    });\n\n    if (typeof period.attributes.duration === 'number') {\n      periodAttributes.periodDuration = period.attributes.duration;\n    }\n\n    var adaptationSets = findChildren(period.node, 'AdaptationSet');\n    var periodSegmentInfo = getSegmentInformation(period.node);\n    return flatten(adaptationSets.map(toRepresentations(periodAttributes, periodBaseUrls, periodSegmentInfo)));\n  };\n};\n/**\n * Gets Period@start property for a given period.\n *\n * @param {Object} options\n *        Options object\n * @param {Object} options.attributes\n *        Period attributes\n * @param {Object} [options.priorPeriodAttributes]\n *        Prior period attributes (if prior period is available)\n * @param {string} options.mpdType\n *        The MPD@type these periods came from\n * @return {number|null}\n *         The period start, or null if it's an early available period or error\n */\n\n\nvar getPeriodStart = function getPeriodStart(_ref) {\n  var attributes = _ref.attributes,\n      priorPeriodAttributes = _ref.priorPeriodAttributes,\n      mpdType = _ref.mpdType; // Summary of period start time calculation from DASH spec section 5.3.2.1\n  //\n  // A period's start is the first period's start + time elapsed after playing all\n  // prior periods to this one. Periods continue one after the other in time (without\n  // gaps) until the end of the presentation.\n  //\n  // The value of Period@start should be:\n  // 1. if Period@start is present: value of Period@start\n  // 2. if previous period exists and it has @duration: previous Period@start +\n  //    previous Period@duration\n  // 3. if this is first period and MPD@type is 'static': 0\n  // 4. in all other cases, consider the period an \"early available period\" (note: not\n  //    currently supported)\n  // (1)\n\n  if (typeof attributes.start === 'number') {\n    return attributes.start;\n  } // (2)\n\n\n  if (priorPeriodAttributes && typeof priorPeriodAttributes.start === 'number' && typeof priorPeriodAttributes.duration === 'number') {\n    return priorPeriodAttributes.start + priorPeriodAttributes.duration;\n  } // (3)\n\n\n  if (!priorPeriodAttributes && mpdType === 'static') {\n    return 0;\n  } // (4)\n  // There is currently no logic for calculating the Period@start value if there is\n  // no Period@start or prior Period@start and Period@duration available. This is not made\n  // explicit by the DASH interop guidelines or the DASH spec, however, since there's\n  // nothing about any other resolution strategies, it's implied. Thus, this case should\n  // be considered an early available period, or error, and null should suffice for both\n  // of those cases.\n\n\n  return null;\n};\n/**\n * Traverses the mpd xml tree to generate a list of Representation information objects\n * that have inherited attributes from parent nodes\n *\n * @param {Node} mpd\n *        The root node of the mpd\n * @param {Object} options\n *        Available options for inheritAttributes\n * @param {string} options.manifestUri\n *        The uri source of the mpd\n * @param {number} options.NOW\n *        Current time per DASH IOP.  Default is current time in ms since epoch\n * @param {number} options.clientOffset\n *        Client time difference from NOW (in milliseconds)\n * @return {RepresentationInformation[]}\n *         List of objects containing Representation information\n */\n\n\nvar inheritAttributes = function inheritAttributes(mpd, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      _options$manifestUri = _options.manifestUri,\n      manifestUri = _options$manifestUri === void 0 ? '' : _options$manifestUri,\n      _options$NOW = _options.NOW,\n      NOW = _options$NOW === void 0 ? Date.now() : _options$NOW,\n      _options$clientOffset = _options.clientOffset,\n      clientOffset = _options$clientOffset === void 0 ? 0 : _options$clientOffset;\n  var periodNodes = findChildren(mpd, 'Period');\n\n  if (!periodNodes.length) {\n    throw new Error(errors.INVALID_NUMBER_OF_PERIOD);\n  }\n\n  var locations = findChildren(mpd, 'Location');\n  var mpdAttributes = parseAttributes(mpd);\n  var mpdBaseUrls = buildBaseUrls([manifestUri], findChildren(mpd, 'BaseURL')); // See DASH spec section 5.3.1.2, Semantics of MPD element. Default type to 'static'.\n\n  mpdAttributes.type = mpdAttributes.type || 'static';\n  mpdAttributes.sourceDuration = mpdAttributes.mediaPresentationDuration || 0;\n  mpdAttributes.NOW = NOW;\n  mpdAttributes.clientOffset = clientOffset;\n\n  if (locations.length) {\n    mpdAttributes.locations = locations.map(getContent);\n  }\n\n  var periods = []; // Since toAdaptationSets acts on individual periods right now, the simplest approach to\n  // adding properties that require looking at prior periods is to parse attributes and add\n  // missing ones before toAdaptationSets is called. If more such properties are added, it\n  // may be better to refactor toAdaptationSets.\n\n  periodNodes.forEach(function (node, index) {\n    var attributes = parseAttributes(node); // Use the last modified prior period, as it may contain added information necessary\n    // for this period.\n\n    var priorPeriod = periods[index - 1];\n    attributes.start = getPeriodStart({\n      attributes: attributes,\n      priorPeriodAttributes: priorPeriod ? priorPeriod.attributes : null,\n      mpdType: mpdAttributes.type\n    });\n    periods.push({\n      node: node,\n      attributes: attributes\n    });\n  });\n  return {\n    locations: mpdAttributes.locations,\n    representationInfo: flatten(periods.map(toAdaptationSets(mpdAttributes, mpdBaseUrls)))\n  };\n};\n\nvar stringToMpdXml = function stringToMpdXml(manifestString) {\n  if (manifestString === '') {\n    throw new Error(errors.DASH_EMPTY_MANIFEST);\n  }\n\n  var parser = new DOMParser();\n  var xml;\n  var mpd;\n\n  try {\n    xml = parser.parseFromString(manifestString, 'application/xml');\n    mpd = xml && xml.documentElement.tagName === 'MPD' ? xml.documentElement : null;\n  } catch (e) {// ie 11 throwsw on invalid xml\n  }\n\n  if (!mpd || mpd && mpd.getElementsByTagName('parsererror').length > 0) {\n    throw new Error(errors.DASH_INVALID_XML);\n  }\n\n  return mpd;\n};\n/**\n * Parses the manifest for a UTCTiming node, returning the nodes attributes if found\n *\n * @param {string} mpd\n *        XML string of the MPD manifest\n * @return {Object|null}\n *         Attributes of UTCTiming node specified in the manifest. Null if none found\n */\n\n\nvar parseUTCTimingScheme = function parseUTCTimingScheme(mpd) {\n  var UTCTimingNode = findChildren(mpd, 'UTCTiming')[0];\n\n  if (!UTCTimingNode) {\n    return null;\n  }\n\n  var attributes = parseAttributes(UTCTimingNode);\n\n  switch (attributes.schemeIdUri) {\n    case 'urn:mpeg:dash:utc:http-head:2014':\n    case 'urn:mpeg:dash:utc:http-head:2012':\n      attributes.method = 'HEAD';\n      break;\n\n    case 'urn:mpeg:dash:utc:http-xsdate:2014':\n    case 'urn:mpeg:dash:utc:http-iso:2014':\n    case 'urn:mpeg:dash:utc:http-xsdate:2012':\n    case 'urn:mpeg:dash:utc:http-iso:2012':\n      attributes.method = 'GET';\n      break;\n\n    case 'urn:mpeg:dash:utc:direct:2014':\n    case 'urn:mpeg:dash:utc:direct:2012':\n      attributes.method = 'DIRECT';\n      attributes.value = Date.parse(attributes.value);\n      break;\n\n    case 'urn:mpeg:dash:utc:http-ntp:2014':\n    case 'urn:mpeg:dash:utc:ntp:2014':\n    case 'urn:mpeg:dash:utc:sntp:2014':\n    default:\n      throw new Error(errors.UNSUPPORTED_UTC_TIMING_SCHEME);\n  }\n\n  return attributes;\n};\n\nvar VERSION = version;\n\nvar parse = function parse(manifestString, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var parsedManifestInfo = inheritAttributes(stringToMpdXml(manifestString), options);\n  var playlists = toPlaylists(parsedManifestInfo.representationInfo);\n  return toM3u8(playlists, parsedManifestInfo.locations, options.sidxMapping);\n};\n/**\n * Parses the manifest for a UTCTiming node, returning the nodes attributes if found\n *\n * @param {string} manifestString\n *        XML string of the MPD manifest\n * @return {Object|null}\n *         Attributes of UTCTiming node specified in the manifest. Null if none found\n */\n\n\nvar parseUTCTiming = function parseUTCTiming(manifestString) {\n  return parseUTCTimingScheme(stringToMpdXml(manifestString));\n};\n\nexport { VERSION, addSidxSegmentsToPlaylist, generateSidxKey, inheritAttributes, parse, parseUTCTiming, stringToMpdXml, toM3u8, toPlaylists };","var MAX_UINT32 = Math.pow(2, 32);\n\nvar parseSidx = function parseSidx(data) {\n  var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n      result = {\n    version: data[0],\n    flags: new Uint8Array(data.subarray(1, 4)),\n    references: [],\n    referenceId: view.getUint32(4),\n    timescale: view.getUint32(8)\n  },\n      i = 12;\n\n  if (result.version === 0) {\n    result.earliestPresentationTime = view.getUint32(i);\n    result.firstOffset = view.getUint32(i + 4);\n    i += 8;\n  } else {\n    // read 64 bits\n    result.earliestPresentationTime = view.getUint32(i) * MAX_UINT32 + view.getUint32(i + 4);\n    result.firstOffset = view.getUint32(i + 8) * MAX_UINT32 + view.getUint32(i + 12);\n    i += 16;\n  }\n\n  i += 2; // reserved\n\n  var referenceCount = view.getUint16(i);\n  i += 2; // start of references\n\n  for (; referenceCount > 0; i += 12, referenceCount--) {\n    result.references.push({\n      referenceType: (data[i] & 0x80) >>> 7,\n      referencedSize: view.getUint32(i) & 0x7FFFFFFF,\n      subsegmentDuration: view.getUint32(i + 4),\n      startsWithSap: !!(data[i + 8] & 0x80),\n      sapType: (data[i + 8] & 0x70) >>> 4,\n      sapDeltaTime: view.getUint32(i + 8) & 0x0FFFFFFF\n    });\n  }\n\n  return result;\n};\n\nmodule.exports = parseSidx;","/**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\nvar ONE_SECOND_IN_TS = 90000,\n    // 90kHz clock\nsecondsToVideoTs,\n    secondsToAudioTs,\n    videoTsToSeconds,\n    audioTsToSeconds,\n    audioTsToVideoTs,\n    videoTsToAudioTs,\n    metadataTsToSeconds;\n\nsecondsToVideoTs = function secondsToVideoTs(seconds) {\n  return seconds * ONE_SECOND_IN_TS;\n};\n\nsecondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {\n  return seconds * sampleRate;\n};\n\nvideoTsToSeconds = function videoTsToSeconds(timestamp) {\n  return timestamp / ONE_SECOND_IN_TS;\n};\n\naudioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {\n  return timestamp / sampleRate;\n};\n\naudioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {\n  return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));\n};\n\nvideoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {\n  return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);\n};\n/**\n * Adjust ID3 tag or caption timing information by the timeline pts values\n * (if keepOriginalTimestamps is false) and convert to seconds\n */\n\n\nmetadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {\n  return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);\n};\n\nmodule.exports = {\n  ONE_SECOND_IN_TS: ONE_SECOND_IN_TS,\n  secondsToVideoTs: secondsToVideoTs,\n  secondsToAudioTs: secondsToAudioTs,\n  videoTsToSeconds: videoTsToSeconds,\n  audioTsToSeconds: audioTsToSeconds,\n  audioTsToVideoTs: audioTsToVideoTs,\n  videoTsToAudioTs: videoTsToAudioTs,\n  metadataTsToSeconds: metadataTsToSeconds\n};","module.exports = SafeParseTuple;\n\nfunction SafeParseTuple(obj, reviver) {\n  var json;\n  var error = null;\n\n  try {\n    json = JSON.parse(obj, reviver);\n  } catch (err) {\n    error = err;\n  }\n\n  return [error, json];\n}","// see https://tools.ietf.org/html/rfc1808\n(function (root) {\n  var URL_REGEX = /^((?:[a-zA-Z0-9+\\-.]+:)?)(\\/\\/[^\\/?#]*)?((?:[^\\/?#]*\\/)*[^;?#]*)?(;[^?#]*)?(\\?[^#]*)?(#[^]*)?$/;\n  var FIRST_SEGMENT_REGEX = /^([^\\/?#]*)([^]*)$/;\n  var SLASH_DOT_REGEX = /(?:\\/|^)\\.(?=\\/)/g;\n  var SLASH_DOT_DOT_REGEX = /(?:\\/|^)\\.\\.\\/(?!\\.\\.\\/)[^\\/]*(?=\\/)/g;\n  var URLToolkit = {\n    // If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //\n    // E.g\n    // With opts.alwaysNormalize = false (default, spec compliant)\n    // http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g\n    // With opts.alwaysNormalize = true (not spec compliant)\n    // http://a.com/b/cd + /e/f/../g => http://a.com/e/g\n    buildAbsoluteURL: function buildAbsoluteURL(baseURL, relativeURL, opts) {\n      opts = opts || {}; // remove any remaining space and CRLF\n\n      baseURL = baseURL.trim();\n      relativeURL = relativeURL.trim();\n\n      if (!relativeURL) {\n        // 2a) If the embedded URL is entirely empty, it inherits the\n        // entire base URL (i.e., is set equal to the base URL)\n        // and we are done.\n        if (!opts.alwaysNormalize) {\n          return baseURL;\n        }\n\n        var basePartsForNormalise = URLToolkit.parseURL(baseURL);\n\n        if (!basePartsForNormalise) {\n          throw new Error('Error trying to parse base URL.');\n        }\n\n        basePartsForNormalise.path = URLToolkit.normalizePath(basePartsForNormalise.path);\n        return URLToolkit.buildURLFromParts(basePartsForNormalise);\n      }\n\n      var relativeParts = URLToolkit.parseURL(relativeURL);\n\n      if (!relativeParts) {\n        throw new Error('Error trying to parse relative URL.');\n      }\n\n      if (relativeParts.scheme) {\n        // 2b) If the embedded URL starts with a scheme name, it is\n        // interpreted as an absolute URL and we are done.\n        if (!opts.alwaysNormalize) {\n          return relativeURL;\n        }\n\n        relativeParts.path = URLToolkit.normalizePath(relativeParts.path);\n        return URLToolkit.buildURLFromParts(relativeParts);\n      }\n\n      var baseParts = URLToolkit.parseURL(baseURL);\n\n      if (!baseParts) {\n        throw new Error('Error trying to parse base URL.');\n      }\n\n      if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {\n        // If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc\n        // This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'\n        var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);\n        baseParts.netLoc = pathParts[1];\n        baseParts.path = pathParts[2];\n      }\n\n      if (baseParts.netLoc && !baseParts.path) {\n        baseParts.path = '/';\n      }\n\n      var builtParts = {\n        // 2c) Otherwise, the embedded URL inherits the scheme of\n        // the base URL.\n        scheme: baseParts.scheme,\n        netLoc: relativeParts.netLoc,\n        path: null,\n        params: relativeParts.params,\n        query: relativeParts.query,\n        fragment: relativeParts.fragment\n      };\n\n      if (!relativeParts.netLoc) {\n        // 3) If the embedded URL's <net_loc> is non-empty, we skip to\n        // Step 7.  Otherwise, the embedded URL inherits the <net_loc>\n        // (if any) of the base URL.\n        builtParts.netLoc = baseParts.netLoc; // 4) If the embedded URL path is preceded by a slash \"/\", the\n        // path is not relative and we skip to Step 7.\n\n        if (relativeParts.path[0] !== '/') {\n          if (!relativeParts.path) {\n            // 5) If the embedded URL path is empty (and not preceded by a\n            // slash), then the embedded URL inherits the base URL path\n            builtParts.path = baseParts.path; // 5a) if the embedded URL's <params> is non-empty, we skip to\n            // step 7; otherwise, it inherits the <params> of the base\n            // URL (if any) and\n\n            if (!relativeParts.params) {\n              builtParts.params = baseParts.params; // 5b) if the embedded URL's <query> is non-empty, we skip to\n              // step 7; otherwise, it inherits the <query> of the base\n              // URL (if any) and we skip to step 7.\n\n              if (!relativeParts.query) {\n                builtParts.query = baseParts.query;\n              }\n            }\n          } else {\n            // 6) The last segment of the base URL's path (anything\n            // following the rightmost slash \"/\", or the entire path if no\n            // slash is present) is removed and the embedded URL's path is\n            // appended in its place.\n            var baseURLPath = baseParts.path;\n            var newPath = baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) + relativeParts.path;\n            builtParts.path = URLToolkit.normalizePath(newPath);\n          }\n        }\n      }\n\n      if (builtParts.path === null) {\n        builtParts.path = opts.alwaysNormalize ? URLToolkit.normalizePath(relativeParts.path) : relativeParts.path;\n      }\n\n      return URLToolkit.buildURLFromParts(builtParts);\n    },\n    parseURL: function parseURL(url) {\n      var parts = URL_REGEX.exec(url);\n\n      if (!parts) {\n        return null;\n      }\n\n      return {\n        scheme: parts[1] || '',\n        netLoc: parts[2] || '',\n        path: parts[3] || '',\n        params: parts[4] || '',\n        query: parts[5] || '',\n        fragment: parts[6] || ''\n      };\n    },\n    normalizePath: function normalizePath(path) {\n      // The following operations are\n      // then applied, in order, to the new path:\n      // 6a) All occurrences of \"./\", where \".\" is a complete path\n      // segment, are removed.\n      // 6b) If the path ends with \".\" as a complete path segment,\n      // that \".\" is removed.\n      path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, ''); // 6c) All occurrences of \"<segment>/../\", where <segment> is a\n      // complete path segment not equal to \"..\", are removed.\n      // Removal of these path segments is performed iteratively,\n      // removing the leftmost matching pattern on each iteration,\n      // until no matching pattern remains.\n      // 6d) If the path ends with \"<segment>/..\", where <segment> is a\n      // complete path segment not equal to \"..\", that\n      // \"<segment>/..\" is removed.\n\n      while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) {}\n\n      return path.split('').reverse().join('');\n    },\n    buildURLFromParts: function buildURLFromParts(parts) {\n      return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;\n    }\n  };\n  if (typeof exports === 'object' && typeof module === 'object') module.exports = URLToolkit;else if (typeof define === 'function' && define.amd) define([], function () {\n    return URLToolkit;\n  });else if (typeof exports === 'object') exports['URLToolkit'] = URLToolkit;else root['URLToolkit'] = URLToolkit;\n})(this);","/**\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// 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.\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};\nwindow.vttjs = vttjs;\nwindow.WebVTT = vttjs.WebVTT;\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 * 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\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\n  return function (o) {\n    if (arguments.length !== 1) {\n      throw new Error('Object.create shim only accepts one parameter.');\n    }\n\n    F.prototype = o;\n    return new F();\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.\n\n\nfunction ParsingError(errorData, message) {\n  this.name = \"ParsingError\";\n  this.code = errorData.code;\n  this.message = message || errorData.message;\n}\n\nParsingError.prototype = _objCreate(Error.prototype);\nParsingError.prototype.constructor = ParsingError; // ParsingError metadata for acceptable ParsingErrors.\n\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}; // Try to parse input as a time stamp.\n\nfunction parseTimeStamp(input) {\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\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} // A settings object holds key/value pairs and will ignore anything but the first\n// assignment to a specific key.\n\n\nfunction Settings() {\n  this.values = _objCreate(null);\n}\n\nSettings.prototype = {\n  // Only accept the first assignment to any key.\n  set: function set(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 get(k, dflt, defaultKey) {\n    if (defaultKey) {\n      return this.has(k) ? this.values[k] : dflt[defaultKey];\n    }\n\n    return this.has(k) ? this.values[k] : dflt;\n  },\n  // Check whether we have a value for a key.\n  has: function has(k) {\n    return k in this.values;\n  },\n  // Accept a setting if its one of the given alternatives.\n  alt: function alt(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 integer(k, v) {\n    if (/^-?\\d+$/.test(v)) {\n      // integer\n      this.set(k, parseInt(v, 10));\n    }\n  },\n  // Accept a setting if its a valid percentage.\n  percent: function percent(k, v) {\n    var m;\n\n    if (m = v.match(/^([\\d]{1,3})(\\.[\\d]*)?%$/)) {\n      v = parseFloat(v);\n\n      if (v >= 0 && v <= 100) {\n        this.set(k, v);\n        return true;\n      }\n    }\n\n    return false;\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'.\n\nfunction parseOptions(input, callback, keyValueDelim, groupDelim) {\n  var groups = groupDelim ? input.split(groupDelim) : [input];\n\n  for (var i in groups) {\n    if (typeof groups[i] !== \"string\") {\n      continue;\n    }\n\n    var kv = groups[i].split(keyValueDelim);\n\n    if (kv.length !== 2) {\n      continue;\n    }\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; // 4.1 WebVTT timestamp\n\n  function consumeTimeStamp() {\n    var ts = parseTimeStamp(input);\n\n    if (ts === null) {\n      throw new ParsingError(ParsingError.Errors.BadTimeStamp, \"Malformed timestamp: \" + oInput);\n    } // Remove time stamp from input.\n\n\n    input = input.replace(/^[^\\sa-zA-Z-]+/, \"\");\n    return ts;\n  } // 4.4.2 WebVTT cue settings\n\n\n  function consumeCueSettings(input, cue) {\n    var settings = new Settings();\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\n          break;\n\n        case \"vertical\":\n          settings.alt(k, v, [\"rl\", \"lr\"]);\n          break;\n\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\n          if (vals.length === 2) {\n            settings.alt(\"lineAlign\", vals[1], [\"start\", \"center\", \"end\"]);\n          }\n\n          break;\n\n        case \"position\":\n          vals = v.split(\",\");\n          settings.percent(k, vals[0]);\n\n          if (vals.length === 2) {\n            settings.alt(\"positionAlign\", vals[1], [\"start\", \"center\", \"end\"]);\n          }\n\n          break;\n\n        case \"size\":\n          settings.percent(k, v);\n          break;\n\n        case \"align\":\n          settings.alt(k, v, [\"start\", \"center\", \"end\", \"left\", \"right\"]);\n          break;\n      }\n    }, /:/, /\\s/); // Apply default values for any missing fields.\n\n    cue.region = settings.get(\"region\", null);\n    cue.vertical = settings.get(\"vertical\", \"\");\n\n    try {\n      cue.line = settings.get(\"line\", \"auto\");\n    } catch (e) {}\n\n    cue.lineAlign = settings.get(\"lineAlign\", \"start\");\n    cue.snapToLines = settings.get(\"snapToLines\", true);\n    cue.size = settings.get(\"size\", 100); // Safari still uses the old middle value and won't accept center\n\n    try {\n      cue.align = settings.get(\"align\", \"center\");\n    } catch (e) {\n      cue.align = settings.get(\"align\", \"middle\");\n    }\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    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  } // 4.1 WebVTT cue timings.\n\n\n  skipWhitespace();\n  cue.startTime = consumeTimeStamp(); // (1) collect cue start time\n\n  skipWhitespace();\n\n  if (input.substr(0, 3) !== \"-->\") {\n    // (3) next characters must match \"-->\"\n    throw new ParsingError(ParsingError.Errors.BadTimeStamp, \"Malformed time stamp (time stamps must be separated by '-->'): \" + oInput);\n  }\n\n  input = input.substr(3);\n  skipWhitespace();\n  cue.endTime = consumeTimeStamp(); // (5) collect cue end time\n  // 4.1 WebVTT cue settings list.\n\n  skipWhitespace();\n  consumeCueSettings(input, cue);\n} // When evaluating this file as part of a Webpack bundle for server\n// side rendering, `document` is an empty object.\n\n\nvar TEXTAREA_ELEMENT = document.createElement && document.createElement(\"textarea\");\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}; // 5.1 default text color\n// 5.2 default text background color is equivalent to text color with bg_ prefix\n\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};\nvar TAG_ANNOTATION = {\n  v: \"title\",\n  lang: \"lang\"\n};\nvar NEEDS_PARENT = {\n  rt: \"ruby\"\n}; // Parse content into a document fragment.\n\nfunction parseContent(window, input) {\n  function nextToken() {\n    // Check for end-of-string.\n    if (!input) {\n      return null;\n    } // Consume 'n' characters from the input.\n\n\n    function consume(result) {\n      input = input.substr(result.length);\n      return result;\n    }\n\n    var m = input.match(/^([^<]*)(<[^>]*>?)?/); // If there is some text before the next tag, return it, otherwise return\n    // the tag.\n\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] || NEEDS_PARENT[element.localName] === current.localName;\n  } // Create an element for this tag.\n\n\n  function createElement(type, annotation) {\n    var tagName = TAG_NAME[type];\n\n    if (!tagName) {\n      return null;\n    }\n\n    var element = window.document.createElement(tagName);\n    var name = TAG_ANNOTATION[type];\n\n    if (name && annotation) {\n      element[name] = annotation.trim();\n    }\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 && tagStack[tagStack.length - 1] === t.substr(2).replace(\">\", \"\")) {\n          tagStack.pop();\n          current = current.parentNode;\n        } // Otherwise just ignore the end tag.\n\n\n        continue;\n      }\n\n      var ts = parseTimeStamp(t.substr(1, t.length - 2));\n      var node;\n\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\n      var m = t.match(/^<([^.\\s/0-9>]+)(\\.[^\\s\\\\>]+)?([^>\\\\]+)?(\\\\?)>?$/); // If we can't parse the tag, skip to the next tag.\n\n      if (!m) {\n        continue;\n      } // Try to construct an element, and ignore the tag if we couldn't.\n\n\n      node = createElement(m[1], m[3]);\n\n      if (!node) {\n        continue;\n      } // Determine if the tag should be added based on the context of where it\n      // is placed in the cuetext.\n\n\n      if (!shouldAdd(current, node)) {\n        continue;\n      } // Set the class list (as a list of classes, separated by space).\n\n\n      if (m[2]) {\n        var classes = m[2].split('.');\n        classes.forEach(function (cl) {\n          var bgColor = /^bg_/.test(cl); // slice out `bg_` if it's a background color\n\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            node.style[propName] = propValue;\n          }\n        });\n        node.className = classes.join(' ');\n      } // Append the node to the current node, and enter the scope of the new\n      // node.\n\n\n      tagStack.push(m[1]);\n      current.appendChild(node);\n      current = node;\n      continue;\n    } // Text nodes are leaf nodes.\n\n\n    current.appendChild(window.document.createTextNode(unescape(t)));\n  }\n\n  return rootDiv;\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\n\n\nvar strongRTLRanges = [[0x5be, 0x5be], [0x5c0, 0x5c0], [0x5c3, 0x5c3], [0x5c6, 0x5c6], [0x5d0, 0x5ea], [0x5f0, 0x5f4], [0x608, 0x608], [0x60b, 0x60b], [0x60d, 0x60d], [0x61b, 0x61b], [0x61e, 0x64a], [0x66d, 0x66f], [0x671, 0x6d5], [0x6e5, 0x6e6], [0x6ee, 0x6ef], [0x6fa, 0x70d], [0x70f, 0x710], [0x712, 0x72f], [0x74d, 0x7a5], [0x7b1, 0x7b1], [0x7c0, 0x7ea], [0x7f4, 0x7f5], [0x7fa, 0x7fa], [0x800, 0x815], [0x81a, 0x81a], [0x824, 0x824], [0x828, 0x828], [0x830, 0x83e], [0x840, 0x858], [0x85e, 0x85e], [0x8a0, 0x8a0], [0x8a2, 0x8ac], [0x200f, 0x200f], [0xfb1d, 0xfb1d], [0xfb1f, 0xfb28], [0xfb2a, 0xfb36], [0xfb38, 0xfb3c], [0xfb3e, 0xfb3e], [0xfb40, 0xfb41], [0xfb43, 0xfb44], [0xfb46, 0xfbc1], [0xfbd3, 0xfd3d], [0xfd50, 0xfd8f], [0xfd92, 0xfdc7], [0xfdf0, 0xfdfc], [0xfe70, 0xfe74], [0xfe76, 0xfefc], [0x10800, 0x10805], [0x10808, 0x10808], [0x1080a, 0x10835], [0x10837, 0x10838], [0x1083c, 0x1083c], [0x1083f, 0x10855], [0x10857, 0x1085f], [0x10900, 0x1091b], [0x10920, 0x10939], [0x1093f, 0x1093f], [0x10980, 0x109b7], [0x109be, 0x109bf], [0x10a00, 0x10a00], [0x10a10, 0x10a13], [0x10a15, 0x10a17], [0x10a19, 0x10a33], [0x10a40, 0x10a47], [0x10a50, 0x10a58], [0x10a60, 0x10a7f], [0x10b00, 0x10b35], [0x10b40, 0x10b55], [0x10b58, 0x10b72], [0x10b78, 0x10b7f], [0x10c00, 0x10c48], [0x1ee00, 0x1ee03], [0x1ee05, 0x1ee1f], [0x1ee21, 0x1ee22], [0x1ee24, 0x1ee24], [0x1ee27, 0x1ee27], [0x1ee29, 0x1ee32], [0x1ee34, 0x1ee37], [0x1ee39, 0x1ee39], [0x1ee3b, 0x1ee3b], [0x1ee42, 0x1ee42], [0x1ee47, 0x1ee47], [0x1ee49, 0x1ee49], [0x1ee4b, 0x1ee4b], [0x1ee4d, 0x1ee4f], [0x1ee51, 0x1ee52], [0x1ee54, 0x1ee54], [0x1ee57, 0x1ee57], [0x1ee59, 0x1ee59], [0x1ee5b, 0x1ee5b], [0x1ee5d, 0x1ee5d], [0x1ee5f, 0x1ee5f], [0x1ee61, 0x1ee62], [0x1ee64, 0x1ee64], [0x1ee67, 0x1ee6a], [0x1ee6c, 0x1ee72], [0x1ee74, 0x1ee77], [0x1ee79, 0x1ee7c], [0x1ee7e, 0x1ee7e], [0x1ee80, 0x1ee89], [0x1ee8b, 0x1ee9b], [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\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\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\n      if (m) {\n        nodeStack.length = 0;\n        return m[0];\n      }\n\n      return text;\n    }\n\n    if (node.tagName === \"ruby\") {\n      return nextTextNode(nodeStack);\n    }\n\n    if (node.childNodes) {\n      pushNodes(nodeStack, node);\n      return nextTextNode(nodeStack);\n    }\n  }\n\n  pushNodes(nodeStack, cueDiv);\n\n  while (text = nextTextNode(nodeStack)) {\n    for (var i = 0; i < text.length; i++) {\n      charCode = text.charCodeAt(i);\n\n      if (isStrongRTLChar(charCode)) {\n        return \"rtl\";\n      }\n    }\n  }\n\n  return \"ltr\";\n}\n\nfunction computeLinePos(cue) {\n  if (typeof cue.line === \"number\" && (cue.snapToLines || cue.line >= 0 && cue.line <= 100)) {\n    return cue.line;\n  }\n\n  if (!cue.track || !cue.track.textTrackList || !cue.track.textTrackList.mediaElement) {\n    return -1;\n  }\n\n  var track = cue.track,\n      trackList = track.textTrackList,\n      count = 0;\n\n  for (var i = 0; i < trackList.length && trackList[i] !== track; i++) {\n    if (trackList[i].mode === \"showing\") {\n      count++;\n    }\n  }\n\n  return ++count * -1;\n}\n\nfunction StyleBox() {} // Apply styles to a div. If there is no div passed then it defaults to the\n// div on 'this'.\n\n\nStyleBox.prototype.applyStyles = function (styles, div) {\n  div = div || this.div;\n\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}; // 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).\n\n\nfunction CueStyleBox(window, cue, styleOptions) {\n  StyleBox.call(this);\n  this.cue = cue; // 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\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\" : cue.vertical === \"lr\" ? \"vertical-lr\" : \"vertical-rl\",\n    unicodeBidi: \"plaintext\"\n  };\n  this.applyStyles(styles, this.cueDiv); // 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\n  this.div = window.document.createElement(\"div\");\n  styles = {\n    direction: determineBidi(this.cueDiv),\n    writingMode: cue.vertical === \"\" ? \"horizontal-tb\" : cue.vertical === \"lr\" ? \"vertical-lr\" : \"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  this.applyStyles(styles);\n  this.div.appendChild(this.cueDiv); // 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\n  var textPos = 0;\n\n  switch (cue.positionAlign) {\n    case \"start\":\n      textPos = cue.position;\n      break;\n\n    case \"center\":\n      textPos = cue.position - cue.size / 2;\n      break;\n\n    case \"end\":\n      textPos = cue.position - cue.size;\n      break;\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\n\n  if (cue.vertical === \"\") {\n    this.applyStyles({\n      left: this.formatStyle(textPos, \"%\"),\n      width: this.formatStyle(cue.size, \"%\")\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}\n\nCueStyleBox.prototype = _objCreate(StyleBox.prototype);\nCueStyleBox.prototype.constructor = CueStyleBox; // 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.\n\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\n  if (obj.div) {\n    height = obj.div.offsetHeight;\n    width = obj.div.offsetWidth;\n    top = obj.div.offsetTop;\n    var rects = (rects = obj.div.childNodes) && (rects = rects[0]) && rects.getClientRects && rects.getClientRects();\n    obj = obj.div.getBoundingClientRect(); // 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\n    lh = rects ? Math.max(rects[0] && rects[0].height || 0, obj.height / rects.length) : 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} // 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.\n\n\nBoxPosition.prototype.move = function (axis, toMove) {\n  toMove = toMove !== undefined ? toMove : this.lineHeight;\n\n  switch (axis) {\n    case \"+x\":\n      this.left += toMove;\n      this.right += toMove;\n      break;\n\n    case \"-x\":\n      this.left -= toMove;\n      this.right -= toMove;\n      break;\n\n    case \"+y\":\n      this.top += toMove;\n      this.bottom += toMove;\n      break;\n\n    case \"-y\":\n      this.top -= toMove;\n      this.bottom -= toMove;\n      break;\n  }\n}; // Check if this box overlaps another box, b2.\n\n\nBoxPosition.prototype.overlaps = function (b2) {\n  return this.left < b2.right && this.right > b2.left && this.top < b2.bottom && this.bottom > b2.top;\n}; // Check if this box overlaps any other boxes in boxes.\n\n\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\n  return false;\n}; // Check if this box is within another box.\n\n\nBoxPosition.prototype.within = function (container) {\n  return this.top >= container.top && this.bottom <= container.bottom && this.left >= container.left && this.right <= container.right;\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.\n\n\nBoxPosition.prototype.overlapsOppositeAxis = function (container, axis) {\n  switch (axis) {\n    case \"+x\":\n      return this.left < container.left;\n\n    case \"-x\":\n      return this.right > container.right;\n\n    case \"+y\":\n      return this.top < container.top;\n\n    case \"-y\":\n      return this.bottom > container.bottom;\n  }\n}; // Find the percentage of the area that this box is overlapping with another\n// box.\n\n\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}; // 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.\n\n\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}; // Get an object that represents the box's position without anything extra.\n// Can pass a StyleBox, HTMLElement, or another BoxPositon.\n\n\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  obj = obj.div ? obj.div.getBoundingClientRect() : 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}; // 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.\n\n\nfunction moveBoxToLinePosition(window, styleBox, containerBox, boxPositions) {\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]) || b.within(containerBox) && b.overlapsAny(boxPositions)) {\n        b.move(axis[i]);\n      } // We found a spot where we aren't overlapping anything. This is our\n      // best position.\n\n\n      if (b.within(containerBox)) {\n        return b;\n      }\n\n      var p = b.intersectPercentage(containerBox); // 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\n      if (percentage > p) {\n        bestPosition = new BoxPosition(b);\n        percentage = p;\n      } // Reset the box position to the specified position.\n\n\n      b = new BoxPosition(specifiedPosition);\n    }\n\n    return bestPosition || specifiedPosition;\n  }\n\n  var boxPosition = new BoxPosition(styleBox),\n      cue = styleBox.cue,\n      linePos = computeLinePos(cue),\n      axis = []; // If we have a line number to align the cue to.\n\n  if (cue.snapToLines) {\n    var size;\n\n    switch (cue.vertical) {\n      case \"\":\n        axis = [\"+y\", \"-y\"];\n        size = \"height\";\n        break;\n\n      case \"rl\":\n        axis = [\"+x\", \"-x\"];\n        size = \"width\";\n        break;\n\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]; // 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\n    if (Math.abs(position) > maxPosition) {\n      position = position < 0 ? -1 : 1;\n      position *= Math.ceil(maxPosition / step) * step;\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\n\n    if (linePos < 0) {\n      position += cue.vertical === \"\" ? containerBox.height : containerBox.width;\n      axis = axis.reverse();\n    } // Move the box to the specified position. This may not be its best\n    // position.\n\n\n    boxPosition.move(initialAxis, position);\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\n      case \"end\":\n        linePos -= calculatedPercentage;\n        break;\n    } // Apply initial line position to the cue box.\n\n\n    switch (cue.vertical) {\n      case \"\":\n        styleBox.applyStyles({\n          top: styleBox.formatStyle(linePos, \"%\")\n        });\n        break;\n\n      case \"rl\":\n        styleBox.applyStyles({\n          left: styleBox.formatStyle(linePos, \"%\")\n        });\n        break;\n\n      case \"lr\":\n        styleBox.applyStyles({\n          right: styleBox.formatStyle(linePos, \"%\")\n        });\n        break;\n    }\n\n    axis = [\"+y\", \"-x\", \"+x\", \"-y\"]; // Get the box position again after we've applied the specified positioning\n    // to it.\n\n    boxPosition = new BoxPosition(styleBox);\n  }\n\n  var bestPosition = findBestPosition(boxPosition, axis);\n  styleBox.move(bestPosition.toCSSCompatValues(containerBox));\n}\n\nfunction WebVTT() {// Nothing\n} // Helper to allow strings to be decoded instead of the default binary utf8 data.\n\n\nWebVTT.StringDecoder = function () {\n  return {\n    decode: function decode(data) {\n      if (!data) {\n        return \"\";\n      }\n\n      if (typeof data !== \"string\") {\n        throw new Error(\"Error - expected string data.\");\n      }\n\n      return decodeURIComponent(encodeURIComponent(data));\n    }\n  };\n};\n\nWebVTT.convertCueToDOMTree = function (window, cuetext) {\n  if (!window || !cuetext) {\n    return null;\n  }\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%\"; // 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.\n\nWebVTT.processCues = function (window, cues, overlay) {\n  if (!window || !cues || !overlay) {\n    return null;\n  } // Remove all previous children.\n\n\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); // 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\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\n    return false;\n  } // We don't need to recompute the cues' display states. Just reuse them.\n\n\n  if (!shouldCompute(cues)) {\n    for (var i = 0; i < cues.length; i++) {\n      paddedOverlay.appendChild(cues[i].displayState);\n    }\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]; // Compute the intial position and styles of the cue div.\n\n      styleBox = new CueStyleBox(window, cue, styleOptions);\n      paddedOverlay.appendChild(styleBox.div); // Move the cue div to it's correct line position.\n\n      moveBoxToLinePosition(window, styleBox, containerBox, boxPositions); // Remember the computed div so that we don't have to recompute it later\n      // if we don't have too.\n\n      cue.displayState = styleBox.div;\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\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 reportOrThrowError(e) {\n    if (e instanceof ParsingError) {\n      this.onparsingerror && this.onparsingerror(e);\n    } else {\n      throw e;\n    }\n  },\n  parse: function parse(data) {\n    var self = this; // 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\n    if (data) {\n      // Try to decode the data that we received.\n      self.buffer += self.decoder.decode(data, {\n        stream: true\n      });\n    }\n\n    function collectNextLine() {\n      var buffer = self.buffer;\n      var pos = 0;\n\n      while (pos < buffer.length && buffer[pos] !== '\\r' && buffer[pos] !== '\\n') {\n        ++pos;\n      }\n\n      var line = buffer.substr(0, pos); // Advance the buffer early in case we fail below.\n\n      if (buffer[pos] === '\\r') {\n        ++pos;\n      }\n\n      if (buffer[pos] === '\\n') {\n        ++pos;\n      }\n\n      self.buffer = buffer.substr(pos);\n      return line;\n    } // 3.4 WebVTT region and WebVTT region settings syntax\n\n\n    function parseRegion(input) {\n      var settings = new Settings();\n      parseOptions(input, function (k, v) {\n        switch (k) {\n          case \"id\":\n            settings.set(k, v);\n            break;\n\n          case \"width\":\n            settings.percent(k, v);\n            break;\n\n          case \"lines\":\n            settings.integer(k, v);\n            break;\n\n          case \"regionanchor\":\n          case \"viewportanchor\":\n            var xy = v.split(',');\n\n            if (xy.length !== 2) {\n              break;\n            } // We have to make sure both x and y parse, so use a temporary\n            // settings object here.\n\n\n            var anchor = new Settings();\n            anchor.percent(\"x\", xy[0]);\n            anchor.percent(\"y\", xy[1]);\n\n            if (!anchor.has(\"x\") || !anchor.has(\"y\")) {\n              break;\n            }\n\n            settings.set(k + \"X\", anchor.get(\"x\"));\n            settings.set(k + \"Y\", anchor.get(\"y\"));\n            break;\n\n          case \"scroll\":\n            settings.alt(k, v, [\"up\"]);\n            break;\n        }\n      }, /=/, /\\s/); // Create the region, using default values for any values that were not\n      // specified.\n\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\", \"\"); // Register the region.\n\n        self.onregion && self.onregion(region); // Remember the VTTRegion for later in case we parse any VTTCues that\n        // reference it.\n\n        self.regionList.push({\n          id: settings.get(\"id\"),\n          region: region\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\n\n    function parseTimestampMap(input) {\n      var settings = new Settings();\n      parseOptions(input, function (k, v) {\n        switch (k) {\n          case \"MPEGT\":\n            settings.integer(k + 'S', v);\n            break;\n\n          case \"LOCA\":\n            settings.set(k + 'L', parseTimeStamp(v));\n            break;\n        }\n      }, /[^\\d]:/, /,/);\n      self.ontimestampmap && self.ontimestampmap({\n        \"MPEGTS\": settings.get(\"MPEGTS\"),\n        \"LOCAL\": settings.get(\"LOCAL\")\n      });\n    } // 3.2 WebVTT metadata header syntax\n\n\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    } // 5.1 WebVTT file parsing.\n\n\n    try {\n      var line;\n\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        var m = line.match(/^WEBVTT([ \\t].*)?$/);\n\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\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\n            continue;\n\n          case \"NOTE\":\n            // Ignore NOTE blocks.\n            if (!line) {\n              self.state = \"ID\";\n            }\n\n            continue;\n\n          case \"ID\":\n            // Check for the start of NOTE blocks.\n            if (/^NOTE($|[ \\t])/.test(line)) {\n              self.state = \"NOTE\";\n              break;\n            } // 19-29 - Allow any number of line terminators, then initialize new cue values.\n\n\n            if (!line) {\n              continue;\n            }\n\n            self.cue = new (self.vttjs.VTTCue || self.window.VTTCue)(0, 0, \"\"); // Safari still uses the old middle value and won't accept center\n\n            try {\n              self.cue.align = \"center\";\n            } catch (e) {\n              self.cue.align = \"middle\";\n            }\n\n            self.state = \"CUE\"; // 30-39 - Check if self line contains an optional identifier or timing data.\n\n            if (line.indexOf(\"-->\") === -1) {\n              self.cue.id = line;\n              continue;\n            }\n\n          // Process line as start of a cue.\n\n          /*falls through*/\n\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); // In case of an error ignore rest of the cue.\n\n              self.cue = null;\n              self.state = \"BADCUE\";\n              continue;\n            }\n\n            self.state = \"CUETEXT\";\n            continue;\n\n          case \"CUETEXT\":\n            var hasSubstring = line.indexOf(\"-->\") !== -1; // 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\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\n            if (self.cue.text) {\n              self.cue.text += \"\\n\";\n            }\n\n            self.cue.text += line.replace(/\\u2028/g, '\\n').replace(/u2029/g, '\\n');\n            continue;\n\n          case \"BADCUE\":\n            // BADCUE\n            // 54-62 - Collect and discard the remaining cue.\n            if (!line) {\n              self.state = \"ID\";\n            }\n\n            continue;\n        }\n      }\n    } catch (e) {\n      self.reportOrThrowError(e); // If we are currently parsing a cue, report what we have.\n\n      if (self.state === \"CUETEXT\" && self.cue && self.oncue) {\n        self.oncue(self.cue);\n      }\n\n      self.cue = null; // Enter BADWEBVTT state if header was not parsed correctly otherwise\n      // another exception occurred so enter BADCUE state.\n\n      self.state = self.state === \"INITIAL\" ? \"BADWEBVTT\" : \"BADCUE\";\n    }\n\n    return this;\n  },\n  flush: function flush() {\n    var self = this;\n\n    try {\n      // Finish decoding the stream.\n      self.buffer += self.decoder.decode(); // Synthesize the end of the current cue or region.\n\n      if (self.cue || self.state === \"HEADER\") {\n        self.buffer += \"\\n\\n\";\n        self.parse();\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\n\n      if (self.state === \"INITIAL\") {\n        throw new ParsingError(ParsingError.Errors.BadSignature);\n      }\n    } catch (e) {\n      self.reportOrThrowError(e);\n    }\n\n    self.onflush && self.onflush();\n    return this;\n  }\n};\nmodule.exports = WebVTT;","/**\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 */\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\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\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  // 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   * 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  Object.defineProperties(this, {\n    \"id\": {\n      enumerable: true,\n      get: function get() {\n        return _id;\n      },\n      set: function set(value) {\n        _id = \"\" + value;\n      }\n    },\n    \"pauseOnExit\": {\n      enumerable: true,\n      get: function get() {\n        return _pauseOnExit;\n      },\n      set: function set(value) {\n        _pauseOnExit = !!value;\n      }\n    },\n    \"startTime\": {\n      enumerable: true,\n      get: function get() {\n        return _startTime;\n      },\n      set: function set(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Start time must be set to a number.\");\n        }\n\n        _startTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"endTime\": {\n      enumerable: true,\n      get: function get() {\n        return _endTime;\n      },\n      set: function set(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"End time must be set to a number.\");\n        }\n\n        _endTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"text\": {\n      enumerable: true,\n      get: function get() {\n        return _text;\n      },\n      set: function set(value) {\n        _text = \"\" + value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"region\": {\n      enumerable: true,\n      get: function get() {\n        return _region;\n      },\n      set: function set(value) {\n        _region = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"vertical\": {\n      enumerable: true,\n      get: function get() {\n        return _vertical;\n      },\n      set: function set(value) {\n        var setting = findDirectionSetting(value); // Have to check for false because the setting an be an empty string.\n\n        if (setting === false) {\n          throw new SyntaxError(\"Vertical: an invalid or illegal direction string was specified.\");\n        }\n\n        _vertical = setting;\n        this.hasBeenReset = true;\n      }\n    },\n    \"snapToLines\": {\n      enumerable: true,\n      get: function get() {\n        return _snapToLines;\n      },\n      set: function set(value) {\n        _snapToLines = !!value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"line\": {\n      enumerable: true,\n      get: function get() {\n        return _line;\n      },\n      set: function set(value) {\n        if (typeof value !== \"number\" && value !== autoKeyword) {\n          throw new SyntaxError(\"Line: an invalid number or illegal string was specified.\");\n        }\n\n        _line = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"lineAlign\": {\n      enumerable: true,\n      get: function get() {\n        return _lineAlign;\n      },\n      set: function set(value) {\n        var setting = findAlignSetting(value);\n\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    \"position\": {\n      enumerable: true,\n      get: function get() {\n        return _position;\n      },\n      set: function set(value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Position must be between 0 and 100.\");\n        }\n\n        _position = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"positionAlign\": {\n      enumerable: true,\n      get: function get() {\n        return _positionAlign;\n      },\n      set: function set(value) {\n        var setting = findAlignSetting(value);\n\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    \"size\": {\n      enumerable: true,\n      get: function get() {\n        return _size;\n      },\n      set: function set(value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Size must be between 0 and 100.\");\n        }\n\n        _size = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"align\": {\n      enumerable: true,\n      get: function get() {\n        return _align;\n      },\n      set: function set(value) {\n        var setting = findAlignSetting(value);\n\n        if (!setting) {\n          throw new SyntaxError(\"align: an invalid or illegal alignment string was specified.\");\n        }\n\n        _align = setting;\n        this.hasBeenReset = true;\n      }\n    }\n  });\n  /**\n   * Other <track> spec defined properties\n   */\n  // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-display-state\n\n  this.displayState = undefined;\n}\n/**\n * VTTCue methods\n */\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 * 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 */\nvar scrollSetting = {\n  \"\": true,\n  \"up\": true\n};\n\nfunction findScrollSetting(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\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} // VTTRegion shim http://dev.w3.org/html5/webvtt/#vttregion-interface\n\n\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  Object.defineProperties(this, {\n    \"width\": {\n      enumerable: true,\n      get: function get() {\n        return _width;\n      },\n      set: function set(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"Width must be between 0 and 100.\");\n        }\n\n        _width = value;\n      }\n    },\n    \"lines\": {\n      enumerable: true,\n      get: function get() {\n        return _lines;\n      },\n      set: function set(value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Lines must be set to a number.\");\n        }\n\n        _lines = value;\n      }\n    },\n    \"regionAnchorY\": {\n      enumerable: true,\n      get: function get() {\n        return _regionAnchorY;\n      },\n      set: function set(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorX must be between 0 and 100.\");\n        }\n\n        _regionAnchorY = value;\n      }\n    },\n    \"regionAnchorX\": {\n      enumerable: true,\n      get: function get() {\n        return _regionAnchorX;\n      },\n      set: function set(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorY must be between 0 and 100.\");\n        }\n\n        _regionAnchorX = value;\n      }\n    },\n    \"viewportAnchorY\": {\n      enumerable: true,\n      get: function get() {\n        return _viewportAnchorY;\n      },\n      set: function set(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorY must be between 0 and 100.\");\n        }\n\n        _viewportAnchorY = value;\n      }\n    },\n    \"viewportAnchorX\": {\n      enumerable: true,\n      get: function get() {\n        return _viewportAnchorX;\n      },\n      set: function set(value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorX must be between 0 and 100.\");\n        }\n\n        _viewportAnchorX = value;\n      }\n    },\n    \"scroll\": {\n      enumerable: true,\n      get: function get() {\n        return _scroll;\n      },\n      set: function set(value) {\n        var setting = findScrollSetting(value); // Have to check for false as an empty string is a legal value.\n\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;","import React from \"react\";\nimport VideoJS from \"./video\";\nimport { cdn } from \"../../authConfig\";\nimport { useLocation } from \"@reach/router\";\n\nconst FreeVideo = (props) => {\n  const { videoJson, className, withDoc } = props;\n  const location = useLocation();\n  const cdnUrl =\n    location.hostname === \"www.mizuno-ch.cn\" ? cdn.url_cn : cdn.url;\n\n  // https://docs.videojs.com/tutorial-react.html\n  const playerRef = React.useRef(null);\n  const videoJsOptions = {\n    // lookup the options in the docs for more options\n    autoplay: false,\n    controls: true,\n    playbackRates: [0.5, 1, 1.5, 2],\n    responsive: true,\n    fluid: true,\n    sources: [\n      {\n        src: cdnUrl + `/public/videos/${videoJson.slug}/playlist.m3u8`,\n        type: \"application/x-mpegURL\",\n      },\n    ],\n    poster: cdnUrl + `/public/thumbnails/${videoJson.slug}.webp`,\n  };\n  const handlePlayerReady = (player) => {\n    playerRef.current = player;\n\n    // you can handle player events here\n    player.on(\"waiting\", () => {\n      console.log(\"player is waiting\");\n    });\n\n    player.on(\"dispose\", () => {\n      console.log(\"player will dispose\");\n    });\n  };\n\n  return (\n    <>\n      <VideoJS\n        options={videoJsOptions}\n        onReady={handlePlayerReady}\n        className={className}\n        videoJson={videoJson}\n      />\n      {withDoc &&\n      videoJson.series !== \"katari\" &&\n      videoJson.series !== \"taidan\" ? (\n        <div className=\"flex justify-center\">\n          <a\n            href={cdnUrl + `/public/docs/${videoJson.slug}.pdf`}\n            download\n            target=\"_blank\"\n            rel=\"noreferrer\"\n            className=\"inline-block px-5 md:px-10 py-2 md:py-3 bg-cyan-800 hover:bg-cyan-700 text-white rounded-md mt-5 text-center font-sans tracking-wider\"\n          >\n            レジュメPDFダウンロード\n          </a>\n        </div>\n      ) : null}\n    </>\n  );\n};\n\nexport default FreeVideo;\n","import videojs from 'video.js';\nvar version = \"1.1.4\";\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar asyncGenerator = function () {\n  function AwaitValue(value) {\n    this.value = value;\n  }\n\n  function AsyncGenerator(gen) {\n    var front, back;\n\n    function send(key, arg) {\n      return new Promise(function (resolve, reject) {\n        var request = {\n          key: key,\n          arg: arg,\n          resolve: resolve,\n          reject: reject,\n          next: null\n        };\n\n        if (back) {\n          back = back.next = request;\n        } else {\n          front = back = request;\n          resume(key, arg);\n        }\n      });\n    }\n\n    function resume(key, arg) {\n      try {\n        var result = gen[key](arg);\n        var value = result.value;\n\n        if (value instanceof AwaitValue) {\n          Promise.resolve(value.value).then(function (arg) {\n            resume(\"next\", arg);\n          }, function (arg) {\n            resume(\"throw\", arg);\n          });\n        } else {\n          settle(result.done ? \"return\" : \"normal\", result.value);\n        }\n      } catch (err) {\n        settle(\"throw\", err);\n      }\n    }\n\n    function settle(type, value) {\n      switch (type) {\n        case \"return\":\n          front.resolve({\n            value: value,\n            done: true\n          });\n          break;\n\n        case \"throw\":\n          front.reject(value);\n          break;\n\n        default:\n          front.resolve({\n            value: value,\n            done: false\n          });\n          break;\n      }\n\n      front = front.next;\n\n      if (front) {\n        resume(front.key, front.arg);\n      } else {\n        back = null;\n      }\n    }\n\n    this._invoke = send;\n\n    if (typeof gen.return !== \"function\") {\n      this.return = undefined;\n    }\n  }\n\n  if (typeof Symbol === \"function\" && Symbol.asyncIterator) {\n    AsyncGenerator.prototype[Symbol.asyncIterator] = function () {\n      return this;\n    };\n  }\n\n  AsyncGenerator.prototype.next = function (arg) {\n    return this._invoke(\"next\", arg);\n  };\n\n  AsyncGenerator.prototype.throw = function (arg) {\n    return this._invoke(\"throw\", arg);\n  };\n\n  AsyncGenerator.prototype.return = function (arg) {\n    return this._invoke(\"return\", arg);\n  };\n\n  return {\n    wrap: function wrap(fn) {\n      return function () {\n        return new AsyncGenerator(fn.apply(this, arguments));\n      };\n    },\n    await: function _await(value) {\n      return new AwaitValue(value);\n    }\n  };\n}();\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar inherits = function inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar VideoJsButtonClass = videojs.getComponent('MenuButton');\nvar VideoJsMenuClass = videojs.getComponent('Menu');\nvar VideoJsComponent = videojs.getComponent('Component');\nvar Dom = videojs.dom;\n/**\n * Convert string to title case.\n *\n * @param {string} string - the string to convert\n * @return {string} the returned titlecase string\n */\n\nfunction toTitleCase(string) {\n  if (typeof string !== 'string') {\n    return string;\n  }\n\n  return string.charAt(0).toUpperCase() + string.slice(1);\n}\n/**\n * Extend vjs button class for quality button.\n */\n\n\nvar ConcreteButton = function (_VideoJsButtonClass) {\n  inherits(ConcreteButton, _VideoJsButtonClass);\n  /**\n   * Button constructor.\n   *\n   * @param {Player} player - videojs player instance\n   */\n\n  function ConcreteButton(player) {\n    classCallCheck(this, ConcreteButton);\n    return possibleConstructorReturn(this, _VideoJsButtonClass.call(this, player, {\n      title: player.localize('Quality'),\n      name: 'QualityButton'\n    }));\n  }\n  /**\n   * Creates button items.\n   *\n   * @return {Array} - Button items\n   */\n\n\n  ConcreteButton.prototype.createItems = function createItems() {\n    return [];\n  };\n  /**\n   * Create the menu and add all items to it.\n   *\n   * @return {Menu}\n   *         The constructed menu\n   */\n\n\n  ConcreteButton.prototype.createMenu = function createMenu() {\n    var menu = new VideoJsMenuClass(this.player_, {\n      menuButton: this\n    });\n    this.hideThreshold_ = 0; // Add a title list item to the top\n\n    if (this.options_.title) {\n      var titleEl = Dom.createEl('li', {\n        className: 'vjs-menu-title',\n        innerHTML: toTitleCase(this.options_.title),\n        tabIndex: -1\n      });\n      var titleComponent = new VideoJsComponent(this.player_, {\n        el: titleEl\n      });\n      this.hideThreshold_ += 1;\n      menu.addItem(titleComponent);\n    }\n\n    this.items = this.createItems();\n\n    if (this.items) {\n      // Add menu items to the menu\n      for (var i = 0; i < this.items.length; i++) {\n        menu.addItem(this.items[i]);\n      }\n    }\n\n    return menu;\n  };\n\n  return ConcreteButton;\n}(VideoJsButtonClass); // Concrete classes\n\n\nvar VideoJsMenuItemClass = videojs.getComponent('MenuItem');\n/**\n * Extend vjs menu item class.\n */\n\nvar ConcreteMenuItem = function (_VideoJsMenuItemClass) {\n  inherits(ConcreteMenuItem, _VideoJsMenuItemClass);\n  /**\n   * Menu item constructor.\n   *\n   * @param {Player} player - vjs player\n   * @param {Object} item - Item object\n   * @param {ConcreteButton} qualityButton - The containing button.\n   * @param {HlsQualitySelectorPlugin} plugin - This plugin instance.\n   */\n\n  function ConcreteMenuItem(player, item, qualityButton, plugin) {\n    classCallCheck(this, ConcreteMenuItem);\n\n    var _this = possibleConstructorReturn(this, _VideoJsMenuItemClass.call(this, player, {\n      label: item.label,\n      selectable: true,\n      selected: item.selected || false\n    }));\n\n    _this.item = item;\n    _this.qualityButton = qualityButton;\n    _this.plugin = plugin;\n    return _this;\n  }\n  /**\n   * Click event for menu item.\n   */\n\n\n  ConcreteMenuItem.prototype.handleClick = function handleClick() {\n    // Reset other menu items selected status.\n    for (var i = 0; i < this.qualityButton.items.length; ++i) {\n      this.qualityButton.items[i].selected(false);\n    } // Set this menu item to selected, and set quality.\n\n\n    this.plugin.setQuality(this.item.value);\n    this.selected(true);\n  };\n\n  return ConcreteMenuItem;\n}(VideoJsMenuItemClass); // Default options for the plugin.\n\n\nvar defaults = {}; // Cross-compatibility for Video.js 5 and 6.\n\nvar registerPlugin = videojs.registerPlugin || videojs.plugin; // const dom = videojs.dom || videojs;\n\n/**\n * VideoJS HLS Quality Selector Plugin class.\n */\n\nvar HlsQualitySelectorPlugin = function () {\n  /**\n   * Plugin Constructor.\n   *\n   * @param {Player} player - The videojs player instance.\n   * @param {Object} options - The plugin options.\n   */\n  function HlsQualitySelectorPlugin(player, options) {\n    classCallCheck(this, HlsQualitySelectorPlugin);\n    this.player = player;\n    this.config = options; // If there is quality levels plugin and the HLS tech exists\n    // then continue.\n\n    if (this.player.qualityLevels && this.getHls()) {\n      // Create the quality button.\n      this.createQualityButton();\n      this.bindPlayerEvents();\n    }\n  }\n  /**\n   * Returns HLS Plugin\n   *\n   * @return {*} - videojs-hls-contrib plugin.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.getHls = function getHls() {\n    return this.player.tech({\n      IWillNotUseThisInPlugins: true\n    }).hls;\n  };\n  /**\n   * Binds listener for quality level changes.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.bindPlayerEvents = function bindPlayerEvents() {\n    this.player.qualityLevels().on('addqualitylevel', this.onAddQualityLevel.bind(this));\n  };\n  /**\n   * Adds the quality menu button to the player control bar.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.createQualityButton = function createQualityButton() {\n    var player = this.player;\n    this._qualityButton = new ConcreteButton(player);\n    var placementIndex = player.controlBar.children().length - 2;\n    var concreteButtonInstance = player.controlBar.addChild(this._qualityButton, {\n      componentClass: 'qualitySelector'\n    }, this.config.placementIndex || placementIndex);\n    concreteButtonInstance.addClass('vjs-quality-selector');\n\n    if (!this.config.displayCurrentQuality) {\n      var icon = ' ' + (this.config.vjsIconClass || 'vjs-icon-hd');\n      concreteButtonInstance.menuButton_.$('.vjs-icon-placeholder').className += icon;\n    } else {\n      this.setButtonInnerText('auto');\n    }\n\n    concreteButtonInstance.removeClass('vjs-hidden');\n  };\n  /**\n   *Set inner button text.\n   *\n   * @param {string} text - the text to display in the button.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.setButtonInnerText = function setButtonInnerText(text) {\n    this._qualityButton.menuButton_.$('.vjs-icon-placeholder').innerHTML = text;\n  };\n  /**\n   * Builds individual quality menu items.\n   *\n   * @param {Object} item - Individual quality menu item.\n   * @return {ConcreteMenuItem} - Menu item\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.getQualityMenuItem = function getQualityMenuItem(item) {\n    var player = this.player;\n    return new ConcreteMenuItem(player, item, this._qualityButton, this);\n  };\n  /**\n   * Executed when a quality level is added from HLS playlist.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.onAddQualityLevel = function onAddQualityLevel() {\n    var _this = this;\n\n    var player = this.player;\n    var qualityList = player.qualityLevels();\n    var levels = qualityList.levels_ || [];\n    var levelItems = [];\n\n    var _loop = function _loop(i) {\n      if (!levelItems.filter(function (_existingItem) {\n        return _existingItem.item && _existingItem.item.value === levels[i].height;\n      }).length) {\n        var levelItem = _this.getQualityMenuItem.call(_this, {\n          label: levels[i].height + 'p',\n          value: levels[i].height\n        });\n\n        levelItems.push(levelItem);\n      }\n    };\n\n    for (var i = 0; i < levels.length; ++i) {\n      _loop(i);\n    }\n\n    levelItems.sort(function (current, next) {\n      if ((typeof current === 'undefined' ? 'undefined' : _typeof(current)) !== 'object' || (typeof next === 'undefined' ? 'undefined' : _typeof(next)) !== 'object') {\n        return -1;\n      }\n\n      if (current.item.value < next.item.value) {\n        return -1;\n      }\n\n      if (current.item.value > next.item.value) {\n        return 1;\n      }\n\n      return 0;\n    });\n    levelItems.push(this.getQualityMenuItem.call(this, {\n      label: player.localize('Auto'),\n      value: 'auto',\n      selected: true\n    }));\n\n    if (this._qualityButton) {\n      this._qualityButton.createItems = function () {\n        return levelItems;\n      };\n\n      this._qualityButton.update();\n    }\n  };\n  /**\n   * Sets quality (based on media height)\n   *\n   * @param {number} height - A number representing HLS playlist.\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.setQuality = function setQuality(height) {\n    var qualityList = this.player.qualityLevels(); // Set quality on plugin\n\n    this._currentQuality = height;\n\n    if (this.config.displayCurrentQuality) {\n      this.setButtonInnerText(height === 'auto' ? height : height + 'p');\n    }\n\n    for (var i = 0; i < qualityList.length; ++i) {\n      var quality = qualityList[i];\n      quality.enabled = quality.height === height || height === 'auto';\n    }\n\n    this._qualityButton.unpressButton();\n  };\n  /**\n   * Return the current set quality or 'auto'\n   *\n   * @return {string} the currently set quality\n   */\n\n\n  HlsQualitySelectorPlugin.prototype.getCurrentQuality = function getCurrentQuality() {\n    return this._currentQuality || 'auto';\n  };\n\n  return HlsQualitySelectorPlugin;\n}();\n/**\n * Function to invoke when the player is ready.\n *\n * This is a great place for your plugin to initialize itself. When this\n * function is called, the player will have its DOM and child components\n * in place.\n *\n * @function onPlayerReady\n * @param    {Player} player\n *           A Video.js player object.\n *\n * @param    {Object} [options={}]\n *           A plain object containing options for the plugin.\n */\n\n\nvar onPlayerReady = function onPlayerReady(player, options) {\n  player.addClass('vjs-hls-quality-selector');\n  player.hlsQualitySelector = new HlsQualitySelectorPlugin(player, options);\n};\n/**\n * A video.js plugin.\n *\n * In the plugin function, the value of `this` is a video.js `Player`\n * instance. You cannot rely on the player being in a \"ready\" state here,\n * depending on how the plugin is invoked. This may or may not be important\n * to you; if not, remove the wait for \"ready\"!\n *\n * @function hlsQualitySelector\n * @param    {Object} [options={}]\n *           An object of options left to the plugin author to define.\n */\n\n\nvar hlsQualitySelector = function hlsQualitySelector(options) {\n  var _this2 = this;\n\n  this.ready(function () {\n    onPlayerReady(_this2, videojs.mergeOptions(defaults, options));\n  });\n}; // Register the plugin with video.js.\n\n\nregisterPlugin('hlsQualitySelector', hlsQualitySelector); // Include the version number.\n\nhlsQualitySelector.VERSION = version;\nexport default hlsQualitySelector;","/*! @name videojs-contrib-quality-levels @version 2.1.0 @license Apache-2.0 */\nimport videojs from 'video.js';\nimport document from 'global/document';\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n/**\n * A single QualityLevel.\n *\n * interface QualityLevel {\n *   readonly attribute DOMString id;\n *            attribute DOMString label;\n *   readonly attribute long width;\n *   readonly attribute long height;\n *   readonly attribute long bitrate;\n *            attribute boolean enabled;\n * };\n *\n * @class QualityLevel\n */\n\n\nvar QualityLevel =\n/**\n * Creates a QualityLevel\n *\n * @param {Representation|Object} representation The representation of the quality level\n * @param {string}   representation.id        Unique id of the QualityLevel\n * @param {number=}  representation.width     Resolution width of the QualityLevel\n * @param {number=}  representation.height    Resolution height of the QualityLevel\n * @param {number}   representation.bandwidth Bitrate of the QualityLevel\n * @param {Function} representation.enabled   Callback to enable/disable QualityLevel\n */\nfunction QualityLevel(representation) {\n  var level = this; // eslint-disable-line\n\n  if (videojs.browser.IS_IE8) {\n    level = document.createElement('custom');\n\n    for (var prop in QualityLevel.prototype) {\n      if (prop !== 'constructor') {\n        level[prop] = QualityLevel.prototype[prop];\n      }\n    }\n  }\n\n  level.id = representation.id;\n  level.label = level.id;\n  level.width = representation.width;\n  level.height = representation.height;\n  level.bitrate = representation.bandwidth;\n  level.enabled_ = representation.enabled;\n  Object.defineProperty(level, 'enabled', {\n    /**\n     * Get whether the QualityLevel is enabled.\n     *\n     * @return {boolean} True if the QualityLevel is enabled.\n     */\n    get: function get() {\n      return level.enabled_();\n    },\n\n    /**\n     * Enable or disable the QualityLevel.\n     *\n     * @param {boolean} enable true to enable QualityLevel, false to disable.\n     */\n    set: function set(enable) {\n      level.enabled_(enable);\n    }\n  });\n  return level;\n};\n/**\n * A list of QualityLevels.\n *\n * interface QualityLevelList : EventTarget {\n *   getter QualityLevel (unsigned long index);\n *   readonly attribute unsigned long length;\n *   readonly attribute long selectedIndex;\n *\n *   void addQualityLevel(QualityLevel qualityLevel)\n *   void removeQualityLevel(QualityLevel remove)\n *   QualityLevel? getQualityLevelById(DOMString id);\n *\n *   attribute EventHandler onchange;\n *   attribute EventHandler onaddqualitylevel;\n *   attribute EventHandler onremovequalitylevel;\n * };\n *\n * @extends videojs.EventTarget\n * @class QualityLevelList\n */\n\n\nvar QualityLevelList = /*#__PURE__*/function (_videojs$EventTarget) {\n  _inheritsLoose(QualityLevelList, _videojs$EventTarget);\n\n  function QualityLevelList() {\n    var _this;\n\n    _this = _videojs$EventTarget.call(this) || this;\n\n    var list = _assertThisInitialized(_assertThisInitialized(_this)); // eslint-disable-line\n\n\n    if (videojs.browser.IS_IE8) {\n      list = document.createElement('custom');\n\n      for (var prop in QualityLevelList.prototype) {\n        if (prop !== 'constructor') {\n          list[prop] = QualityLevelList.prototype[prop];\n        }\n      }\n    }\n\n    list.levels_ = [];\n    list.selectedIndex_ = -1;\n    /**\n     * Get the index of the currently selected QualityLevel.\n     *\n     * @returns {number} The index of the selected QualityLevel. -1 if none selected.\n     * @readonly\n     */\n\n    Object.defineProperty(list, 'selectedIndex', {\n      get: function get() {\n        return list.selectedIndex_;\n      }\n    });\n    /**\n     * Get the length of the list of QualityLevels.\n     *\n     * @returns {number} The length of the list.\n     * @readonly\n     */\n\n    Object.defineProperty(list, 'length', {\n      get: function get() {\n        return list.levels_.length;\n      }\n    });\n    return list || _assertThisInitialized(_this);\n  }\n  /**\n   * Adds a quality level to the list.\n   *\n   * @param {Representation|Object} representation The representation of the quality level\n   * @param {string}   representation.id        Unique id of the QualityLevel\n   * @param {number=}  representation.width     Resolution width of the QualityLevel\n   * @param {number=}  representation.height    Resolution height of the QualityLevel\n   * @param {number}   representation.bandwidth Bitrate of the QualityLevel\n   * @param {Function} representation.enabled   Callback to enable/disable QualityLevel\n   * @return {QualityLevel} the QualityLevel added to the list\n   * @method addQualityLevel\n   */\n\n\n  var _proto = QualityLevelList.prototype;\n\n  _proto.addQualityLevel = function addQualityLevel(representation) {\n    var qualityLevel = this.getQualityLevelById(representation.id); // Do not add duplicate quality levels\n\n    if (qualityLevel) {\n      return qualityLevel;\n    }\n\n    var index = this.levels_.length;\n    qualityLevel = new QualityLevel(representation);\n\n    if (!('' + index in this)) {\n      Object.defineProperty(this, index, {\n        get: function get() {\n          return this.levels_[index];\n        }\n      });\n    }\n\n    this.levels_.push(qualityLevel);\n    this.trigger({\n      qualityLevel: qualityLevel,\n      type: 'addqualitylevel'\n    });\n    return qualityLevel;\n  };\n  /**\n   * Removes a quality level from the list.\n   *\n   * @param {QualityLevel} remove QualityLevel to remove to the list.\n   * @return {QualityLevel|null} the QualityLevel removed or null if nothing removed\n   * @method removeQualityLevel\n   */\n\n\n  _proto.removeQualityLevel = function removeQualityLevel(qualityLevel) {\n    var removed = null;\n\n    for (var i = 0, l = this.length; i < l; i++) {\n      if (this[i] === qualityLevel) {\n        removed = this.levels_.splice(i, 1)[0];\n\n        if (this.selectedIndex_ === i) {\n          this.selectedIndex_ = -1;\n        } else if (this.selectedIndex_ > i) {\n          this.selectedIndex_--;\n        }\n\n        break;\n      }\n    }\n\n    if (removed) {\n      this.trigger({\n        qualityLevel: qualityLevel,\n        type: 'removequalitylevel'\n      });\n    }\n\n    return removed;\n  };\n  /**\n   * Searches for a QualityLevel with the given id.\n   *\n   * @param {string} id The id of the QualityLevel to find.\n   * @return {QualityLevel|null} The QualityLevel with id, or null if not found.\n   * @method getQualityLevelById\n   */\n\n\n  _proto.getQualityLevelById = function getQualityLevelById(id) {\n    for (var i = 0, l = this.length; i < l; i++) {\n      var level = this[i];\n\n      if (level.id === id) {\n        return level;\n      }\n    }\n\n    return null;\n  };\n  /**\n   * Resets the list of QualityLevels to empty\n   *\n   * @method dispose\n   */\n\n\n  _proto.dispose = function dispose() {\n    this.selectedIndex_ = -1;\n    this.levels_.length = 0;\n  };\n\n  return QualityLevelList;\n}(videojs.EventTarget);\n/**\n * change - The selected QualityLevel has changed.\n * addqualitylevel - A QualityLevel has been added to the QualityLevelList.\n * removequalitylevel - A QualityLevel has been removed from the QualityLevelList.\n */\n\n\nQualityLevelList.prototype.allowedEvents_ = {\n  change: 'change',\n  addqualitylevel: 'addqualitylevel',\n  removequalitylevel: 'removequalitylevel'\n}; // emulate attribute EventHandler support to allow for feature detection\n\nfor (var event in QualityLevelList.prototype.allowedEvents_) {\n  QualityLevelList.prototype['on' + event] = null;\n}\n\nvar version = \"2.1.0\";\nvar registerPlugin = videojs.registerPlugin || videojs.plugin;\n/**\n * Initialization function for the qualityLevels plugin. Sets up the QualityLevelList and\n * event handlers.\n *\n * @param {Player} player Player object.\n * @param {Object} options Plugin options object.\n * @function initPlugin\n */\n\nvar initPlugin = function initPlugin(player, options) {\n  var originalPluginFn = player.qualityLevels;\n  var qualityLevelList = new QualityLevelList();\n\n  var disposeHandler = function disposeHandler() {\n    qualityLevelList.dispose();\n    player.qualityLevels = originalPluginFn;\n    player.off('dispose', disposeHandler);\n  };\n\n  player.on('dispose', disposeHandler);\n\n  player.qualityLevels = function () {\n    return qualityLevelList;\n  };\n\n  player.qualityLevels.VERSION = version;\n  return qualityLevelList;\n};\n/**\n * A video.js plugin.\n *\n * In the plugin function, the value of `this` is a video.js `Player`\n * instance. You cannot rely on the player being in a \"ready\" state here,\n * depending on how the plugin is invoked. This may or may not be important\n * to you; if not, remove the wait for \"ready\"!\n *\n * @param {Object} options Plugin options object\n * @function qualityLevels\n */\n\n\nvar qualityLevels = function qualityLevels(options) {\n  return initPlugin(this, videojs.mergeOptions({}, options));\n}; // Register the plugin with video.js.\n\n\nregisterPlugin('qualityLevels', qualityLevels); // Include the version number.\n\nqualityLevels.VERSION = version;\nexport default qualityLevels;","import React from \"react\";\nimport videojs from \"video.js\";\nimport \"video.js/dist/video-js.css\";\nimport \"videojs-hls-quality-selector\";\nimport \"videojs-contrib-quality-levels\";\n\n// https://docs.videojs.com/tutorial-react.html\nexport const VideoJS = (props) => {\n  const videoRef = React.useRef(null);\n  const playerRef = React.useRef(null);\n  const { options, onReady, sas, className, videoJson } = props;\n\n  // Add Azure Blob SAS to HLS lists\n  // https://github.com/videojs/http-streaming#vhsxhr\n  videojs.Vhs.xhr.beforeRequest = function (o) {\n    if (sas) {\n      o.uri = o.uri + sas;\n    }\n    return o;\n  };\n\n  React.useEffect(() => {\n    // make sure Video.js player is only initialized once\n    if (!playerRef.current) {\n      const videoElement = videoRef.current;\n      if (!videoElement) return;\n\n      const player = (playerRef.current = videojs(videoElement, options, () => {\n        console.log(\"player is ready\");\n        onReady && onReady(player);\n      }));\n      player.hlsQualitySelector({ displayCurrentQuality: true });\n      player.playbackRates([0.5, 1, 1.2, 1.3, 1.5, 2]);\n    } else {\n    }\n  }, [options, videoRef]);\n\n  // Dispose the Video.js player when the functional component unmounts\n  React.useEffect(() => {\n    const player = playerRef.current;\n\n    return () => {\n      if (player) {\n        player.dispose();\n        playerRef.current = null;\n      }\n    };\n  }, [playerRef]);\n\n  return (\n    <div className={className}>\n      <div data-vjs-player>\n        <video\n          data-matomo-title={videoJson.title}\n          ref={videoRef}\n          className=\"video-js vjs-big-play-centered\"\n        />\n      </div>\n    </div>\n  );\n};\n\nexport default VideoJS;\n"],"names":["setPrototypeOf","isNativeReflectConstruct","_construct","Parent","args","Class","module","exports","Reflect","construct","__esModule","a","push","apply","instance","Function","bind","prototype","arguments","subClass","superClass","TypeError","Object","create","constructor","value","writable","configurable","sham","Proxy","Boolean","valueOf","call","e","b","toUint8","bytes","Uint8Array","Array","isArray","obj","ArrayBuffer","isView","buffer","byteOffset","byteLength","BigInt","Number","BYTE_TABLE","bytesToNumber","Uint16Array","_temp","_ref","_ref$signed","signed","_ref$le","le","fn","number","total","byte","i","exponent","Math","abs","length","max","numberToBytes","_temp2","_ref2$le","x","byteCount","ceil","toString","countBits","byteIndex","bytesToString","slice","string","String","fromCharCode","decodeURIComponent","escape","stringToBytes","stringIsBytes","unescape","encodeURIComponent","view","charCodeAt","concatTypedArrays","_len","buffers","_key","filter","totalLen","reduce","buf","tempBuffer","offset","forEach","set","bytesMatch","_temp3","_ref3","_ref3$offset","_ref3$mask","mask","every","bByte","regexs","mp4","webm","ogg","video","audio","text","muxerVideo","muxerAudio","muxerText","mediaTypes","upperMediaTypes","translateLegacyCodec","codec","replace","orig","profile","avcLevel","parseCodecs","codecString","codecs","split","result","codecType","trim","name","match","exec","toLowerCase","type","substring","details","mediaType","codecsFromDefault","master","audioGroupId","mediaGroups","AUDIO","audioGroup","audioType","default","playlists","attributes","CODECS","isAudioCodec","test","getMimeForCodec","map","c","container","browserSupportsCodec","muxerSupportsCodec","DEFAULT_AUDIO_CODEC","DEFAULT_VIDEO_CODEC","DESCRIPTORS","normalizePath","path","parseDescriptors","results","tag","size","headerSize","z","_DESCRIPTORS$z","id","parser","subarray","desc","flags","dependsOnEsId","ocrEsId","descriptors","url","len","oti","streamType","bufferSize","maxBitrate","avgBitrate","findBox","paths","complete","p","normalizePaths","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","getvint","removeLength","getLength","valueBytes","getInfinityDataSize","innerid","dataHeader","findEbml","dataStart","dataEnd","concat","NAL_TYPE_ONE","NAL_TYPE_TWO","EMULATION_PREVENTION","discardEmulationPreventionBytes","positions","newLength","newData","sourceIndex","shift","findNal","dataType","types","nalLimit","Infinity","nalStart","nalsFound","nalOffset","nalType","indexOf","CONSTANTS","_isLikely","aac","mp3","docType","mkv","matroska","mov","fmp4","moof","moov","ac3","ts","flac","avi","riff","wav","findH264Nal","findH265Nal","isLikelyTypes","keys","t","isLikelyFn","isLikely","detectContainerForBytes","isLikelyFmp4MediaSegment","decodeB64ToUint8Array","b64Text","s","decodedString","Buffer","from","array","ID3","getId3Offset","returnSize","getId3Size","MPEGURL_REGEX","DASH_REGEX","simpleTypeFromSourceType","DEFAULT_LOCATION","baseUrl","relativeUrl","nativeURL","protocolLess","removeLocation","newUrl","URL","href","protocol","window","callback","decodeResponseBody","err","response","responseBody","statusCode","cause","TextDecoder","charset","contentTypeHeader","contentType","_contentType$split","getCharset","headers","decode","_extends","isFunction","createXHR","httpHandler","initParams","uri","options","params","_createXHR","Error","called","body","getBody","undefined","xhr","responseText","responseType","responseXML","firefoxBugTakenEffect","documentElement","nodeName","getXml","isJson","JSON","parse","errorFunc","evt","clearTimeout","timeoutTimer","failureResponse","loadFunc","aborted","status","useXDR","method","rawRequest","getAllResponseHeaders","row","index","key","parseHeaders","cors","XDomainRequest","XMLHttpRequest","sync","json","stringify","onreadystatechange","readyState","setTimeout","onload","onerror","onprogress","onabort","ontimeout","open","username","password","withCredentials","timeout","abort","code","setRequestHeader","hasOwnProperty","isEmpty","beforeSend","send","iterator","forEachArray","toUpperCase","freeze","object","oc","MIME_TYPE","HTML","isHTML","XML_APPLICATION","XML_TEXT","XML_XHTML_APPLICATION","XML_SVG_IMAGE","NAMESPACE","SVG","XML","XMLNS","conventions","dom","entities","sax","DOMImplementation","ParseError","XMLReader","DOMParser","this","locator","DOMHandler","cdata","position","node","lineNumber","columnNumber","_locator","l","systemId","_toString","chars","start","substr","java","lang","appendElement","hander","currentElement","appendChild","doc","parseFromString","source","mimeType","domBuilder","errorHandler","defaultNSMap","xmlns","entityMap","HTML_ENTITIES","XML_ENTITIES","setDocumentLocator","errorImpl","isCallback","build","msg","buildErrorHandler","xml","error","startDocument","createDocument","documentURI","startElement","namespaceURI","localName","qName","attrs","el","createElementNS","getURI","getValue","attr","getQName","createAttributeNS","getLocator","nodeValue","setAttributeNode","endElement","current","tagName","parentNode","startPrefixMapping","prefix","endPrefixMapping","processingInstruction","target","ins","createProcessingInstruction","ignorableWhitespace","ch","characters","charNode","createCDATASection","createTextNode","skippedEntity","endDocument","normalize","comment","comm","createComment","startCDATA","endCDATA","startDTD","publicId","impl","implementation","createDocumentType","dt","doctype","warning","console","warn","_error","fatalError","XMLSerializer","notEmptyString","input","orderedSetReducer","element","toOrderedSet","list","splitOnASCIIWhitespace","copy","src","dest","Super","pt","NodeType","ELEMENT_NODE","ATTRIBUTE_NODE","TEXT_NODE","CDATA_SECTION_NODE","ENTITY_REFERENCE_NODE","ENTITY_NODE","PROCESSING_INSTRUCTION_NODE","COMMENT_NODE","DOCUMENT_NODE","DOCUMENT_TYPE_NODE","DOCUMENT_FRAGMENT_NODE","NOTATION_NODE","ExceptionCode","ExceptionMessage","HIERARCHY_REQUEST_ERR","INDEX_SIZE_ERR","DOMSTRING_SIZE_ERR","NOT_FOUND_ERR","WRONG_DOCUMENT_ERR","INVALID_CHARACTER_ERR","NO_DATA_ALLOWED_ERR","NO_MODIFICATION_ALLOWED_ERR","INUSE_ATTRIBUTE_ERR","NOT_SUPPORTED_ERR","INVALID_STATE_ERR","SYNTAX_ERR","INVALID_MODIFICATION_ERR","NAMESPACE_ERR","INVALID_ACCESS_ERR","DOMException","message","captureStackTrace","NodeList","LiveNodeList","refresh","_node","_refresh","_updateLiveList","inc","_inc","ownerDocument","ls","__set__","NamedNodeMap","_findNodeIndex","_addNamedNode","newAttr","oldAttr","ownerElement","_onRemoveAttribute","_nsMap","_onAddAttribute","_removeNamedNode","lastIndex","Node","_xmlEncoder","_visitNode","firstChild","nextSibling","Document","remove","_onUpdateChild","newChild","cs","childNodes","child","_removeChild","previous","previousSibling","next","lastChild","_insertBefore","nextChild","cp","removeChild","nodeType","newFirst","newLast","pre","Element","Attr","CharacterData","Text","Comment","CDATASection","DocumentType","Notation","Entity","EntityReference","DocumentFragment","ProcessingInstruction","nodeSerializeToString","isHtml","nodeFilter","refNode","lookupPrefix","visibleNamespaces","namespace","serializeToString","join","needNamespaceDefine","ns","addSerializedAttribute","qualifiedName","prefixedNodeName","defaultNS","ai","item","nsi","pubid","sysid","sub","internalSubset","_importNode","deep","node2","cloneNode","_cloneNode","n","v","attrs2","_ownerElement","getNamedItem","setNamedItem","setNamedItemNS","getNamedItemNS","removeNamedItem","removeNamedItemNS","hasFeature","feature","version","root","insertBefore","refChild","replaceChild","oldChild","hasChildNodes","appendData","isSupported","hasAttributes","lookupNamespaceURI","isDefaultNamespace","importNode","importedNode","getElementById","rtv","getAttribute","getElementsByClassName","classNames","classNamesSet","base","nodeClassNames","matches","nodeClassNamesSet","createElement","createDocumentFragment","createAttribute","specified","createEntityReference","pl","hasAttribute","getAttributeNode","setAttribute","removeAttribute","removeAttributeNode","_appendSingleChild","setAttributeNodeNS","removeAttributeNS","old","getAttributeNodeNS","hasAttributeNS","getAttributeNS","setAttributeNS","getElementsByTagName","getElementsByTagNameNS","substringData","count","insertData","replaceData","deleteData","splitText","newText","newNode","defineProperty","getTextContent","get","$$length","amp","apos","gt","lt","quot","Agrave","Aacute","Acirc","Atilde","Auml","Aring","AElig","Ccedil","Egrave","Eacute","Ecirc","Euml","Igrave","Iacute","Icirc","Iuml","ETH","Ntilde","Ograve","Oacute","Ocirc","Otilde","Ouml","Oslash","Ugrave","Uacute","Ucirc","Uuml","Yacute","THORN","szlig","agrave","aacute","acirc","atilde","auml","aring","aelig","ccedil","egrave","eacute","ecirc","euml","igrave","iacute","icirc","iuml","eth","ntilde","ograve","oacute","ocirc","otilde","ouml","oslash","ugrave","uacute","ucirc","uuml","yacute","thorn","yuml","nbsp","iexcl","cent","pound","curren","yen","brvbar","sect","uml","ordf","laquo","not","shy","reg","macr","deg","plusmn","sup2","sup3","acute","micro","para","middot","cedil","sup1","ordm","raquo","frac14","frac12","frac34","iquest","times","divide","forall","part","exist","empty","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","prop","infin","ang","and","or","cap","cup","there4","sim","cong","asymp","ne","equiv","ge","sup","nsub","sube","supe","oplus","otimes","perp","sdot","Alpha","Beta","Gamma","Delta","Epsilon","Zeta","Eta","Theta","Iota","Kappa","Lambda","Mu","Nu","Xi","Omicron","Pi","Rho","Sigma","Tau","Upsilon","Phi","Chi","Psi","Omega","alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu","nu","xi","omicron","pi","rho","sigmaf","sigma","tau","upsilon","phi","chi","psi","omega","thetasym","upsih","piv","OElig","oelig","Scaron","scaron","Yuml","fnof","circ","tilde","ensp","emsp","thinsp","zwnj","zwj","lrm","rlm","ndash","mdash","lsquo","rsquo","sbquo","ldquo","rdquo","bdquo","dagger","Dagger","bull","hellip","permil","prime","Prime","lsaquo","rsaquo","oline","euro","trade","larr","uarr","rarr","darr","harr","crarr","lceil","rceil","lfloor","rfloor","loz","spades","clubs","hearts","diams","nameStartChar","nameChar","RegExp","tagNamePattern","copyLocator","f","parseElementStartPart","currentNSMap","entityReplacer","addAttribute","qname","startIndex","attributeNames","addValue","attrName","charAt","setTagName","closed","localNSMap","nsp","nsPrefix","_copy","parseHtmlSpecialContent","elStartEnd","elEndStart","fixSelfClosed","closeMap","pos","lastIndexOf","parseDCC","matchs","lastMatch","endDTD","parseInstruction","ElementAttributes","defaultNSMapCopy","fixedFromCharCode","surrogate1","surrogate2","k","parseInt","appendText","xt","m","lineEnd","linePattern","lineStart","parseStack","tagStart","config","pop","endMatch","locator2","_parse","getLocalName","doccy","topLevel","g","minDoc","document","win","self","alert","confirm","prompt","keyCode","searchInput","hasKeyCode","which","charCode","names","foundNamedKey","search","codes","aliases","isEventKey","event","nameOrCode","title","alias","Stream","listeners","_proto","on","listener","off","splice","trigger","callbacks","_length","_i","dispose","pipe","destination","LineStream","_Stream","_this","nextNewline","TAB","parseByterange","byterangeString","parseAttributes","ParseStream","customParsers","tagMappers","line","_this2","acc","mapper","mappedLine","newLine","tagType","duration","parseFloat","playlistType","allowed","URI","BYTERANGE","byterange","RESOLUTION","resolution","width","height","BANDWIDTH","dateTimeString","dateTimeObject","Date","IV","Uint32Array","PRECISE","subkey","addParser","_this3","expression","customType","dataParser","segment","addTagMapper","_ref2","camelCaseKeys","str","setHoldBack","manifest","serverControl","targetDuration","partTargetDuration","hb","phb","minTargetDuration","minPartDuration","Parser","lineStream","parseStream","currentMap","uris","currentUri","hasParts","noop","defaultMediaGroups","currentTimeline","allowCache","discontinuityStarts","segments","lastByterangeEnd","lastPartByterangeEnd","parts","preloadHints","timeline","preloadSegment","entry","mediaGroup","rendition","endlist","endList","inf","mediaSequence","discontinuitySequence","METHOD","KEYFORMAT","contentProtection","KEYID","schemeIdUri","keyId","pssh","iv","isFinite","playlist","media","TYPE","NAME","mediaGroupType","DEFAULT","autoselect","AUTOSELECT","LANGUAGE","language","instreamId","CHARACTERISTICS","characteristics","FORCED","forced","discontinuity","targetduration","isNaN","timeOffset","precise","cueOut","cueOutCont","cueIn","skip","warnOnMissingAttributes_","segmentIndex","partIndex","renditionReports","r","canBlockReload","canSkipDateranges","hint","isPart","otherHint","report","required","partInf","partTarget","custom","identifier","missing","chunk","isObject","merge","objects","flatten","lists","y","errors","urlTypeToSegment","_ref$baseUrl","_ref$source","_ref$range","range","_ref$indexRange","indexRange","resolvedUri","ranges","startRange","endRange","parseEndNumber","endNumber","segmentRange","static","_attributes$timescale","timescale","sourceDuration","periodDuration","segmentDuration","dynamic","NOW","clientOffset","availabilityStartTime","_attributes$timescale2","_attributes$start","_attributes$minimumUp","minimumUpdatePeriod","_attributes$timeShift","timeShiftBufferDepth","now","periodStartWC","segmentCount","availableStart","floor","availableEnd","min","parseByDuration","_attributes$timescale4","_segmentRange$type","_attributes$timescale3","periodIndex","_attributes$startNumb","startNumber","time","toSegments","sectionDuration","segmentsFromBase","_attributes$initializ","initialization","_attributes$indexRang","initSegment","sourceURL","segmentTimeInfo","addSidxSegmentsToPlaylist","sidx","sidxByteRange","sidxEnd","mediaReferences","references","referenceType","firstOffset","reference","referencedSize","subsegmentDuration","generateSidxKey","mergeDiscontiguousPlaylists","o","_acc$name$segments","addSidxSegmentsToPlaylist$1","sidxMapping","sidxKey","sidxMatch","addSidxSegmentsToPlaylists","formatVideoPlaylist","_attributes2","SUBTITLES","bandwidth","videoOnly","_ref4","audioOnly","_ref5","vttOnly","_ref6","toM3u8","dashPlaylists","locations","_mediaGroups","_dashPlaylists$0$attr","suggestedPresentationDelay","videoPlaylists","audioPlaylists","vttPlaylists","captions","captionServices","VIDEO","isAudioOnly","mainPlaylist","formattedPlaylists","role","label","roleLabel","formatted","_attributes","formatAudioPlaylist","organizeAudioPlaylists","subs","_m3u8Attributes","m3u8Attributes","formatVttPlaylist","organizeVttPlaylists","cc","svcObj","svc","service","channel","aspectRatio","easyReader","getLiveRValue","parseByTimeline","segmentTimeline","_attributes$minimumUp2","_attributes$media","sIndex","S","d","repeat","segmentTime","nextS","identifierPattern","constructTemplateUrl","values","format","identifierReplacement","segmentsFromTemplate","templateValues","RepresentationID","Bandwidth","mapSegment","parseTemplateInfo","Time","presentationTimeOffset","presentationTime","periodStart","segmentsFromList","_attributes$segmentUr","segmentUrls","segmentUrlMap","segmentUrlObject","segmentUrl","mediaRange","SegmentURLToSegmentObject","generateSegments","segmentAttributes","segmentsFn","segmentInfo","template","segmentsInfo","_segmentAttributes","_segmentAttributes$ti","findChildren","getContent","textContent","parseDuration","_match$slice","year","month","day","hour","minute","second","parsers","mediaPresentationDuration","parsedValue","parseFn","keySystemsMap","buildBaseUrls","referenceUrls","baseUrlElements","baseUrlElement","getSegmentInformation","adaptationSet","segmentTemplate","segmentList","segmentBase","segmentTimelineParentNode","segmentInitializationParentNode","segmentInitialization","toRepresentations","periodAttributes","periodBaseUrls","periodSegmentInfo","adaptationSetAttributes","adaptationSetBaseUrls","roleAttributes","accessibility","_value$split","_value$split2","_value$split2$","opts","opt","_opt$split","val","labelVal","keySystem","psshNode","psshBuffer","representations","adaptationSetSegmentInfo","representation","repBaseUrlElements","repBaseUrls","representationSegmentInfo","inheritBaseUrls","toAdaptationSets","mpdAttributes","mpdBaseUrls","period","parsedPeriodId","adaptationSets","stringToMpdXml","manifestString","mpd","parsedManifestInfo","_options","_options$manifestUri","manifestUri","_options$NOW","_options$clientOffset","periodNodes","periods","priorPeriod","priorPeriodAttributes","mpdType","getPeriodStart","representationInfo","inheritAttributes","parseUTCTiming","UTCTimingNode","parseUTCTimingScheme","MAX_UINT32","pow","DataView","referenceId","getUint32","earliestPresentationTime","referenceCount","getUint16","startsWithSap","sapType","sapDeltaTime","secondsToVideoTs","secondsToAudioTs","videoTsToSeconds","audioTsToSeconds","audioTsToVideoTs","videoTsToAudioTs","metadataTsToSeconds","ONE_SECOND_IN_TS","seconds","sampleRate","timestamp","timelineStartPts","keepOriginalTimestamps","reviver","URL_REGEX","FIRST_SEGMENT_REGEX","SLASH_DOT_REGEX","SLASH_DOT_DOT_REGEX","URLToolkit","buildAbsoluteURL","baseURL","relativeURL","alwaysNormalize","basePartsForNormalise","parseURL","buildURLFromParts","relativeParts","scheme","baseParts","netLoc","pathParts","builtParts","query","fragment","baseURLPath","newPath","reverse","vttjs","WebVTT","VTTCue","VTTRegion","cueShim","regionShim","nativeVTTCue","nativeVTTRegion","shim","restore","_objCreate","F","ParsingError","errorData","parseTimeStamp","computeSeconds","h","Settings","parseOptions","keyValueDelim","groupDelim","groups","kv","parseCue","cue","regionList","oInput","consumeTimeStamp","Errors","BadTimeStamp","skipWhitespace","startTime","endTime","settings","region","alt","vals","vals0","integer","percent","vertical","lineAlign","snapToLines","align","left","center","middle","right","positionAlign","consumeCueSettings","BadSignature","dflt","defaultKey","has","TEXTAREA_ELEMENT","TAG_NAME","u","ruby","rt","DEFAULT_COLOR_CLASS","white","lime","cyan","red","yellow","magenta","blue","black","TAG_ANNOTATION","NEEDS_PARENT","parseContent","nextToken","shouldAdd","annotation","rootDiv","tagStack","innerHTML","classes","cl","bgColor","colorName","propName","propValue","style","className","strongRTLRanges","isStrongRTLChar","currentRange","determineBidi","cueDiv","nodeStack","pushNodes","nextTextNode","innerText","StyleBox","CueStyleBox","styleOptions","styles","color","backgroundColor","top","bottom","display","writingMode","unicodeBidi","applyStyles","div","direction","textAlign","font","whiteSpace","textPos","formatStyle","move","box","BoxPosition","lh","offsetHeight","offsetWidth","offsetTop","rects","getClientRects","getBoundingClientRect","lineHeight","moveBoxToLinePosition","styleBox","containerBox","boxPositions","boxPosition","linePos","track","textTrackList","mediaElement","trackList","mode","computeLinePos","axis","step","round","maxPosition","initialAxis","calculatedPercentage","bestPosition","specifiedPosition","percentage","overlapsOppositeAxis","within","overlapsAny","intersectPercentage","findBestPosition","toCSSCompatValues","unit","toMove","overlaps","b2","boxes","getSimpleBoxPosition","StringDecoder","convertCueToDOMTree","cuetext","processCues","cues","overlay","paddedOverlay","margin","hasBeenReset","displayState","shouldCompute","fontSize","decoder","state","reportOrThrowError","onparsingerror","collectNextLine","parseHeader","ontimestampmap","parseTimestampMap","xy","anchor","lines","regionAnchorX","regionAnchorY","viewportAnchorX","viewportAnchorY","scroll","onregion","parseRegion","stream","alreadyCollectedLine","hasSubstring","oncue","flush","onflush","directionSetting","alignSetting","findAlignSetting","_id","_pauseOnExit","_startTime","_endTime","_text","_region","_vertical","_snapToLines","_line","_lineAlign","_position","_positionAlign","_size","_align","defineProperties","enumerable","setting","findDirectionSetting","SyntaxError","getCueAsHTML","scrollSetting","isValidPercentValue","_width","_lines","_regionAnchorX","_regionAnchorY","_viewportAnchorX","_viewportAnchorY","_scroll","findScrollSetting","props","videoJson","withDoc","cdnUrl","useLocation","hostname","cdn","playerRef","React","videoJsOptions","autoplay","controls","playbackRates","responsive","fluid","sources","slug","poster","onReady","player","log","series","download","rel","_typeof","Symbol","classCallCheck","AwaitValue","AsyncGenerator","gen","front","back","resume","arg","Promise","resolve","then","settle","done","reject","_invoke","request","return","asyncIterator","throw","Constructor","inherits","__proto__","possibleConstructorReturn","ReferenceError","VideoJsButtonClass","VideoJsMenuClass","VideoJsComponent","Dom","ConcreteButton","_VideoJsButtonClass","localize","createItems","createMenu","menu","player_","menuButton","hideThreshold_","options_","titleEl","createEl","tabIndex","titleComponent","addItem","items","ConcreteMenuItem","_VideoJsMenuItemClass","qualityButton","plugin","selectable","selected","handleClick","setQuality","defaults","registerPlugin","HlsQualitySelectorPlugin","qualityLevels","getHls","createQualityButton","bindPlayerEvents","tech","IWillNotUseThisInPlugins","hls","onAddQualityLevel","_qualityButton","placementIndex","controlBar","children","concreteButtonInstance","addChild","componentClass","addClass","displayCurrentQuality","setButtonInnerText","icon","vjsIconClass","menuButton_","$","removeClass","getQualityMenuItem","levels","levels_","levelItems","_loop","_existingItem","levelItem","sort","update","qualityList","_currentQuality","quality","enabled","unpressButton","getCurrentQuality","hlsQualitySelector","ready","onPlayerReady","VERSION","_assertThisInitialized","QualityLevel","level","bitrate","enabled_","enable","QualityLevelList","_videojs$EventTarget","selectedIndex_","addQualityLevel","qualityLevel","getQualityLevelById","removeQualityLevel","removed","allowedEvents_","change","addqualitylevel","removequalitylevel","originalPluginFn","qualityLevelList","disposeHandler","videoRef","sas","videojs","videoElement","ref"],"sourceRoot":""}