{"version":3,"file":"1f383bb4190fe88beee5c43b1dc1aa69f6931f4a-5cc7854121f5ef999758.js","mappings":"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","sources":["webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/byte-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/codecs.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/mp4-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/opus-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/ebml-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/nal-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/containers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/id3-helpers.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/media-types.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/resolve-url.js","webpack://waxcarvers-fe/./node_modules/@videojs/xhr/lib/http-handler.js","webpack://waxcarvers-fe/./node_modules/@videojs/xhr/lib/index.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/conventions.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/dom-parser.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/dom.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/entities.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/index.js","webpack://waxcarvers-fe/./node_modules/@xmldom/xmldom/lib/sax.js","webpack://waxcarvers-fe/./node_modules/global/document.js","webpack://waxcarvers-fe/./node_modules/global/window.js","webpack://waxcarvers-fe/./node_modules/is-function/index.js","webpack://waxcarvers-fe/./node_modules/keycode/index.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/stream.js","webpack://waxcarvers-fe/./node_modules/m3u8-parser/dist/m3u8-parser.es.js","webpack://waxcarvers-fe/./node_modules/mpd-parser/dist/mpd-parser.es.js","webpack://waxcarvers-fe/./node_modules/@videojs/vhs-utils/es/media-groups.js","webpack://waxcarvers-fe/./node_modules/mux.js/lib/tools/parse-sidx.js","webpack://waxcarvers-fe/./node_modules/mux.js/lib/utils/clock.js","webpack://waxcarvers-fe/./node_modules/mux.js/lib/utils/numbers.js","webpack://waxcarvers-fe/./node_modules/safe-json-parse/tuple.js","webpack://waxcarvers-fe/./node_modules/url-toolkit/src/url-toolkit.js","webpack://waxcarvers-fe/./node_modules/videojs-vtt.js/lib/browser-index.js","webpack://waxcarvers-fe/./node_modules/videojs-vtt.js/lib/vtt.js","webpack://waxcarvers-fe/./node_modules/videojs-vtt.js/lib/vttcue.js","webpack://waxcarvers-fe/./node_modules/videojs-vtt.js/lib/vttregion.js","webpack://waxcarvers-fe/./node_modules/@babel/runtime/helpers/construct.js","webpack://waxcarvers-fe/./node_modules/@babel/runtime/helpers/inherits.js","webpack://waxcarvers-fe/./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js"],"sourcesContent":["import window from 'global/window'; // const log2 = Math.log2 ? Math.log2 : (x) => (Math.log(x) / Math.log(2));\n\nvar repeat = function repeat(str, len) {\n  var acc = '';\n\n  while (len--) {\n    acc += str;\n  }\n\n  return acc;\n}; // count the number of bits it would take to represent a number\n// we used to do this with log2 but BigInt does not support builtin math\n// Math.ceil(log2(x));\n\n\nexport var countBits = function countBits(x) {\n  return x.toString(2).length;\n}; // count the number of whole bytes it would take to represent a number\n\nexport var countBytes = function countBytes(x) {\n  return Math.ceil(countBits(x) / 8);\n};\nexport var padStart = function padStart(b, len, str) {\n  if (str === void 0) {\n    str = ' ';\n  }\n\n  return (repeat(str, len) + b.toString()).slice(-len);\n};\nexport var isArrayBufferView = function isArrayBufferView(obj) {\n  if (ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(obj);\n  }\n\n  return obj && obj.buffer instanceof ArrayBuffer;\n};\nexport var isTypedArray = function isTypedArray(obj) {\n  return isArrayBufferView(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 (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 (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 () {\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 (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 (namespaceURI, localName, qName) {\n    var current = this.currentElement;\n    var tagName = current.tagName;\n    this.currentElement = current.parentNode;\n  },\n  startPrefixMapping: function (prefix, uri) {},\n  endPrefixMapping: function (prefix) {},\n  processingInstruction: function (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 (ch, start, length) {},\n  characters: function (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 (name) {},\n  endDocument: function () {\n    this.doc.normalize();\n  },\n  setDocumentLocator: function (locator) {\n    if (this.locator = locator) {\n      // && !('lineNumber' in locator)){\n      locator.lineNumber = 0;\n    }\n  },\n  //LexicalHandler\n  comment: function (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 () {\n    //used in characters() methods\n    this.cdata = true;\n  },\n  endCDATA: function () {\n    this.cdata = false;\n  },\n  startDTD: function (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 (error) {\n    console.warn('[xmldom warning]\\t' + error, _locator(this.locator));\n  },\n  error: function (error) {\n    console.error('[xmldom error]\\t' + error, _locator(this.locator));\n  },\n  fatalError: function (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 (index) {\n    return this[index] || null;\n  },\n  toString: function (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 (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 (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 (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 (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 (namespaceURI, localName) {\n    var attr = this.getNamedItemNS(namespaceURI, localName);\n\n    _removeNamedNode(this._ownerElement, this, attr);\n\n    return attr;\n  },\n  getNamedItemNS: function (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 (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 (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 (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 (newChild, refChild) {\n    //raises \n    return _insertBefore(this, newChild, refChild);\n  },\n  replaceChild: function (newChild, oldChild) {\n    //raises \n    this.insertBefore(newChild, oldChild);\n\n    if (oldChild) {\n      this.removeChild(oldChild);\n    }\n  },\n  removeChild: function (oldChild) {\n    return _removeChild(this, oldChild);\n  },\n  appendChild: function (newChild) {\n    return this.insertBefore(newChild, null);\n  },\n  hasChildNodes: function () {\n    return this.firstChild != null;\n  },\n  cloneNode: function (deep) {\n    return cloneNode(this.ownerDocument || this, this, deep);\n  },\n  // Modified in DOM Level 2:\n  normalize: function () {\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 (feature, version) {\n    return this.ownerDocument.implementation.hasFeature(feature, version);\n  },\n  // Introduced in DOM Level 2:\n  hasAttributes: function () {\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 (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 (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 (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 (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 (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 (importedNode, deep) {\n    return importNode(this, importedNode, deep);\n  },\n  // Introduced in DOM Level 2:\n  getElementById: function (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 (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 (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 () {\n    var node = new DocumentFragment();\n    node.ownerDocument = this;\n    node.childNodes = new NodeList();\n    return node;\n  },\n  createTextNode: function (data) {\n    var node = new Text();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createComment: function (data) {\n    var node = new Comment();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createCDATASection: function (data) {\n    var node = new CDATASection();\n    node.ownerDocument = this;\n    node.appendData(data);\n    return node;\n  },\n  createProcessingInstruction: function (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 (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 (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 (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 (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 (name) {\n    return this.getAttributeNode(name) != null;\n  },\n  getAttribute: function (name) {\n    var attr = this.getAttributeNode(name);\n    return attr && attr.value || '';\n  },\n  getAttributeNode: function (name) {\n    return this.attributes.getNamedItem(name);\n  },\n  setAttribute: function (name, value) {\n    var attr = this.ownerDocument.createAttribute(name);\n    attr.value = attr.nodeValue = \"\" + value;\n    this.setAttributeNode(attr);\n  },\n  removeAttribute: function (name) {\n    var attr = this.getAttributeNode(name);\n    attr && this.removeAttributeNode(attr);\n  },\n  //four real opeartion method\n  appendChild: function (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 (newAttr) {\n    return this.attributes.setNamedItem(newAttr);\n  },\n  setAttributeNodeNS: function (newAttr) {\n    return this.attributes.setNamedItemNS(newAttr);\n  },\n  removeAttributeNode: function (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 (namespaceURI, localName) {\n    var old = this.getAttributeNodeNS(namespaceURI, localName);\n    old && this.removeAttributeNode(old);\n  },\n  hasAttributeNS: function (namespaceURI, localName) {\n    return this.getAttributeNodeNS(namespaceURI, localName) != null;\n  },\n  getAttributeNS: function (namespaceURI, localName) {\n    var attr = this.getAttributeNodeNS(namespaceURI, localName);\n    return attr && attr.value || '';\n  },\n  setAttributeNS: function (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 (namespaceURI, localName) {\n    return this.attributes.getNamedItemNS(namespaceURI, localName);\n  },\n  getElementsByTagName: function (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 (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 (offset, count) {\n    return this.data.substring(offset, offset + count);\n  },\n  appendData: function (text) {\n    text = this.data + text;\n    this.nodeValue = this.data = text;\n    this.length = text.length;\n  },\n  insertData: function (offset, text) {\n    this.replaceData(offset, 0, text);\n  },\n  appendChild: function (newChild) {\n    throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);\n  },\n  deleteData: function (offset, count) {\n    this.replaceData(offset, count, \"\");\n  },\n  replaceData: function (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 (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 () {\n        _updateLiveList(this);\n\n        return this.$$length;\n      }\n    });\n    Object.defineProperty(Node.prototype, 'textContent', {\n      get: function () {\n        return getTextContent(this);\n      },\n      set: function (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 (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: \"\\u00a0\",\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 (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    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 '\\u0080':\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 (tagName) {\n    if (!tagNamePattern.test(tagName)) {\n      throw new Error('invalid tagName:' + tagName);\n    }\n\n    this.tagName = tagName;\n  },\n  addValue: function (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 (i) {\n    return this[i].localName;\n  },\n  getLocator: function (i) {\n    return this[i].locator;\n  },\n  getQName: function (i) {\n    return this[i].qName;\n  },\n  getURI: function (i) {\n    return this[i].uri;\n  },\n  getValue: function (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++) codes[String.fromCharCode(i)] = i - 32; // numbers\n\n\nfor (var i = 48; i < 58; i++) codes[i - 48] = i; // function keys\n\n\nfor (i = 1; i < 13; i++) codes['f' + i] = i + 111; // numpad keys\n\n\nfor (i = 0; i < 10; i++) codes['numpad ' + i] = i + 96;\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) names[codes[i]] = i; // 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.1 @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              }\n\n              if (entry.attributes.KEYFORMAT === 'com.microsoft.playready') {\n                this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.\n\n                this.manifest.contentProtection['com.microsoft.playready'] = {\n                  uri: entry.attributes.URI\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.21.1 @license Apache-2.0 */\nimport resolveUrl from '@videojs/vhs-utils/es/resolve-url';\nimport window from 'global/window';\nimport { forEachMediaGroup } from '@videojs/vhs-utils/es/media-groups';\nimport decodeB64ToUint8Array from '@videojs/vhs-utils/es/decode-b64-to-uint8-array';\nimport { DOMParser } from '@xmldom/xmldom';\nvar version = \"0.21.1\";\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/**\n * Returns the first index that satisfies the matching function, or -1 if not found.\n *\n * Only necessary because of IE11 support.\n *\n * @param {Array} list - the list to search through\n * @param {Function} matchingFunction - the matching function\n *\n * @return {number} the matching index or -1 if not found\n */\n\n\nvar findIndex = function findIndex(list, matchingFunction) {\n  for (var i = 0; i < list.length; i++) {\n    if (matchingFunction(list[i])) {\n      return i;\n    }\n  }\n\n  return -1;\n};\n/**\n * Returns a union of the included lists provided each element can be identified by a key.\n *\n * @param {Array} list - list of lists to get the union of\n * @param {Function} keyFunction - the function to use as a key for each element\n *\n * @return {Array} the union of the arrays\n */\n\n\nvar union = function union(lists, keyFunction) {\n  return values(lists.reduce(function (acc, list) {\n    list.forEach(function (el) {\n      acc[keyFunction(el)] = el;\n    });\n    return acc;\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('-'); // default to parsing this as a BigInt if possible\n\n    var startRange = window.BigInt ? window.BigInt(ranges[0]) : parseInt(ranges[0], 10);\n    var endRange = window.BigInt ? window.BigInt(ranges[1]) : parseInt(ranges[1], 10); // convert back to a number if less than MAX_SAFE_INTEGER\n\n    if (startRange < Number.MAX_SAFE_INTEGER && typeof startRange === 'bigint') {\n      startRange = Number(startRange);\n    }\n\n    if (endRange < Number.MAX_SAFE_INTEGER && typeof endRange === 'bigint') {\n      endRange = Number(endRange);\n    }\n\n    var length;\n\n    if (typeof endRange === 'bigint' || typeof startRange === 'bigint') {\n      length = window.BigInt(endRange) - window.BigInt(startRange) + window.BigInt(1);\n    } else {\n      length = endRange - startRange + 1;\n    }\n\n    if (typeof length === 'bigint' && length < Number.MAX_SAFE_INTEGER) {\n      length = Number(length);\n    } // byterange should be inclusive according to\n    // RFC 2616, Clause 14.35.1\n\n\n    segment.byterange = {\n      length: length,\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;\n\n  if (typeof byterange.offset === 'bigint' || typeof byterange.length === 'bigint') {\n    endRange = window.BigInt(byterange.offset) + window.BigInt(byterange.length) - window.BigInt(1);\n  } else {\n    endRange = byterange.offset + byterange.length - 1;\n  }\n\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$periodSta = attributes.periodStart,\n        periodStart = _attributes$periodSta === void 0 ? 0 : _attributes$periodSta,\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); // clientOffset is passed in at the top level of mpd-parser and is an offset calculated\n    // after retrieving UTC server time.\n\n    var now = (NOW + clientOffset) / 1000; // WC stands for Wall Clock.\n    // Convert the period start time to EPOCH.\n\n    var periodStartWC = availabilityStartTime + periodStart; // Period end in EPOCH is manifest's retrieval time + time until next update.\n\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) {\n    var duration = attributes.duration,\n        _attributes$timescale3 = attributes.timescale,\n        timescale = _attributes$timescale3 === void 0 ? 1 : _attributes$timescale3,\n        periodStart = attributes.periodStart,\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: periodStart,\n      time: number * 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      periodStart = attributes.periodStart,\n      presentationTime = attributes.presentationTime,\n      _attributes$number = attributes.number,\n      number = _attributes$number === void 0 ? 0 : _attributes$number,\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 = periodStart;\n  } // If presentation time is provided, these segments are being generated by SIDX\n  // references, and should use the time provided. For the general case of SegmentBase,\n  // there should only be one segment in the period, so its presentation time is the same\n  // as its period start.\n\n\n  segment.presentationTime = presentationTime || periodStart;\n  segment.number = number;\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$1 = 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';\n  var periodStart = playlist.sidx.timeline;\n  var presentationTime = periodStart;\n  var number = playlist.mediaSequence || 0; // firstOffset is the offset from the end of the sidx box\n\n  var startIndex; // eslint-disable-next-line\n\n  if (typeof sidx.firstOffset === 'bigint') {\n    startIndex = window.BigInt(sidxEnd) + sidx.firstOffset;\n  } else {\n    startIndex = sidxEnd + sidx.firstOffset;\n  }\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 = void 0; // eslint-disable-next-line\n\n    if (typeof startIndex === 'bigint') {\n      endIndex = startIndex + window.BigInt(size) - window.BigInt(1);\n    } else {\n      endIndex = startIndex + size - 1;\n    }\n\n    var indexRange = startIndex + \"-\" + endIndex;\n    var attributes = {\n      baseUrl: baseUrl,\n      timescale: timescale,\n      timeline: timeline,\n      periodStart: periodStart,\n      presentationTime: presentationTime,\n      number: number,\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\n    if (typeof startIndex === 'bigint') {\n      startIndex += window.BigInt(size);\n    } else {\n      startIndex += size;\n    }\n\n    presentationTime += duration / timescale;\n    number++;\n  }\n\n  playlist.segments = segments;\n  return playlist;\n};\n\nvar SUPPORTED_MEDIA_TYPES = ['AUDIO', 'SUBTITLES']; // allow one 60fps frame as leniency (arbitrarily chosen)\n\nvar TIME_FUDGE = 1 / 60;\n/**\n * Given a list of timelineStarts, combines, dedupes, and sorts them.\n *\n * @param {TimelineStart[]} timelineStarts - list of timeline starts\n *\n * @return {TimelineStart[]} the combined and deduped timeline starts\n */\n\nvar getUniqueTimelineStarts = function getUniqueTimelineStarts(timelineStarts) {\n  return union(timelineStarts, function (_ref) {\n    var timeline = _ref.timeline;\n    return timeline;\n  }).sort(function (a, b) {\n    return a.timeline > b.timeline ? 1 : -1;\n  });\n};\n/**\n * Finds the playlist with the matching NAME attribute.\n *\n * @param {Array} playlists - playlists to search through\n * @param {string} name - the NAME attribute to search for\n *\n * @return {Object|null} the matching playlist object, or null\n */\n\n\nvar findPlaylistWithName = function findPlaylistWithName(playlists, name) {\n  for (var i = 0; i < playlists.length; i++) {\n    if (playlists[i].attributes.NAME === name) {\n      return playlists[i];\n    }\n  }\n\n  return null;\n};\n/**\n * Gets a flattened array of media group playlists.\n *\n * @param {Object} manifest - the main manifest object\n *\n * @return {Array} the media group playlists\n */\n\n\nvar getMediaGroupPlaylists = function getMediaGroupPlaylists(manifest) {\n  var mediaGroupPlaylists = [];\n  forEachMediaGroup(manifest, SUPPORTED_MEDIA_TYPES, function (properties, type, group, label) {\n    mediaGroupPlaylists = mediaGroupPlaylists.concat(properties.playlists || []);\n  });\n  return mediaGroupPlaylists;\n};\n/**\n * Updates the playlist's media sequence numbers.\n *\n * @param {Object} config - options object\n * @param {Object} config.playlist - the playlist to update\n * @param {number} config.mediaSequence - the mediaSequence number to start with\n */\n\n\nvar updateMediaSequenceForPlaylist = function updateMediaSequenceForPlaylist(_ref2) {\n  var playlist = _ref2.playlist,\n      mediaSequence = _ref2.mediaSequence;\n  playlist.mediaSequence = mediaSequence;\n  playlist.segments.forEach(function (segment, index) {\n    segment.number = playlist.mediaSequence + index;\n  });\n};\n/**\n * Updates the media and discontinuity sequence numbers of newPlaylists given oldPlaylists\n * and a complete list of timeline starts.\n *\n * If no matching playlist is found, only the discontinuity sequence number of the playlist\n * will be updated.\n *\n * Since early available timelines are not supported, at least one segment must be present.\n *\n * @param {Object} config - options object\n * @param {Object[]} oldPlaylists - the old playlists to use as a reference\n * @param {Object[]} newPlaylists - the new playlists to update\n * @param {Object} timelineStarts - all timelineStarts seen in the stream to this point\n */\n\n\nvar updateSequenceNumbers = function updateSequenceNumbers(_ref3) {\n  var oldPlaylists = _ref3.oldPlaylists,\n      newPlaylists = _ref3.newPlaylists,\n      timelineStarts = _ref3.timelineStarts;\n  newPlaylists.forEach(function (playlist) {\n    playlist.discontinuitySequence = findIndex(timelineStarts, function (_ref4) {\n      var timeline = _ref4.timeline;\n      return timeline === playlist.timeline;\n    }); // Playlists NAMEs come from DASH Representation IDs, which are mandatory\n    // (see ISO_23009-1-2012 5.3.5.2).\n    //\n    // If the same Representation existed in a prior Period, it will retain the same NAME.\n\n    var oldPlaylist = findPlaylistWithName(oldPlaylists, playlist.attributes.NAME);\n\n    if (!oldPlaylist) {\n      // Since this is a new playlist, the media sequence values can start from 0 without\n      // consequence.\n      return;\n    } // TODO better support for live SIDX\n    //\n    // As of this writing, mpd-parser does not support multiperiod SIDX (in live or VOD).\n    // This is evident by a playlist only having a single SIDX reference. In a multiperiod\n    // playlist there would need to be multiple SIDX references. In addition, live SIDX is\n    // not supported when the SIDX properties change on refreshes.\n    //\n    // In the future, if support needs to be added, the merging logic here can be called\n    // after SIDX references are resolved. For now, exit early to prevent exceptions being\n    // thrown due to undefined references.\n\n\n    if (playlist.sidx) {\n      return;\n    } // Since we don't yet support early available timelines, we don't need to support\n    // playlists with no segments.\n\n\n    var firstNewSegment = playlist.segments[0];\n    var oldMatchingSegmentIndex = findIndex(oldPlaylist.segments, function (oldSegment) {\n      return Math.abs(oldSegment.presentationTime - firstNewSegment.presentationTime) < TIME_FUDGE;\n    }); // No matching segment from the old playlist means the entire playlist was refreshed.\n    // In this case the media sequence should account for this update, and the new segments\n    // should be marked as discontinuous from the prior content, since the last prior\n    // timeline was removed.\n\n    if (oldMatchingSegmentIndex === -1) {\n      updateMediaSequenceForPlaylist({\n        playlist: playlist,\n        mediaSequence: oldPlaylist.mediaSequence + oldPlaylist.segments.length\n      });\n      playlist.segments[0].discontinuity = true;\n      playlist.discontinuityStarts.unshift(0); // No matching segment does not necessarily mean there's missing content.\n      //\n      // If the new playlist's timeline is the same as the last seen segment's timeline,\n      // then a discontinuity can be added to identify that there's potentially missing\n      // content. If there's no missing content, the discontinuity should still be rather\n      // harmless. It's possible that if segment durations are accurate enough, that the\n      // existence of a gap can be determined using the presentation times and durations,\n      // but if the segment timing info is off, it may introduce more problems than simply\n      // adding the discontinuity.\n      //\n      // If the new playlist's timeline is different from the last seen segment's timeline,\n      // then a discontinuity can be added to identify that this is the first seen segment\n      // of a new timeline. However, the logic at the start of this function that\n      // determined the disconinuity sequence by timeline index is now off by one (the\n      // discontinuity of the newest timeline hasn't yet fallen off the manifest...since\n      // we added it), so the disconinuity sequence must be decremented.\n      //\n      // A period may also have a duration of zero, so the case of no segments is handled\n      // here even though we don't yet support early available periods.\n\n      if (!oldPlaylist.segments.length && playlist.timeline > oldPlaylist.timeline || oldPlaylist.segments.length && playlist.timeline > oldPlaylist.segments[oldPlaylist.segments.length - 1].timeline) {\n        playlist.discontinuitySequence--;\n      }\n\n      return;\n    } // If the first segment matched with a prior segment on a discontinuity (it's matching\n    // on the first segment of a period), then the discontinuitySequence shouldn't be the\n    // timeline's matching one, but instead should be the one prior, and the first segment\n    // of the new manifest should be marked with a discontinuity.\n    //\n    // The reason for this special case is that discontinuity sequence shows how many\n    // discontinuities have fallen off of the playlist, and discontinuities are marked on\n    // the first segment of a new \"timeline.\" Because of this, while DASH will retain that\n    // Period while the \"timeline\" exists, HLS keeps track of it via the discontinuity\n    // sequence, and that first segment is an indicator, but can be removed before that\n    // timeline is gone.\n\n\n    var oldMatchingSegment = oldPlaylist.segments[oldMatchingSegmentIndex];\n\n    if (oldMatchingSegment.discontinuity && !firstNewSegment.discontinuity) {\n      firstNewSegment.discontinuity = true;\n      playlist.discontinuityStarts.unshift(0);\n      playlist.discontinuitySequence--;\n    }\n\n    updateMediaSequenceForPlaylist({\n      playlist: playlist,\n      mediaSequence: oldPlaylist.segments[oldMatchingSegmentIndex].number\n    });\n  });\n};\n/**\n * Given an old parsed manifest object and a new parsed manifest object, updates the\n * sequence and timing values within the new manifest to ensure that it lines up with the\n * old.\n *\n * @param {Array} oldManifest - the old main manifest object\n * @param {Array} newManifest - the new main manifest object\n *\n * @return {Object} the updated new manifest object\n */\n\n\nvar positionManifestOnTimeline = function positionManifestOnTimeline(_ref5) {\n  var oldManifest = _ref5.oldManifest,\n      newManifest = _ref5.newManifest; // Starting from v4.1.2 of the IOP, section 4.4.3.3 states:\n  //\n  // \"MPD@availabilityStartTime and Period@start shall not be changed over MPD updates.\"\n  //\n  // This was added from https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/160\n  //\n  // Because of this change, and the difficulty of supporting periods with changing start\n  // times, periods with changing start times are not supported. This makes the logic much\n  // simpler, since periods with the same start time can be considerred the same period\n  // across refreshes.\n  //\n  // To give an example as to the difficulty of handling periods where the start time may\n  // change, if a single period manifest is refreshed with another manifest with a single\n  // period, and both the start and end times are increased, then the only way to determine\n  // if it's a new period or an old one that has changed is to look through the segments of\n  // each playlist and determine the presentation time bounds to find a match. In addition,\n  // if the period start changed to exceed the old period end, then there would be no\n  // match, and it would not be possible to determine whether the refreshed period is a new\n  // one or the old one.\n\n  var oldPlaylists = oldManifest.playlists.concat(getMediaGroupPlaylists(oldManifest));\n  var newPlaylists = newManifest.playlists.concat(getMediaGroupPlaylists(newManifest)); // Save all seen timelineStarts to the new manifest. Although this potentially means that\n  // there's a \"memory leak\" in that it will never stop growing, in reality, only a couple\n  // of properties are saved for each seen Period. Even long running live streams won't\n  // generate too many Periods, unless the stream is watched for decades. In the future,\n  // this can be optimized by mapping to discontinuity sequence numbers for each timeline,\n  // but it may not become an issue, and the additional info can be useful for debugging.\n\n  newManifest.timelineStarts = getUniqueTimelineStarts([oldManifest.timelineStarts, newManifest.timelineStarts]);\n  updateSequenceNumbers({\n    oldPlaylists: oldPlaylists,\n    newPlaylists: newPlaylists,\n    timelineStarts: newManifest.timelineStarts\n  });\n  return newManifest;\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 || '');\n\n    if (!acc[name]) {\n      // First Period\n      acc[name] = playlist;\n      acc[name].attributes.timelineStarts = [];\n    } else {\n      // Subsequent Periods\n      if (playlist.segments) {\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);\n      } // 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    }\n\n    acc[name].attributes.timelineStarts.push({\n      // Although they represent the same number, it's important to have both to make it\n      // compatible with HLS potentially having a similar attribute.\n      start: playlist.attributes.periodStart,\n      timeline: playlist.attributes.periodStart\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 = function addSidxSegmentsToPlaylist(playlist, sidxMapping) {\n  var sidxKey = generateSidxKey(playlist.sidx);\n  var sidxMatch = sidxKey && sidxMapping[sidxKey] && sidxMapping[sidxKey].sidx;\n\n  if (sidxMatch) {\n    addSidxSegmentsToPlaylist$1(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(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      mediaSequence = _ref.mediaSequence,\n      discontinuitySequence = _ref.discontinuitySequence,\n      discontinuityStarts = _ref.discontinuityStarts;\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.periodStart,\n    resolvedUri: '',\n    targetDuration: attributes.duration,\n    discontinuitySequence: discontinuitySequence,\n    discontinuityStarts: discontinuityStarts,\n    timelineStarts: attributes.timelineStarts,\n    mediaSequence: mediaSequence,\n    segments: segments\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      mediaSequence = _ref2.mediaSequence,\n      discontinuityStarts = _ref2.discontinuityStarts,\n      discontinuitySequence = _ref2.discontinuitySequence;\n\n  if (typeof segments === 'undefined') {\n    // vtt tracks may use single file in BaseURL\n    segments = [{\n      uri: attributes.baseUrl,\n      timeline: attributes.periodStart,\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.periodStart,\n    resolvedUri: attributes.baseUrl || '',\n    targetDuration: attributes.duration,\n    timelineStarts: attributes.timelineStarts,\n    discontinuityStarts: discontinuityStarts,\n    discontinuitySequence: discontinuitySequence,\n    mediaSequence: mediaSequence,\n    segments: segments\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(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(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      discontinuityStarts = _ref3.discontinuityStarts;\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.periodStart,\n    resolvedUri: '',\n    targetDuration: attributes.duration,\n    discontinuityStarts: discontinuityStarts,\n    timelineStarts: attributes.timelineStarts,\n    segments: segments\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/**\n * Contains start and timeline properties denoting a timeline start. For DASH, these will\n * be the same number.\n *\n * @typedef {Object} TimelineStart\n * @property {number} start - the start time of the timeline\n * @property {number} timeline - the timeline number\n */\n\n/**\n * Adds appropriate media and discontinuity sequence values to the segments and playlists.\n *\n * Throughout mpd-parser, the `number` attribute is used in relation to `startNumber`, a\n * DASH specific attribute used in constructing segment URI's from templates. However, from\n * an HLS perspective, the `number` attribute on a segment would be its `mediaSequence`\n * value, which should start at the original media sequence value (or 0) and increment by 1\n * for each segment thereafter. Since DASH's `startNumber` values are independent per\n * period, it doesn't make sense to use it for `number`. Instead, assume everything starts\n * from a 0 mediaSequence value and increment from there.\n *\n * Note that VHS currently doesn't use the `number` property, but it can be helpful for\n * debugging and making sense of the manifest.\n *\n * For live playlists, to account for values increasing in manifests when periods are\n * removed on refreshes, merging logic should be used to update the numbers to their\n * appropriate values (to ensure they're sequential and increasing).\n *\n * @param {Object[]} playlists - the playlists to update\n * @param {TimelineStart[]} timelineStarts - the timeline starts for the manifest\n */\n\n\nvar addMediaSequenceValues = function addMediaSequenceValues(playlists, timelineStarts) {\n  // increment all segments sequentially\n  playlists.forEach(function (playlist) {\n    playlist.mediaSequence = 0;\n    playlist.discontinuitySequence = findIndex(timelineStarts, function (_ref7) {\n      var timeline = _ref7.timeline;\n      return timeline === playlist.timeline;\n    });\n\n    if (!playlist.segments) {\n      return;\n    }\n\n    playlist.segments.forEach(function (segment, index) {\n      segment.number = index;\n    });\n  });\n};\n/**\n * Given a media group object, flattens all playlists within the media group into a single\n * array.\n *\n * @param {Object} mediaGroupObject - the media group object\n *\n * @return {Object[]}\n *         The media group playlists\n */\n\n\nvar flattenMediaGroupPlaylists = function flattenMediaGroupPlaylists(mediaGroupObject) {\n  if (!mediaGroupObject) {\n    return [];\n  }\n\n  return Object.keys(mediaGroupObject).reduce(function (acc, label) {\n    var labelContents = mediaGroupObject[label];\n    return acc.concat(labelContents.playlists);\n  }, []);\n};\n\nvar toM3u8 = function toM3u8(_ref8) {\n  var _mediaGroups;\n\n  var dashPlaylists = _ref8.dashPlaylists,\n      locations = _ref8.locations,\n      _ref8$sidxMapping = _ref8.sidxMapping,\n      sidxMapping = _ref8$sidxMapping === void 0 ? {} : _ref8$sidxMapping,\n      previousManifest = _ref8.previousManifest;\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 = mergeDiscontiguousPlaylists(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  var organizedAudioGroup = audioPlaylists.length ? organizeAudioPlaylists(audioPlaylists, sidxMapping, isAudioOnly) : null;\n  var organizedVttGroup = vttPlaylists.length ? organizeVttPlaylists(vttPlaylists, sidxMapping) : null;\n  var formattedPlaylists = videoPlaylists.concat(flattenMediaGroupPlaylists(organizedAudioGroup), flattenMediaGroupPlaylists(organizedVttGroup));\n  var playlistTimelineStarts = formattedPlaylists.map(function (_ref9) {\n    var timelineStarts = _ref9.timelineStarts;\n    return timelineStarts;\n  });\n  manifest.timelineStarts = getUniqueTimelineStarts(playlistTimelineStarts);\n  addMediaSequenceValues(formattedPlaylists, manifest.timelineStarts);\n\n  if (organizedAudioGroup) {\n    manifest.mediaGroups.AUDIO.audio = organizedAudioGroup;\n  }\n\n  if (organizedVttGroup) {\n    manifest.mediaGroups.SUBTITLES.subs = organizedVttGroup;\n  }\n\n  if (captions.length) {\n    manifest.mediaGroups['CLOSED-CAPTIONS'].cc = organizeCaptionServices(captions);\n  }\n\n  if (previousManifest) {\n    return positionManifestOnTimeline({\n      oldManifest: previousManifest,\n      newManifest: manifest\n    });\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$periodSta = attributes.periodStart,\n      periodStart = _attributes$periodSta === void 0 ? 0 : _attributes$periodSta,\n      _attributes$minimumUp = attributes.minimumUpdatePeriod,\n      minimumUpdatePeriod = _attributes$minimumUp === void 0 ? 0 : _attributes$minimumUp;\n  var now = (NOW + clientOffset) / 1000;\n  var periodStartWC = availabilityStartTime + periodStart;\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.periodStart;\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.periodStart\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); // Although it could be argued that according to the UUID RFC spec the UUID string (a-f chars) should be generated\n    // as a lowercase string it also mentions it should be treated as case-insensitive on input. Since the key system\n    // UUIDs in the keySystemsMap are hardcoded as lowercase in the codebase there isn't any reason not to do\n    // .toLowerCase() on the input UUID string from the manifest (at least I could not think of one).\n\n    if (attributes.schemeIdUri) {\n      attributes.schemeIdUri = attributes.schemeIdUri.toLowerCase();\n    }\n\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        acc[keySystem].pssh = pssh && decodeB64ToUint8Array(pssh);\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} periodStart\n *        Start time 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 periodAttributes = merge(mpdAttributes, {\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/*\n * Given a DASH manifest string and options, parses the DASH manifest into an object in the\n * form outputed by m3u8-parser and accepted by videojs/http-streaming.\n *\n * For live DASH manifests, if `previousManifest` is provided in options, then the newly\n * parsed DASH manifest will have its media sequence and discontinuity sequence values\n * updated to reflect its position relative to the prior manifest.\n *\n * @param {string} manifestString - the DASH manifest as a string\n * @param {options} [options] - any options\n *\n * @return {Object} the manifest object\n */\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({\n    dashPlaylists: playlists,\n    locations: parsedManifestInfo.locations,\n    sidxMapping: options.sidxMapping,\n    previousManifest: options.previousManifest\n  });\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$1 as addSidxSegmentsToPlaylist, generateSidxKey, inheritAttributes, parse, parseUTCTiming, stringToMpdXml, toM3u8, toPlaylists };","/**\n * Loops through all supported media groups in master and calls the provided\n * callback for each group\n *\n * @param {Object} master\n *        The parsed master manifest object\n * @param {string[]} groups\n *        The media groups to call the callback for\n * @param {Function} callback\n *        Callback to call for each media group\n */\nexport var forEachMediaGroup = function forEachMediaGroup(master, groups, callback) {\n  groups.forEach(function (mediaType) {\n    for (var groupKey in master.mediaGroups[mediaType]) {\n      for (var labelKey in master.mediaGroups[mediaType][groupKey]) {\n        var mediaProperties = master.mediaGroups[mediaType][groupKey][labelKey];\n        callback(mediaProperties, mediaType, groupKey, labelKey);\n      }\n    }\n  });\n};","var getUint64 = require('../utils/numbers.js').getUint64;\n\nvar parseSidx = function (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 = getUint64(data.subarray(i));\n    result.firstOffset = getUint64(data.subarray(i + 8));\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 (seconds) {\n  return seconds * ONE_SECOND_IN_TS;\n};\n\nsecondsToAudioTs = function (seconds, sampleRate) {\n  return seconds * sampleRate;\n};\n\nvideoTsToSeconds = function (timestamp) {\n  return timestamp / ONE_SECOND_IN_TS;\n};\n\naudioTsToSeconds = function (timestamp, sampleRate) {\n  return timestamp / sampleRate;\n};\n\naudioTsToVideoTs = function (timestamp, sampleRate) {\n  return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));\n};\n\nvideoTsToAudioTs = function (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 (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};","var MAX_UINT32 = Math.pow(2, 32);\n\nvar getUint64 = function (uint8) {\n  var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);\n  var value;\n\n  if (dv.getBigUint64) {\n    value = dv.getBigUint64(0);\n\n    if (value < Number.MAX_SAFE_INTEGER) {\n      return Number(value);\n    }\n\n    return value;\n  }\n\n  return dv.getUint32(0) * MAX_UINT32 + dv.getUint32(4);\n};\n\nmodule.exports = {\n  getUint64: getUint64,\n  MAX_UINT32: MAX_UINT32\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+\\-.]+:)?))\\1(?=((?:\\/\\/[^\\/?#]*)?))\\2(?=((?:(?:[^?#\\/]*\\/)*[^;?#\\/]*)?))\\3((?:;[^?#]*)?)(\\?[^#]*)?(#[^]*)?$/;\n  var FIRST_SEGMENT_REGEX = /^(?=([^\\/?#]*))\\1([^]*)$/;\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 (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 (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 (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 (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 (k, v) {\n    if (!this.get(k) && v !== \"\") {\n      this.values[k] = v;\n    }\n  },\n  // Return the value for a key, or a default value.\n  // If 'defaultKey' is passed then 'dflt' is assumed to be an object with\n  // a number of possible default values as properties where 'defaultKey' is\n  // the key of the property that will be chosen; otherwise it's assumed to be\n  // a single value.\n  get: function (k, dflt, defaultKey) {\n    if (defaultKey) {\n      return this.has(k) ? this.values[k] : dflt[defaultKey];\n    }\n\n    return this.has(k) ? this.values[k] : dflt;\n  },\n  // Check whether we have a value for a key.\n  has: function (k) {\n    return k in this.values;\n  },\n  // Accept a setting if its one of the given alternatives.\n  alt: function (k, v, a) {\n    for (var n = 0; n < a.length; ++n) {\n      if (v === a[n]) {\n        this.set(k, v);\n        break;\n      }\n    }\n  },\n  // Accept a setting if its a valid (signed) integer.\n  integer: function (k, v) {\n    if (/^-?\\d+$/.test(v)) {\n      // integer\n      this.set(k, parseInt(v, 10));\n    }\n  },\n  // Accept a setting if its a valid percentage.\n  percent: function (k, v) {\n    var m;\n\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].trim();\n    var v = kv[1].trim();\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 (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 (e) {\n    if (e instanceof ParsingError) {\n      this.onparsingerror && this.onparsingerror(e);\n    } else {\n      throw e;\n    }\n  },\n  parse: function (data) {\n    var self = this; // 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 () {\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 () {\n        return _id;\n      },\n      set: function (value) {\n        _id = \"\" + value;\n      }\n    },\n    \"pauseOnExit\": {\n      enumerable: true,\n      get: function () {\n        return _pauseOnExit;\n      },\n      set: function (value) {\n        _pauseOnExit = !!value;\n      }\n    },\n    \"startTime\": {\n      enumerable: true,\n      get: function () {\n        return _startTime;\n      },\n      set: function (value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Start time must be set to a number.\");\n        }\n\n        _startTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"endTime\": {\n      enumerable: true,\n      get: function () {\n        return _endTime;\n      },\n      set: function (value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"End time must be set to a number.\");\n        }\n\n        _endTime = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"text\": {\n      enumerable: true,\n      get: function () {\n        return _text;\n      },\n      set: function (value) {\n        _text = \"\" + value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"region\": {\n      enumerable: true,\n      get: function () {\n        return _region;\n      },\n      set: function (value) {\n        _region = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"vertical\": {\n      enumerable: true,\n      get: function () {\n        return _vertical;\n      },\n      set: function (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 () {\n        return _snapToLines;\n      },\n      set: function (value) {\n        _snapToLines = !!value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"line\": {\n      enumerable: true,\n      get: function () {\n        return _line;\n      },\n      set: function (value) {\n        if (typeof value !== \"number\" && value !== autoKeyword) {\n          throw new SyntaxError(\"Line: an invalid number or illegal string was specified.\");\n        }\n\n        _line = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"lineAlign\": {\n      enumerable: true,\n      get: function () {\n        return _lineAlign;\n      },\n      set: function (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 () {\n        return _position;\n      },\n      set: function (value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Position must be between 0 and 100.\");\n        }\n\n        _position = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"positionAlign\": {\n      enumerable: true,\n      get: function () {\n        return _positionAlign;\n      },\n      set: function (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 () {\n        return _size;\n      },\n      set: function (value) {\n        if (value < 0 || value > 100) {\n          throw new Error(\"Size must be between 0 and 100.\");\n        }\n\n        _size = value;\n        this.hasBeenReset = true;\n      }\n    },\n    \"align\": {\n      enumerable: true,\n      get: function () {\n        return _align;\n      },\n      set: function (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 () {\n        return _width;\n      },\n      set: function (value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"Width must be between 0 and 100.\");\n        }\n\n        _width = value;\n      }\n    },\n    \"lines\": {\n      enumerable: true,\n      get: function () {\n        return _lines;\n      },\n      set: function (value) {\n        if (typeof value !== \"number\") {\n          throw new TypeError(\"Lines must be set to a number.\");\n        }\n\n        _lines = value;\n      }\n    },\n    \"regionAnchorY\": {\n      enumerable: true,\n      get: function () {\n        return _regionAnchorY;\n      },\n      set: function (value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorX must be between 0 and 100.\");\n        }\n\n        _regionAnchorY = value;\n      }\n    },\n    \"regionAnchorX\": {\n      enumerable: true,\n      get: function () {\n        return _regionAnchorX;\n      },\n      set: function (value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"RegionAnchorY must be between 0 and 100.\");\n        }\n\n        _regionAnchorX = value;\n      }\n    },\n    \"viewportAnchorY\": {\n      enumerable: true,\n      get: function () {\n        return _viewportAnchorY;\n      },\n      set: function (value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorY must be between 0 and 100.\");\n        }\n\n        _viewportAnchorY = value;\n      }\n    },\n    \"viewportAnchorX\": {\n      enumerable: true,\n      get: function () {\n        return _viewportAnchorX;\n      },\n      set: function (value) {\n        if (!isValidPercentValue(value)) {\n          throw new Error(\"ViewportAnchorX must be between 0 and 100.\");\n        }\n\n        _viewportAnchorX = value;\n      }\n    },\n    \"scroll\": {\n      enumerable: true,\n      get: function () {\n        return _scroll;\n      },\n      set: function (value) {\n        var setting = findScrollSetting(value); // 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;","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.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\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    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","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  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","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, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;"],"names":["a","b","isArrayBufferView","obj","ArrayBuffer","isView","buffer","toUint8","bytes","Uint8Array","Array","isArray","byteOffset","byteLength","BigInt","Number","BYTE_TABLE","bytesToNumber","Uint16Array","_temp","_ref","_ref$signed","signed","_ref$le","le","fn","number","prototype","call","total","byte","i","exponent","Math","abs","length","max","numberToBytes","_temp2","_ref2$le","x","byteCount","ceil","toString","countBits","byteIndex","bytesToString","slice","string","String","fromCharCode","apply","decodeURIComponent","escape","e","stringToBytes","stringIsBytes","unescape","encodeURIComponent","view","charCodeAt","concatTypedArrays","_len","arguments","buffers","_key","filter","totalLen","reduce","buf","tempBuffer","offset","forEach","set","bytesMatch","_temp3","_ref3","_ref3$offset","_ref3$mask","mask","every","bByte","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","push","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","value","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","Object","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","module","exports","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","Function","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","fatalError","XMLSerializer","notEmptyString","input","orderedSetReducer","element","toOrderedSet","list","splitOnASCIIWhitespace","copy","src","dest","Class","Super","pt","constructor","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","n","v","attrs2","_ownerElement","getNamedItem","setNamedItem","setNamedItemNS","getNamedItemNS","removeNamedItem","removeNamedItemNS","hasFeature","feature","version","root","insertBefore","refChild","replaceChild","oldChild","hasChildNodes","appendData","isSupported","hasAttributes","lookupNamespaceURI","isDefaultNamespace","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","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","args","_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","values","o","flatten","lists","y","findIndex","matchingFunction","errors","urlTypeToSegment","_ref$baseUrl","_ref$source","_ref$range","range","_ref$indexRange","indexRange","resolvedUri","ranges","startRange","endRange","MAX_SAFE_INTEGER","parseEndNumber","endNumber","segmentRange","static","_attributes$timescale","timescale","sourceDuration","periodDuration","segmentDuration","dynamic","NOW","clientOffset","availabilityStartTime","_attributes$timescale2","_attributes$periodSta","periodStart","_attributes$minimumUp","minimumUpdatePeriod","_attributes$timeShift","timeShiftBufferDepth","now","periodStartWC","segmentCount","availableStart","floor","availableEnd","min","parseByDuration","_attributes$timescale4","_segmentRange$type","_attributes$timescale3","_attributes$startNumb","startNumber","time","toSegments","sectionDuration","segmentsFromBase","_attributes$initializ","initialization","_attributes$indexRang","presentationTime","_attributes$number","initSegment","sourceURL","segmentTimeInfo","addSidxSegmentsToPlaylist$1","sidx","sidxByteRange","sidxEnd","mediaReferences","references","referenceType","firstOffset","reference","referencedSize","subsegmentDuration","endIndex","SUPPORTED_MEDIA_TYPES","getUniqueTimelineStarts","timelineStarts","keyFunction","sort","getMediaGroupPlaylists","mediaGroupPlaylists","properties","group","label","groupKey","labelKey","mediaProperties","updateMediaSequenceForPlaylist","positionManifestOnTimeline","_ref5","oldManifest","newManifest","oldPlaylists","newPlaylists","_ref4","oldPlaylist","findPlaylistWithName","firstNewSegment","oldMatchingSegmentIndex","oldSegment","unshift","updateSequenceNumbers","generateSidxKey","mergeDiscontiguousPlaylists","_acc$name$segments","addSidxSegmentsToPlaylist","sidxMapping","sidxKey","sidxMatch","addSidxSegmentsToPlaylists","formatVideoPlaylist","_attributes2","SUBTITLES","bandwidth","videoOnly","audioOnly","vttOnly","_ref6","flattenMediaGroupPlaylists","mediaGroupObject","labelContents","toM3u8","_ref8","_mediaGroups","dashPlaylists","locations","_ref8$sidxMapping","previousManifest","_dashPlaylists$0$attr","suggestedPresentationDelay","videoPlaylists","audioPlaylists","vttPlaylists","captions","captionServices","Boolean","VIDEO","isAudioOnly","organizedAudioGroup","mainPlaylist","formattedPlaylists","role","roleLabel","formatted","_attributes","formatAudioPlaylist","organizeAudioPlaylists","organizedVttGroup","_m3u8Attributes","m3u8Attributes","formatVttPlaylist","organizeVttPlaylists","playlistTimelineStarts","_ref9","_ref7","subs","cc","svcObj","svc","service","channel","aspectRatio","easyReader","getLiveRValue","parseByTimeline","segmentTimeline","_attributes$minimumUp2","_attributes$media","sIndex","S","d","repeat","segmentTime","nextS","identifierPattern","constructTemplateUrl","format","identifierReplacement","segmentsFromTemplate","templateValues","RepresentationID","Bandwidth","mapSegment","parseTemplateInfo","Time","presentationTimeOffset","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","representations","adaptationSetSegmentInfo","representation","repBaseUrlElements","repBaseUrls","representationSegmentInfo","inheritBaseUrls","toAdaptationSets","mpdAttributes","mpdBaseUrls","period","adaptationSets","stringToMpdXml","manifestString","mpd","parsedManifestInfo","_options","_options$manifestUri","manifestUri","_options$NOW","_options$clientOffset","periodNodes","periods","priorPeriod","priorPeriodAttributes","mpdType","getPeriodStart","representationInfo","inheritAttributes","parseUTCTiming","UTCTimingNode","parseUTCTimingScheme","getUint64","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","MAX_UINT32","pow","uint8","dv","getBigUint64","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","create","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","TypeError","setting","findDirectionSetting","SyntaxError","getCueAsHTML","scrollSetting","isValidPercentValue","_width","_lines","_regionAnchorX","_regionAnchorY","_viewportAnchorX","_viewportAnchorY","_scroll","findScrollSetting","setPrototypeOf","isNativeReflectConstruct","_construct","Parent","Reflect","construct","bind","__esModule","instance","subClass","superClass","writable","configurable","sham","Proxy","valueOf"],"sourceRoot":""}