(window["webpackjsonp"] = window["webpackjsonp"] || []).push([[69],{

/***/ 110:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var replace = string.prototype.replace;
var percenttwenties = /%20/g;

var format = {
    rfc1738: 'rfc1738',
    rfc3986: 'rfc3986'
};

module.exports = {
    'default': format.rfc3986,
    formatters: {
        rfc1738: function (value) {
            return replace.call(value, percenttwenties, '+');
        },
        rfc3986: function (value) {
            return string(value);
        }
    },
    rfc1738: format.rfc1738,
    rfc3986: format.rfc3986
};


/***/ }),

/***/ 124:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var stringify = __webpack_require__(325);
var parse = __webpack_require__(335);
var formats = __webpack_require__(110);

module.exports = {
    formats: formats,
    parse: parse,
    stringify: stringify
};


/***/ }),

/***/ 178:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var formats = __webpack_require__(110);

var has = object.prototype.hasownproperty;
var isarray = array.isarray;

var hextable = (function () {
    var array = [];
    for (var i = 0; i < 256; ++i) {
        array.push('%' + ((i < 16 ? '0' : '') + i.tostring(16)).touppercase());
    }

    return array;
}());

var compactqueue = function compactqueue(queue) {
    while (queue.length > 1) {
        var item = queue.pop();
        var obj = item.obj[item.prop];

        if (isarray(obj)) {
            var compacted = [];

            for (var j = 0; j < obj.length; ++j) {
                if (typeof obj[j] !== 'undefined') {
                    compacted.push(obj[j]);
                }
            }

            item.obj[item.prop] = compacted;
        }
    }
};

var arraytoobject = function arraytoobject(source, options) {
    var obj = options && options.plainobjects ? object.create(null) : {};
    for (var i = 0; i < source.length; ++i) {
        if (typeof source[i] !== 'undefined') {
            obj[i] = source[i];
        }
    }

    return obj;
};

var merge = function merge(target, source, options) {
    /* eslint no-param-reassign: 0 */
    if (!source) {
        return target;
    }

    if (typeof source !== 'object') {
        if (isarray(target)) {
            target.push(source);
        } else if (target && typeof target === 'object') {
            if ((options && (options.plainobjects || options.allowprototypes)) || !has.call(object.prototype, source)) {
                target[source] = true;
            }
        } else {
            return [target, source];
        }

        return target;
    }

    if (!target || typeof target !== 'object') {
        return [target].concat(source);
    }

    var mergetarget = target;
    if (isarray(target) && !isarray(source)) {
        mergetarget = arraytoobject(target, options);
    }

    if (isarray(target) && isarray(source)) {
        source.foreach(function (item, i) {
            if (has.call(target, i)) {
                var targetitem = target[i];
                if (targetitem && typeof targetitem === 'object' && item && typeof item === 'object') {
                    target[i] = merge(targetitem, item, options);
                } else {
                    target.push(item);
                }
            } else {
                target[i] = item;
            }
        });
        return target;
    }

    return object.keys(source).reduce(function (acc, key) {
        var value = source[key];

        if (has.call(acc, key)) {
            acc[key] = merge(acc[key], value, options);
        } else {
            acc[key] = value;
        }
        return acc;
    }, mergetarget);
};

var assign = function assignsinglesource(target, source) {
    return object.keys(source).reduce(function (acc, key) {
        acc[key] = source[key];
        return acc;
    }, target);
};

var decode = function (str, decoder, charset) {
    var strwithoutplus = str.replace(/\+/g, ' ');
    if (charset === 'iso-8859-1') {
        // unescape never throws, no try...catch needed:
        return strwithoutplus.replace(/%[0-9a-f]{2}/gi, unescape);
    }
    // utf-8
    try {
        return decodeuricomponent(strwithoutplus);
    } catch (e) {
        return strwithoutplus;
    }
};

var encode = function encode(str, defaultencoder, charset, kind, format) {
    // this code was originally written by brian white (mscdex) for the io.js core querystring library.
    // it has been adapted here for stricter adherence to rfc 3986
    if (str.length === 0) {
        return str;
    }

    var string = str;
    if (typeof str === 'symbol') {
        string = symbol.prototype.tostring.call(str);
    } else if (typeof str !== 'string') {
        string = string(str);
    }

    if (charset === 'iso-8859-1') {
        return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
            return '%26%23' + parseint($0.slice(2), 16) + '%3b';
        });
    }

    var out = '';
    for (var i = 0; i < string.length; ++i) {
        var c = string.charcodeat(i);

        if (
            c === 0x2d // -
            || c === 0x2e // .
            || c === 0x5f // _
            || c === 0x7e // ~
            || (c >= 0x30 && c <= 0x39) // 0-9
            || (c >= 0x41 && c <= 0x5a) // a-z
            || (c >= 0x61 && c <= 0x7a) // a-z
            || (format === formats.rfc1738 && (c === 0x28 || c === 0x29)) // ( )
        ) {
            out += string.charat(i);
            continue;
        }

        if (c < 0x80) {
            out = out + hextable[c];
            continue;
        }

        if (c < 0x800) {
            out = out + (hextable[0xc0 | (c >> 6)] + hextable[0x80 | (c & 0x3f)]);
            continue;
        }

        if (c < 0xd800 || c >= 0xe000) {
            out = out + (hextable[0xe0 | (c >> 12)] + hextable[0x80 | ((c >> 6) & 0x3f)] + hextable[0x80 | (c & 0x3f)]);
            continue;
        }

        i += 1;
        c = 0x10000 + (((c & 0x3ff) << 10) | (string.charcodeat(i) & 0x3ff));
        /* eslint operator-linebreak: [2, "before"] */
        out += hextable[0xf0 | (c >> 18)]
            + hextable[0x80 | ((c >> 12) & 0x3f)]
            + hextable[0x80 | ((c >> 6) & 0x3f)]
            + hextable[0x80 | (c & 0x3f)];
    }

    return out;
};

var compact = function compact(value) {
    var queue = [{ obj: { o: value }, prop: 'o' }];
    var refs = [];

    for (var i = 0; i < queue.length; ++i) {
        var item = queue[i];
        var obj = item.obj[item.prop];

        var keys = object.keys(obj);
        for (var j = 0; j < keys.length; ++j) {
            var key = keys[j];
            var val = obj[key];
            if (typeof val === 'object' && val !== null && refs.indexof(val) === -1) {
                queue.push({ obj: obj, prop: key });
                refs.push(val);
            }
        }
    }

    compactqueue(queue);

    return value;
};

var isregexp = function isregexp(obj) {
    return object.prototype.tostring.call(obj) === '[object regexp]';
};

var isbuffer = function isbuffer(obj) {
    if (!obj || typeof obj !== 'object') {
        return false;
    }

    return !!(obj.constructor && obj.constructor.isbuffer && obj.constructor.isbuffer(obj));
};

var combine = function combine(a, b) {
    return [].concat(a, b);
};

var maybemap = function maybemap(val, fn) {
    if (isarray(val)) {
        var mapped = [];
        for (var i = 0; i < val.length; i += 1) {
            mapped.push(fn(val[i]));
        }
        return mapped;
    }
    return fn(val);
};

module.exports = {
    arraytoobject: arraytoobject,
    assign: assign,
    combine: combine,
    compact: compact,
    decode: decode,
    encode: encode,
    isbuffer: isbuffer,
    isregexp: isregexp,
    maybemap: maybemap,
    merge: merge
};


/***/ }),

/***/ 192:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export linestream */
/* unused harmony export parsestream */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return parser; });
/* harmony import */ var _babel_runtime_helpers_inheritsloose__webpack_imported_module_0__ = __webpack_require__(4);
/* harmony import */ var _babel_runtime_helpers_inheritsloose__webpack_imported_module_0___default = /*#__pure__*/__webpack_require__.n(_babel_runtime_helpers_inheritsloose__webpack_imported_module_0__);
/* harmony import */ var _videojs_vhs_utils_es_stream_js__webpack_imported_module_1__ = __webpack_require__(90);
/* harmony import */ var _babel_runtime_helpers_extends__webpack_imported_module_2__ = __webpack_require__(21);
/* harmony import */ var _babel_runtime_helpers_extends__webpack_imported_module_2___default = /*#__pure__*/__webpack_require__.n(_babel_runtime_helpers_extends__webpack_imported_module_2__);
/* harmony import */ var _babel_runtime_helpers_assertthisinitialized__webpack_imported_module_3__ = __webpack_require__(6);
/* harmony import */ var _babel_runtime_helpers_assertthisinitialized__webpack_imported_module_3___default = /*#__pure__*/__webpack_require__.n(_babel_runtime_helpers_assertthisinitialized__webpack_imported_module_3__);
/* harmony import */ var _videojs_vhs_utils_es_decode_b64_to_uint8_array_js__webpack_imported_module_4__ = __webpack_require__(89);
/*! @name m3u8-parser @version 4.7.1 @license apache-2.0 */






/**
 * a stream that buffers string input and generates a `data` event for each
 * line.
 *
 * @class linestream
 * @extends stream
 */

var linestream = /*#__pure__*/function (_stream) {
  _babel_runtime_helpers_inheritsloose__webpack_imported_module_0___default()(linestream, _stream);

  function linestream() {
    var _this;

    _this = _stream.call(this) || this;
    _this.buffer = '';
    return _this;
  }
  /**
   * add new data to be parsed.
   *
   * @param {string} data the text to process
   */


  var _proto = linestream.prototype;

  _proto.push = function push(data) {
    var nextnewline;
    this.buffer += data;
    nextnewline = this.buffer.indexof('\n');

    for (; nextnewline > -1; nextnewline = this.buffer.indexof('\n')) {
      this.trigger('data', this.buffer.substring(0, nextnewline));
      this.buffer = this.buffer.substring(nextnewline + 1);
    }
  };

  return linestream;
}(_videojs_vhs_utils_es_stream_js__webpack_imported_module_1__[/* default */ "a"]);

var tab = string.fromcharcode(0x09);

var parsebyterange = function parsebyterange(byterangestring) {
  // optionally match and capture 0+ digits before `@`
  // optionally match and capture 0+ digits after `@`
  var match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangestring || '');
  var result = {};

  if (match[1]) {
    result.length = parseint(match[1], 10);
  }

  if (match[2]) {
    result.offset = parseint(match[2], 10);
  }

  return result;
};
/**
 * "forgiving" attribute list psuedo-grammar:
 * attributes -> keyvalue (',' keyvalue)*
 * keyvalue   -> key '=' value
 * key        -> [^=]*
 * value      -> '"' [^"]* '"' | [^,]*
 */


var attributeseparator = function attributeseparator() {
  var key = '[^=]*';
  var value = '"[^"]*"|[^,]*';
  var keyvalue = '(?:' + key + ')=(?:' + value + ')';
  return new regexp('(?:^|,)(' + keyvalue + ')');
};
/**
 * parse attributes from a line given the separator
 *
 * @param {string} attributes the attribute line to parse
 */


var parseattributes = function parseattributes(attributes) {
  // split the string using attributes as the separator
  var attrs = attributes.split(attributeseparator());
  var result = {};
  var i = attrs.length;
  var attr;

  while (i--) {
    // filter out unmatched portions of the string
    if (attrs[i] === '') {
      continue;
    } // split the key and value


    attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1); // trim whitespace and remove optional quotes around the value

    attr[0] = attr[0].replace(/^\s+|\s+$/g, '');
    attr[1] = attr[1].replace(/^\s+|\s+$/g, '');
    attr[1] = attr[1].replace(/^['"](.*)['"]$/g, '$1');
    result[attr[0]] = attr[1];
  }

  return result;
};
/**
 * a line-level m3u8 parser event stream. it expects to receive input one
 * line at a time and performs a context-free parse of its contents. a stream
 * interpretation of a manifest can be useful if the manifest is expected to
 * be too large to fit comfortably into memory or the entirety of the input
 * is not immediately available. otherwise, it's probably much easier to work
 * with a regular `parser` object.
 *
 * produces `data` events with an object that captures the parser's
 * interpretation of the input. that object has a property `tag` that is one
 * of `uri`, `comment`, or `tag`. uris only have a single additional
 * property, `line`, which captures the entirety of the input without
 * interpretation. comments similarly have a single additional property
 * `text` which is the input without the leading `#`.
 *
 * tags always have a property `tagtype` which is the lower-cased version of
 * the m3u8 directive without the `#ext` or `#ext-x-` prefix. for instance,
 * `#ext-x-media-sequence` becomes `media-sequence` when parsed. unrecognized
 * tags are given the tag type `unknown` and a single additional property
 * `data` with the remainder of the input.
 *
 * @class parsestream
 * @extends stream
 */


var parsestream = /*#__pure__*/function (_stream) {
  _babel_runtime_helpers_inheritsloose__webpack_imported_module_0___default()(parsestream, _stream);

  function parsestream() {
    var _this;

    _this = _stream.call(this) || this;
    _this.customparsers = [];
    _this.tagmappers = [];
    return _this;
  }
  /**
   * parses an additional line of input.
   *
   * @param {string} line a single line of an m3u8 file to parse
   */


  var _proto = parsestream.prototype;

  _proto.push = function push(line) {
    var _this2 = this;

    var match;
    var event; // strip whitespace

    line = line.trim();

    if (line.length === 0) {
      // ignore empty lines
      return;
    } // uris


    if (line[0] !== '#') {
      this.trigger('data', {
        type: 'uri',
        uri: line
      });
      return;
    } // map tags


    var newlines = this.tagmappers.reduce(function (acc, mapper) {
      var mappedline = mapper(line); // skip if unchanged

      if (mappedline === line) {
        return acc;
      }

      return acc.concat([mappedline]);
    }, [line]);
    newlines.foreach(function (newline) {
      for (var i = 0; i < _this2.customparsers.length; i++) {
        if (_this2.customparsers[i].call(_this2, newline)) {
          return;
        }
      } // comments


      if (newline.indexof('#ext') !== 0) {
        _this2.trigger('data', {
          type: 'comment',
          text: newline.slice(1)
        });

        return;
      } // strip off any carriage returns here so the regex matching
      // doesn't have to account for them.


      newline = newline.replace('\r', ''); // tags

      match = /^#extm3u/.exec(newline);

      if (match) {
        _this2.trigger('data', {
          type: 'tag',
          tagtype: 'm3u'
        });

        return;
      }

      match = /^#extinf:?([0-9\.]*)?,?(.*)?$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'inf'
        };

        if (match[1]) {
          event.duration = parsefloat(match[1]);
        }

        if (match[2]) {
          event.title = match[2];
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-targetduration:?([0-9.]*)?/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'targetduration'
        };

        if (match[1]) {
          event.duration = parseint(match[1], 10);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-version:?([0-9.]*)?/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'version'
        };

        if (match[1]) {
          event.version = parseint(match[1], 10);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-media-sequence:?(\-?[0-9.]*)?/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'media-sequence'
        };

        if (match[1]) {
          event.number = parseint(match[1], 10);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-discontinuity-sequence:?(\-?[0-9.]*)?/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'discontinuity-sequence'
        };

        if (match[1]) {
          event.number = parseint(match[1], 10);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-playlist-type:?(.*)?$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'playlist-type'
        };

        if (match[1]) {
          event.playlisttype = match[1];
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-byterange:?(.*)?$/.exec(newline);

      if (match) {
        event = _babel_runtime_helpers_extends__webpack_imported_module_2___default()(parsebyterange(match[1]), {
          type: 'tag',
          tagtype: 'byterange'
        });

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-allow-cache:?(yes|no)?/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'allow-cache'
        };

        if (match[1]) {
          event.allowed = !/no/.test(match[1]);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-map:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'map'
        };

        if (match[1]) {
          var attributes = parseattributes(match[1]);

          if (attributes.uri) {
            event.uri = attributes.uri;
          }

          if (attributes.byterange) {
            event.byterange = parsebyterange(attributes.byterange);
          }
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-stream-inf:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'stream-inf'
        };

        if (match[1]) {
          event.attributes = parseattributes(match[1]);

          if (event.attributes.resolution) {
            var split = event.attributes.resolution.split('x');
            var resolution = {};

            if (split[0]) {
              resolution.width = parseint(split[0], 10);
            }

            if (split[1]) {
              resolution.height = parseint(split[1], 10);
            }

            event.attributes.resolution = resolution;
          }

          if (event.attributes.bandwidth) {
            event.attributes.bandwidth = parseint(event.attributes.bandwidth, 10);
          }

          if (event.attributes['program-id']) {
            event.attributes['program-id'] = parseint(event.attributes['program-id'], 10);
          }
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-media:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'media'
        };

        if (match[1]) {
          event.attributes = parseattributes(match[1]);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-endlist/.exec(newline);

      if (match) {
        _this2.trigger('data', {
          type: 'tag',
          tagtype: 'endlist'
        });

        return;
      }

      match = /^#ext-x-discontinuity/.exec(newline);

      if (match) {
        _this2.trigger('data', {
          type: 'tag',
          tagtype: 'discontinuity'
        });

        return;
      }

      match = /^#ext-x-program-date-time:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'program-date-time'
        };

        if (match[1]) {
          event.datetimestring = match[1];
          event.datetimeobject = new date(match[1]);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-key:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'key'
        };

        if (match[1]) {
          event.attributes = parseattributes(match[1]); // parse the iv string into a uint32array

          if (event.attributes.iv) {
            if (event.attributes.iv.substring(0, 2).tolowercase() === '0x') {
              event.attributes.iv = event.attributes.iv.substring(2);
            }

            event.attributes.iv = event.attributes.iv.match(/.{8}/g);
            event.attributes.iv[0] = parseint(event.attributes.iv[0], 16);
            event.attributes.iv[1] = parseint(event.attributes.iv[1], 16);
            event.attributes.iv[2] = parseint(event.attributes.iv[2], 16);
            event.attributes.iv[3] = parseint(event.attributes.iv[3], 16);
            event.attributes.iv = new uint32array(event.attributes.iv);
          }
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-start:?(.*)$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'start'
        };

        if (match[1]) {
          event.attributes = parseattributes(match[1]);
          event.attributes['time-offset'] = parsefloat(event.attributes['time-offset']);
          event.attributes.precise = /yes/.test(event.attributes.precise);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-cue-out-cont:?(.*)?$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'cue-out-cont'
        };

        if (match[1]) {
          event.data = match[1];
        } else {
          event.data = '';
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-cue-out:?(.*)?$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'cue-out'
        };

        if (match[1]) {
          event.data = match[1];
        } else {
          event.data = '';
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-cue-in:?(.*)?$/.exec(newline);

      if (match) {
        event = {
          type: 'tag',
          tagtype: 'cue-in'
        };

        if (match[1]) {
          event.data = match[1];
        } else {
          event.data = '';
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-skip:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'skip'
        };
        event.attributes = parseattributes(match[1]);

        if (event.attributes.hasownproperty('skipped-segments')) {
          event.attributes['skipped-segments'] = parseint(event.attributes['skipped-segments'], 10);
        }

        if (event.attributes.hasownproperty('recently-removed-dateranges')) {
          event.attributes['recently-removed-dateranges'] = event.attributes['recently-removed-dateranges'].split(tab);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-part:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'part'
        };
        event.attributes = parseattributes(match[1]);
        ['duration'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = parsefloat(event.attributes[key]);
          }
        });
        ['independent', 'gap'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = /yes/.test(event.attributes[key]);
          }
        });

        if (event.attributes.hasownproperty('byterange')) {
          event.attributes.byterange = parsebyterange(event.attributes.byterange);
        }

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-server-control:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'server-control'
        };
        event.attributes = parseattributes(match[1]);
        ['can-skip-until', 'part-hold-back', 'hold-back'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = parsefloat(event.attributes[key]);
          }
        });
        ['can-skip-dateranges', 'can-block-reload'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = /yes/.test(event.attributes[key]);
          }
        });

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-part-inf:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'part-inf'
        };
        event.attributes = parseattributes(match[1]);
        ['part-target'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = parsefloat(event.attributes[key]);
          }
        });

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-preload-hint:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'preload-hint'
        };
        event.attributes = parseattributes(match[1]);
        ['byterange-start', 'byterange-length'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = parseint(event.attributes[key], 10);
            var subkey = key === 'byterange-length' ? 'length' : 'offset';
            event.attributes.byterange = event.attributes.byterange || {};
            event.attributes.byterange[subkey] = event.attributes[key]; // only keep the parsed byterange object.

            delete event.attributes[key];
          }
        });

        _this2.trigger('data', event);

        return;
      }

      match = /^#ext-x-rendition-report:(.*)$/.exec(newline);

      if (match && match[1]) {
        event = {
          type: 'tag',
          tagtype: 'rendition-report'
        };
        event.attributes = parseattributes(match[1]);
        ['last-msn', 'last-part'].foreach(function (key) {
          if (event.attributes.hasownproperty(key)) {
            event.attributes[key] = parseint(event.attributes[key], 10);
          }
        });

        _this2.trigger('data', event);

        return;
      } // unknown tag type


      _this2.trigger('data', {
        type: 'tag',
        data: newline.slice(4)
      });
    });
  }
  /**
   * add a parser for custom headers
   *
   * @param {object}   options              a map of options for the added parser
   * @param {regexp}   options.expression   a regular expression to match the custom header
   * @param {string}   options.customtype   the custom type to register to the output
   * @param {function} [options.dataparser] function to parse the line into an object
   * @param {boolean}  [options.segment]    should tag data be attached to the segment object
   */
  ;

  _proto.addparser = function addparser(_ref) {
    var _this3 = this;

    var expression = _ref.expression,
        customtype = _ref.customtype,
        dataparser = _ref.dataparser,
        segment = _ref.segment;

    if (typeof dataparser !== 'function') {
      dataparser = function dataparser(line) {
        return line;
      };
    }

    this.customparsers.push(function (line) {
      var match = expression.exec(line);

      if (match) {
        _this3.trigger('data', {
          type: 'custom',
          data: dataparser(line),
          customtype: customtype,
          segment: segment
        });

        return true;
      }
    });
  }
  /**
   * add a custom header mapper
   *
   * @param {object}   options
   * @param {regexp}   options.expression   a regular expression to match the custom header
   * @param {function} options.map          function to translate tag into a different tag
   */
  ;

  _proto.addtagmapper = function addtagmapper(_ref2) {
    var expression = _ref2.expression,
        map = _ref2.map;

    var mapfn = function mapfn(line) {
      if (expression.test(line)) {
        return map(line);
      }

      return line;
    };

    this.tagmappers.push(mapfn);
  };

  return parsestream;
}(_videojs_vhs_utils_es_stream_js__webpack_imported_module_1__[/* default */ "a"]);

var camelcase = function camelcase(str) {
  return str.tolowercase().replace(/-(\w)/g, function (a) {
    return a[1].touppercase();
  });
};

var camelcasekeys = function camelcasekeys(attributes) {
  var result = {};
  object.keys(attributes).foreach(function (key) {
    result[camelcase(key)] = attributes[key];
  });
  return result;
}; // set server-control hold back based upon targetduration and parttargetduration
// we need this helper because defaults are based upon targetduration and
// parttargetduration being set, but they may not be if server-control appears before
// target durations are set.


var setholdback = function setholdback(manifest) {
  var servercontrol = manifest.servercontrol,
      targetduration = manifest.targetduration,
      parttargetduration = manifest.parttargetduration;

  if (!servercontrol) {
    return;
  }

  var tag = '#ext-x-server-control';
  var hb = 'holdback';
  var phb = 'partholdback';
  var mintargetduration = targetduration && targetduration * 3;
  var minpartduration = parttargetduration && parttargetduration * 2;

  if (targetduration && !servercontrol.hasownproperty(hb)) {
    servercontrol[hb] = mintargetduration;
    this.trigger('info', {
      message: tag + " defaulting hold-back to targetduration * 3 (" + mintargetduration + ")."
    });
  }

  if (mintargetduration && servercontrol[hb] < mintargetduration) {
    this.trigger('warn', {
      message: tag + " clamping hold-back (" + servercontrol[hb] + ") to targetduration * 3 (" + mintargetduration + ")"
    });
    servercontrol[hb] = mintargetduration;
  } // default no part hold back to part target duration * 3


  if (parttargetduration && !servercontrol.hasownproperty(phb)) {
    servercontrol[phb] = parttargetduration * 3;
    this.trigger('info', {
      message: tag + " defaulting part-hold-back to parttargetduration * 3 (" + servercontrol[phb] + ")."
    });
  } // if part hold back is too small default it to part target duration * 2


  if (parttargetduration && servercontrol[phb] < minpartduration) {
    this.trigger('warn', {
      message: tag + " clamping part-hold-back (" + servercontrol[phb] + ") to parttargetduration * 2 (" + minpartduration + ")."
    });
    servercontrol[phb] = minpartduration;
  }
};
/**
 * a parser for m3u8 files. the current interpretation of the input is
 * exposed as a property `manifest` on parser objects. it's just two lines to
 * create and parse a manifest once you have the contents available as a string:
 *
 * ```js
 * var parser = new m3u8.parser();
 * parser.push(xhr.responsetext);
 * ```
 *
 * new input can later be applied to update the manifest object by calling
 * `push` again.
 *
 * the parser attempts to create a usable manifest object even if the
 * underlying input is somewhat nonsensical. it emits `info` and `warning`
 * events during the parse if it encounters input that seems invalid or
 * requires some property of the manifest object to be defaulted.
 *
 * @class parser
 * @extends stream
 */


var parser = /*#__pure__*/function (_stream) {
  _babel_runtime_helpers_inheritsloose__webpack_imported_module_0___default()(parser, _stream);

  function parser() {
    var _this;

    _this = _stream.call(this) || this;
    _this.linestream = new linestream();
    _this.parsestream = new parsestream();

    _this.linestream.pipe(_this.parsestream);
    /* eslint-disable consistent-this */


    var self = _babel_runtime_helpers_assertthisinitialized__webpack_imported_module_3___default()(_this);
    /* eslint-enable consistent-this */


    var uris = [];
    var currenturi = {}; // if specified, the active ext-x-map definition

    var currentmap; // if specified, the active decryption key

    var _key;

    var hasparts = false;

    var noop = function noop() {};

    var defaultmediagroups = {
      'audio': {},
      'video': {},
      'closed-captions': {},
      'subtitles': {}
    }; // this is the widevine uuid from dash if iop. the same exact string is
    // used in mpds with widevine encrypted streams.

    var widevineuuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities

    var currenttimeline = 0; // the manifest is empty until the parse stream begins delivering data

    _this.manifest = {
      allowcache: true,
      discontinuitystarts: [],
      segments: []
    }; // keep track of the last seen segment's byte range end, as segments are not required
    // to provide the offset, in which case it defaults to the next byte after the
    // previous segment

    var lastbyterangeend = 0; // keep track of the last seen part's byte range end.

    var lastpartbyterangeend = 0;

    _this.on('end', function () {
      // only add preloadsegment if we don't yet have a uri for it.
      // and we actually have parts/preloadhints
      if (currenturi.uri || !currenturi.parts && !currenturi.preloadhints) {
        return;
      }

      if (!currenturi.map && currentmap) {
        currenturi.map = currentmap;
      }

      if (!currenturi.key && _key) {
        currenturi.key = _key;
      }

      if (!currenturi.timeline && typeof currenttimeline === 'number') {
        currenturi.timeline = currenttimeline;
      }

      _this.manifest.preloadsegment = currenturi;
    }); // update the manifest with the m3u8 entry from the parse stream


    _this.parsestream.on('data', function (entry) {
      var mediagroup;
      var rendition;
      ({
        tag: function tag() {
          // switch based on the tag type
          (({
            version: function version() {
              if (entry.version) {
                this.manifest.version = entry.version;
              }
            },
            'allow-cache': function allowcache() {
              this.manifest.allowcache = entry.allowed;

              if (!('allowed' in entry)) {
                this.trigger('info', {
                  message: 'defaulting allowcache to yes'
                });
                this.manifest.allowcache = true;
              }
            },
            byterange: function byterange() {
              var byterange = {};

              if ('length' in entry) {
                currenturi.byterange = byterange;
                byterange.length = entry.length;

                if (!('offset' in entry)) {
                  /*
                   * from the latest spec (as of this writing):
                   * https://tools.ietf.org/html/draft-pantos-http-live-streaming-23#section-4.3.2.2
                   *
                   * same text since ext-x-byterange's introduction in draft 7:
                   * https://tools.ietf.org/html/draft-pantos-http-live-streaming-07#section-3.3.1)
                   *
                   * "if o [offset] is not present, the sub-range begins at the next byte
                   * following the sub-range of the previous media segment."
                   */
                  entry.offset = lastbyterangeend;
                }
              }

              if ('offset' in entry) {
                currenturi.byterange = byterange;
                byterange.offset = entry.offset;
              }

              lastbyterangeend = byterange.offset + byterange.length;
            },
            endlist: function endlist() {
              this.manifest.endlist = true;
            },
            inf: function inf() {
              if (!('mediasequence' in this.manifest)) {
                this.manifest.mediasequence = 0;
                this.trigger('info', {
                  message: 'defaulting media sequence to zero'
                });
              }

              if (!('discontinuitysequence' in this.manifest)) {
                this.manifest.discontinuitysequence = 0;
                this.trigger('info', {
                  message: 'defaulting discontinuity sequence to zero'
                });
              }

              if (entry.duration > 0) {
                currenturi.duration = entry.duration;
              }

              if (entry.duration === 0) {
                currenturi.duration = 0.01;
                this.trigger('info', {
                  message: 'updating zero segment duration to a small value'
                });
              }

              this.manifest.segments = uris;
            },
            key: function key() {
              if (!entry.attributes) {
                this.trigger('warn', {
                  message: 'ignoring key declaration without attribute list'
                });
                return;
              } // clear the active encryption key


              if (entry.attributes.method === 'none') {
                _key = null;
                return;
              }

              if (!entry.attributes.uri) {
                this.trigger('warn', {
                  message: 'ignoring key declaration without uri'
                });
                return;
              }

              if (entry.attributes.keyformat === 'com.apple.streamingkeydelivery') {
                this.manifest.contentprotection = this.manifest.contentprotection || {}; // todo: add full support for this.

                this.manifest.contentprotection['com.apple.fps.1_0'] = {
                  attributes: entry.attributes
                };
                return;
              }

              if (entry.attributes.keyformat === 'com.microsoft.playready') {
                this.manifest.contentprotection = this.manifest.contentprotection || {}; // todo: add full support for this.

                this.manifest.contentprotection['com.microsoft.playready'] = {
                  uri: entry.attributes.uri
                };
                return;
              } // check if the content is encrypted for widevine
              // widevine/hls spec: https://storage.googleapis.com/wvdocs/widevine_drm_hls.pdf


              if (entry.attributes.keyformat === widevineuuid) {
                var valid_methods = ['sample-aes', 'sample-aes-ctr', 'sample-aes-cenc'];

                if (valid_methods.indexof(entry.attributes.method) === -1) {
                  this.trigger('warn', {
                    message: 'invalid key method provided for widevine'
                  });
                  return;
                }

                if (entry.attributes.method === 'sample-aes-cenc') {
                  this.trigger('warn', {
                    message: 'sample-aes-cenc is deprecated, please use sample-aes-ctr instead'
                  });
                }

                if (entry.attributes.uri.substring(0, 23) !== 'data:text/plain;base64,') {
                  this.trigger('warn', {
                    message: 'invalid key uri provided for widevine'
                  });
                  return;
                }

                if (!(entry.attributes.keyid && entry.attributes.keyid.substring(0, 2) === '0x')) {
                  this.trigger('warn', {
                    message: 'invalid key id provided for widevine'
                  });
                  return;
                } // if widevine key attributes are valid, store them as `contentprotection`
                // on the manifest to emulate widevine tag structure in a dash mpd


                this.manifest.contentprotection = this.manifest.contentprotection || {};
                this.manifest.contentprotection['com.widevine.alpha'] = {
                  attributes: {
                    schemeiduri: entry.attributes.keyformat,
                    // remove '0x' from the key id string
                    keyid: entry.attributes.keyid.substring(2)
                  },
                  // decode the base64-encoded pssh box
                  pssh: object(_videojs_vhs_utils_es_decode_b64_to_uint8_array_js__webpack_imported_module_4__[/* default */ "a"])(entry.attributes.uri.split(',')[1])
                };
                return;
              }

              if (!entry.attributes.method) {
                this.trigger('warn', {
                  message: 'defaulting key method to aes-128'
                });
              } // setup an encryption key for upcoming segments


              _key = {
                method: entry.attributes.method || 'aes-128',
                uri: entry.attributes.uri
              };

              if (typeof entry.attributes.iv !== 'undefined') {
                _key.iv = entry.attributes.iv;
              }
            },
            'media-sequence': function mediasequence() {
              if (!isfinite(entry.number)) {
                this.trigger('warn', {
                  message: 'ignoring invalid media sequence: ' + entry.number
                });
                return;
              }

              this.manifest.mediasequence = entry.number;
            },
            'discontinuity-sequence': function discontinuitysequence() {
              if (!isfinite(entry.number)) {
                this.trigger('warn', {
                  message: 'ignoring invalid discontinuity sequence: ' + entry.number
                });
                return;
              }

              this.manifest.discontinuitysequence = entry.number;
              currenttimeline = entry.number;
            },
            'playlist-type': function playlisttype() {
              if (!/vod|event/.test(entry.playlisttype)) {
                this.trigger('warn', {
                  message: 'ignoring unknown playlist type: ' + entry.playlist
                });
                return;
              }

              this.manifest.playlisttype = entry.playlisttype;
            },
            map: function map() {
              currentmap = {};

              if (entry.uri) {
                currentmap.uri = entry.uri;
              }

              if (entry.byterange) {
                currentmap.byterange = entry.byterange;
              }

              if (_key) {
                currentmap.key = _key;
              }
            },
            'stream-inf': function streaminf() {
              this.manifest.playlists = uris;
              this.manifest.mediagroups = this.manifest.mediagroups || defaultmediagroups;

              if (!entry.attributes) {
                this.trigger('warn', {
                  message: 'ignoring empty stream-inf attributes'
                });
                return;
              }

              if (!currenturi.attributes) {
                currenturi.attributes = {};
              }

              _babel_runtime_helpers_extends__webpack_imported_module_2___default()(currenturi.attributes, entry.attributes);
            },
            media: function media() {
              this.manifest.mediagroups = this.manifest.mediagroups || defaultmediagroups;

              if (!(entry.attributes && entry.attributes.type && entry.attributes['group-id'] && entry.attributes.name)) {
                this.trigger('warn', {
                  message: 'ignoring incomplete or missing media group'
                });
                return;
              } // find the media group, creating defaults as necessary


              var mediagrouptype = this.manifest.mediagroups[entry.attributes.type];
              mediagrouptype[entry.attributes['group-id']] = mediagrouptype[entry.attributes['group-id']] || {};
              mediagroup = mediagrouptype[entry.attributes['group-id']]; // collect the rendition metadata

              rendition = {
                default: /yes/i.test(entry.attributes.default)
              };

              if (rendition.default) {
                rendition.autoselect = true;
              } else {
                rendition.autoselect = /yes/i.test(entry.attributes.autoselect);
              }

              if (entry.attributes.language) {
                rendition.language = entry.attributes.language;
              }

              if (entry.attributes.uri) {
                rendition.uri = entry.attributes.uri;
              }

              if (entry.attributes['instream-id']) {
                rendition.instreamid = entry.attributes['instream-id'];
              }

              if (entry.attributes.characteristics) {
                rendition.characteristics = entry.attributes.characteristics;
              }

              if (entry.attributes.forced) {
                rendition.forced = /yes/i.test(entry.attributes.forced);
              } // insert the new rendition


              mediagroup[entry.attributes.name] = rendition;
            },
            discontinuity: function discontinuity() {
              currenttimeline += 1;
              currenturi.discontinuity = true;
              this.manifest.discontinuitystarts.push(uris.length);
            },
            'program-date-time': function programdatetime() {
              if (typeof this.manifest.datetimestring === 'undefined') {
                // program-date-time is a media-segment tag, but for backwards
                // compatibility, we add the first occurence of the program-date-time tag
                // to the manifest object
                // todo: consider removing this in future major version
                this.manifest.datetimestring = entry.datetimestring;
                this.manifest.datetimeobject = entry.datetimeobject;
              }

              currenturi.datetimestring = entry.datetimestring;
              currenturi.datetimeobject = entry.datetimeobject;
            },
            targetduration: function targetduration() {
              if (!isfinite(entry.duration) || entry.duration < 0) {
                this.trigger('warn', {
                  message: 'ignoring invalid target duration: ' + entry.duration
                });
                return;
              }

              this.manifest.targetduration = entry.duration;
              setholdback.call(this, this.manifest);
            },
            start: function start() {
              if (!entry.attributes || isnan(entry.attributes['time-offset'])) {
                this.trigger('warn', {
                  message: 'ignoring start declaration without appropriate attribute list'
                });
                return;
              }

              this.manifest.start = {
                timeoffset: entry.attributes['time-offset'],
                precise: entry.attributes.precise
              };
            },
            'cue-out': function cueout() {
              currenturi.cueout = entry.data;
            },
            'cue-out-cont': function cueoutcont() {
              currenturi.cueoutcont = entry.data;
            },
            'cue-in': function cuein() {
              currenturi.cuein = entry.data;
            },
            'skip': function skip() {
              this.manifest.skip = camelcasekeys(entry.attributes);
              this.warnonmissingattributes_('#ext-x-skip', entry.attributes, ['skipped-segments']);
            },
            'part': function part() {
              var _this2 = this;

              hasparts = true; // parts are always specifed before a segment

              var segmentindex = this.manifest.segments.length;
              var part = camelcasekeys(entry.attributes);
              currenturi.parts = currenturi.parts || [];
              currenturi.parts.push(part);

              if (part.byterange) {
                if (!part.byterange.hasownproperty('offset')) {
                  part.byterange.offset = lastpartbyterangeend;
                }

                lastpartbyterangeend = part.byterange.offset + part.byterange.length;
              }

              var partindex = currenturi.parts.length - 1;
              this.warnonmissingattributes_("#ext-x-part #" + partindex + " for segment #" + segmentindex, entry.attributes, ['uri', 'duration']);

              if (this.manifest.renditionreports) {
                this.manifest.renditionreports.foreach(function (r, i) {
                  if (!r.hasownproperty('lastpart')) {
                    _this2.trigger('warn', {
                      message: "#ext-x-rendition-report #" + i + " lacks required attribute(s): last-part"
                    });
                  }
                });
              }
            },
            'server-control': function servercontrol() {
              var attrs = this.manifest.servercontrol = camelcasekeys(entry.attributes);

              if (!attrs.hasownproperty('canblockreload')) {
                attrs.canblockreload = false;
                this.trigger('info', {
                  message: '#ext-x-server-control defaulting can-block-reload to false'
                });
              }

              setholdback.call(this, this.manifest);

              if (attrs.canskipdateranges && !attrs.hasownproperty('canskipuntil')) {
                this.trigger('warn', {
                  message: '#ext-x-server-control lacks required attribute can-skip-until which is required when can-skip-dateranges is set'
                });
              }
            },
            'preload-hint': function preloadhint() {
              // parts are always specifed before a segment
              var segmentindex = this.manifest.segments.length;
              var hint = camelcasekeys(entry.attributes);
              var ispart = hint.type && hint.type === 'part';
              currenturi.preloadhints = currenturi.preloadhints || [];
              currenturi.preloadhints.push(hint);

              if (hint.byterange) {
                if (!hint.byterange.hasownproperty('offset')) {
                  // use last part byterange end or zero if not a part.
                  hint.byterange.offset = ispart ? lastpartbyterangeend : 0;

                  if (ispart) {
                    lastpartbyterangeend = hint.byterange.offset + hint.byterange.length;
                  }
                }
              }

              var index = currenturi.preloadhints.length - 1;
              this.warnonmissingattributes_("#ext-x-preload-hint #" + index + " for segment #" + segmentindex, entry.attributes, ['type', 'uri']);

              if (!hint.type) {
                return;
              } // search through all preload hints except for the current one for
              // a duplicate type.


              for (var i = 0; i < currenturi.preloadhints.length - 1; i++) {
                var otherhint = currenturi.preloadhints[i];

                if (!otherhint.type) {
                  continue;
                }

                if (otherhint.type === hint.type) {
                  this.trigger('warn', {
                    message: "#ext-x-preload-hint #" + index + " for segment #" + segmentindex + " has the same type " + hint.type + " as preload hint #" + i
                  });
                }
              }
            },
            'rendition-report': function renditionreport() {
              var report = camelcasekeys(entry.attributes);
              this.manifest.renditionreports = this.manifest.renditionreports || [];
              this.manifest.renditionreports.push(report);
              var index = this.manifest.renditionreports.length - 1;
              var required = ['last-msn', 'uri'];

              if (hasparts) {
                required.push('last-part');
              }

              this.warnonmissingattributes_("#ext-x-rendition-report #" + index, entry.attributes, required);
            },
            'part-inf': function partinf() {
              this.manifest.partinf = camelcasekeys(entry.attributes);
              this.warnonmissingattributes_('#ext-x-part-inf', entry.attributes, ['part-target']);

              if (this.manifest.partinf.parttarget) {
                this.manifest.parttargetduration = this.manifest.partinf.parttarget;
              }

              setholdback.call(this, this.manifest);
            }
          })[entry.tagtype] || noop).call(self);
        },
        uri: function uri() {
          currenturi.uri = entry.uri;
          uris.push(currenturi); // if no explicit duration was declared, use the target duration

          if (this.manifest.targetduration && !('duration' in currenturi)) {
            this.trigger('warn', {
              message: 'defaulting segment duration to the target duration'
            });
            currenturi.duration = this.manifest.targetduration;
          } // annotate with encryption information, if necessary


          if (_key) {
            currenturi.key = _key;
          }

          currenturi.timeline = currenttimeline; // annotate with initialization segment information, if necessary

          if (currentmap) {
            currenturi.map = currentmap;
          } // reset the last byterange end as it needs to be 0 between parts


          lastpartbyterangeend = 0; // prepare for the next uri

          currenturi = {};
        },
        comment: function comment() {// comments are not important for playback
        },
        custom: function custom() {
          // if this is segment-level data attach the output to the segment
          if (entry.segment) {
            currenturi.custom = currenturi.custom || {};
            currenturi.custom[entry.customtype] = entry.data; // if this is manifest-level data attach to the top level manifest object
          } else {
            this.manifest.custom = this.manifest.custom || {};
            this.manifest.custom[entry.customtype] = entry.data;
          }
        }
      })[entry.type].call(self);
    });

    return _this;
  }

  var _proto = parser.prototype;

  _proto.warnonmissingattributes_ = function warnonmissingattributes_(identifier, attributes, required) {
    var missing = [];
    required.foreach(function (key) {
      if (!attributes.hasownproperty(key)) {
        missing.push(key);
      }
    });

    if (missing.length) {
      this.trigger('warn', {
        message: identifier + " lacks required attribute(s): " + missing.join(', ')
      });
    }
  }
  /**
   * parse the input string and update the manifest object.
   *
   * @param {string} chunk a potentially incomplete portion of the manifest
   */
  ;

  _proto.push = function push(chunk) {
    this.linestream.push(chunk);
  }
  /**
   * flush any remaining input. this can be handy if the last line of an m3u8
   * manifest did not contain a trailing newline but the file has been
   * completely received.
   */
  ;

  _proto.end = function end() {
    // flush any buffered input
    this.linestream.push('\n');
    this.trigger('end');
  }
  /**
   * add an additional parser for non-standard tags
   *
   * @param {object}   options              a map of options for the added parser
   * @param {regexp}   options.expression   a regular expression to match the custom header
   * @param {string}   options.type         the type to register to the output
   * @param {function} [options.dataparser] function to parse the line into an object
   * @param {boolean}  [options.segment]    should tag data be attached to the segment object
   */
  ;

  _proto.addparser = function addparser(options) {
    this.parsestream.addparser(options);
  }
  /**
   * add a custom header mapper
   *
   * @param {object}   options
   * @param {regexp}   options.expression   a regular expression to match the custom header
   * @param {function} options.map          function to translate tag into a different tag
   */
  ;

  _proto.addtagmapper = function addtagmapper(options) {
    this.parsestream.addtagmapper(options);
  };

  return parser;
}(_videojs_vhs_utils_es_stream_js__webpack_imported_module_1__[/* default */ "a"]);




/***/ }),

/***/ 195:
/***/ (function(module, exports, __webpack_require__) {

var getuint64 = __webpack_require__(322).getuint64;

var parsesidx = function(data) {
  var view = new dataview(data.buffer, data.byteoffset, data.bytelength),
      result = {
        version: data[0],
        flags: new uint8array(data.subarray(1, 4)),
        references: [],
        referenceid: view.getuint32(4),
        timescale: view.getuint32(8)
      },
    i = 12;

  if (result.version === 0) {
    result.earliestpresentationtime = view.getuint32(i);
    result.firstoffset = view.getuint32(i + 4);
    i += 8;
  } else {
    // read 64 bits
    result.earliestpresentationtime = getuint64(data.subarray(i));
    result.firstoffset = getuint64(data.subarray(i + 8));
    i += 16;
  }

  i += 2; // reserved

  var referencecount = view.getuint16(i);

  i += 2; // start of references

  for (; referencecount > 0; i += 12, referencecount--) {
    result.references.push({
      referencetype: (data[i] & 0x80) >>> 7,
      referencedsize: view.getuint32(i) & 0x7fffffff,
      subsegmentduration: view.getuint32(i + 4),
      startswithsap: !!(data[i + 8] & 0x80),
      saptype: (data[i + 8] & 0x70) >>> 4,
      sapdeltatime: view.getuint32(i + 8) & 0x0fffffff
    });
  }

  return result;
};


module.exports = parsesidx;


/***/ }),

/***/ 315:
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* webpack var injection */(function(global) {/*!
 * the buffer module from node.js, for the browser.
 *
 * @author   feross aboukhadijeh <http://feross.org>
 * @license  mit
 */
/* eslint-disable no-proto */



var base64 = __webpack_require__(316)
var ieee754 = __webpack_require__(317)
var isarray = __webpack_require__(318)

exports.buffer = buffer
exports.slowbuffer = slowbuffer
exports.inspect_max_bytes = 50

/**
 * if `buffer.typed_array_support`:
 *   === true    use uint8array implementation (fastest)
 *   === false   use object implementation (most compatible, even ie6)
 *
 * browsers that support typed arrays are ie 10+, firefox 4+, chrome 7+, safari 5.1+,
 * opera 11.6+, ios 4.2+.
 *
 * due to various browser bugs, sometimes the object implementation will be used even
 * when the browser supports typed arrays.
 *
 * note:
 *
 *   - firefox 4-29 lacks support for adding new properties to `uint8array` instances,
 *     see: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 *
 *   - chrome 9-10 is missing the `typedarray.prototype.subarray` function.
 *
 *   - ie10 has a broken `typedarray.prototype.subarray` function which returns arrays of
 *     incorrect length in some situations.

 * we detect these buggy browsers and set `buffer.typed_array_support` to `false` so they
 * get the object implementation, which is slower but behaves correctly.
 */
buffer.typed_array_support = global.typed_array_support !== undefined
  ? global.typed_array_support
  : typedarraysupport()

/*
 * export kmaxlength after typed array support is determined.
 */
exports.kmaxlength = kmaxlength()

function typedarraysupport () {
  try {
    var arr = new uint8array(1)
    arr.__proto__ = {__proto__: uint8array.prototype, foo: function () { return 42 }}
    return arr.foo() === 42 && // typed array instances can be augmented
        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
        arr.subarray(1, 1).bytelength === 0 // ie10 has broken `subarray`
  } catch (e) {
    return false
  }
}

function kmaxlength () {
  return buffer.typed_array_support
    ? 0x7fffffff
    : 0x3fffffff
}

function createbuffer (that, length) {
  if (kmaxlength() < length) {
    throw new rangeerror('invalid typed array length')
  }
  if (buffer.typed_array_support) {
    // return an augmented `uint8array` instance, for best performance
    that = new uint8array(length)
    that.__proto__ = buffer.prototype
  } else {
    // fallback: return an object instance of the buffer class
    if (that === null) {
      that = new buffer(length)
    }
    that.length = length
  }

  return that
}

/**
 * the buffer constructor returns instances of `uint8array` that have their
 * prototype changed to `buffer.prototype`. furthermore, `buffer` is a subclass of
 * `uint8array`, so the returned instances will have all the node `buffer` methods
 * and the `uint8array` methods. square bracket notation works as expected -- it
 * returns a single octet.
 *
 * the `uint8array` prototype remains unmodified.
 */

function buffer (arg, encodingoroffset, length) {
  if (!buffer.typed_array_support && !(this instanceof buffer)) {
    return new buffer(arg, encodingoroffset, length)
  }

  // common case.
  if (typeof arg === 'number') {
    if (typeof encodingoroffset === 'string') {
      throw new error(
        'if encoding is specified then the first argument must be a string'
      )
    }
    return allocunsafe(this, arg)
  }
  return from(this, arg, encodingoroffset, length)
}

buffer.poolsize = 8192 // not used by this implementation

// todo: legacy, not needed anymore. remove in next major version.
buffer._augment = function (arr) {
  arr.__proto__ = buffer.prototype
  return arr
}

function from (that, value, encodingoroffset, length) {
  if (typeof value === 'number') {
    throw new typeerror('"value" argument must not be a number')
  }

  if (typeof arraybuffer !== 'undefined' && value instanceof arraybuffer) {
    return fromarraybuffer(that, value, encodingoroffset, length)
  }

  if (typeof value === 'string') {
    return fromstring(that, value, encodingoroffset)
  }

  return fromobject(that, value)
}

/**
 * functionally equivalent to buffer(arg, encoding) but throws a typeerror
 * if value is a number.
 * buffer.from(str[, encoding])
 * buffer.from(array)
 * buffer.from(buffer)
 * buffer.from(arraybuffer[, byteoffset[, length]])
 **/
buffer.from = function (value, encodingoroffset, length) {
  return from(null, value, encodingoroffset, length)
}

if (buffer.typed_array_support) {
  buffer.prototype.__proto__ = uint8array.prototype
  buffer.__proto__ = uint8array
  if (typeof symbol !== 'undefined' && symbol.species &&
      buffer[symbol.species] === buffer) {
    // fix subarray() in es2016. see: https://github.com/feross/buffer/pull/97
    object.defineproperty(buffer, symbol.species, {
      value: null,
      configurable: true
    })
  }
}

function assertsize (size) {
  if (typeof size !== 'number') {
    throw new typeerror('"size" argument must be a number')
  } else if (size < 0) {
    throw new rangeerror('"size" argument must not be negative')
  }
}

function alloc (that, size, fill, encoding) {
  assertsize(size)
  if (size <= 0) {
    return createbuffer(that, size)
  }
  if (fill !== undefined) {
    // only pay attention to encoding if it's a string. this
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string'
      ? createbuffer(that, size).fill(fill, encoding)
      : createbuffer(that, size).fill(fill)
  }
  return createbuffer(that, size)
}

/**
 * creates a new filled buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
buffer.alloc = function (size, fill, encoding) {
  return alloc(null, size, fill, encoding)
}

function allocunsafe (that, size) {
  assertsize(size)
  that = createbuffer(that, size < 0 ? 0 : checked(size) | 0)
  if (!buffer.typed_array_support) {
    for (var i = 0; i < size; ++i) {
      that[i] = 0
    }
  }
  return that
}

/**
 * equivalent to buffer(num), by default creates a non-zero-filled buffer instance.
 * */
buffer.allocunsafe = function (size) {
  return allocunsafe(null, size)
}
/**
 * equivalent to slowbuffer(num), by default creates a non-zero-filled buffer instance.
 */
buffer.allocunsafeslow = function (size) {
  return allocunsafe(null, size)
}

function fromstring (that, string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

  if (!buffer.isencoding(encoding)) {
    throw new typeerror('"encoding" must be a valid string encoding')
  }

  var length = bytelength(string, encoding) | 0
  that = createbuffer(that, length)

  var actual = that.write(string, encoding)

  if (actual !== length) {
    // writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    that = that.slice(0, actual)
  }

  return that
}

function fromarraylike (that, array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0
  that = createbuffer(that, length)
  for (var i = 0; i < length; i += 1) {
    that[i] = array[i] & 255
  }
  return that
}

function fromarraybuffer (that, array, byteoffset, length) {
  array.bytelength // this throws if `array` is not a valid arraybuffer

  if (byteoffset < 0 || array.bytelength < byteoffset) {
    throw new rangeerror('\'offset\' is out of bounds')
  }

  if (array.bytelength < byteoffset + (length || 0)) {
    throw new rangeerror('\'length\' is out of bounds')
  }

  if (byteoffset === undefined && length === undefined) {
    array = new uint8array(array)
  } else if (length === undefined) {
    array = new uint8array(array, byteoffset)
  } else {
    array = new uint8array(array, byteoffset, length)
  }

  if (buffer.typed_array_support) {
    // return an augmented `uint8array` instance, for best performance
    that = array
    that.__proto__ = buffer.prototype
  } else {
    // fallback: return an object instance of the buffer class
    that = fromarraylike(that, array)
  }
  return that
}

function fromobject (that, obj) {
  if (buffer.isbuffer(obj)) {
    var len = checked(obj.length) | 0
    that = createbuffer(that, len)

    if (that.length === 0) {
      return that
    }

    obj.copy(that, 0, 0, len)
    return that
  }

  if (obj) {
    if ((typeof arraybuffer !== 'undefined' &&
        obj.buffer instanceof arraybuffer) || 'length' in obj) {
      if (typeof obj.length !== 'number' || isnan(obj.length)) {
        return createbuffer(that, 0)
      }
      return fromarraylike(that, obj)
    }

    if (obj.type === 'buffer' && isarray(obj.data)) {
      return fromarraylike(that, obj.data)
    }
  }

  throw new typeerror('first argument must be a string, buffer, arraybuffer, array, or array-like object.')
}

function checked (length) {
  // note: cannot use `length < kmaxlength()` here because that fails when
  // length is nan (which is otherwise coerced to zero.)
  if (length >= kmaxlength()) {
    throw new rangeerror('attempt to allocate buffer larger than maximum ' +
                         'size: 0x' + kmaxlength().tostring(16) + ' bytes')
  }
  return length | 0
}

function slowbuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return buffer.alloc(+length)
}

buffer.isbuffer = function isbuffer (b) {
  return !!(b != null && b._isbuffer)
}

buffer.compare = function compare (a, b) {
  if (!buffer.isbuffer(a) || !buffer.isbuffer(b)) {
    throw new typeerror('arguments must be buffers')
  }

  if (a === b) return 0

  var x = a.length
  var y = b.length

  for (var i = 0, len = math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

buffer.isencoding = function isencoding (encoding) {
  switch (string(encoding).tolowercase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

buffer.concat = function concat (list, length) {
  if (!isarray(list)) {
    throw new typeerror('"list" argument must be an array of buffers')
  }

  if (list.length === 0) {
    return buffer.alloc(0)
  }

  var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  var buffer = buffer.allocunsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (!buffer.isbuffer(buf)) {
      throw new typeerror('"list" argument must be an array of buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

function bytelength (string, encoding) {
  if (buffer.isbuffer(string)) {
    return string.length
  }
  if (typeof arraybuffer !== 'undefined' && typeof arraybuffer.isview === 'function' &&
      (arraybuffer.isview(string) || string instanceof arraybuffer)) {
    return string.bytelength
  }
  if (typeof string !== 'string') {
    string = '' + string
  }

  var len = string.length
  if (len === 0) return 0

  // use a for loop to avoid recursion
  var loweredcase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8tobytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64tobytes(string).length
      default:
        if (loweredcase) return utf8tobytes(string).length // assume utf8
        encoding = ('' + encoding).tolowercase()
        loweredcase = true
    }
  }
}
buffer.bytelength = bytelength

function slowtostring (encoding, start, end) {
  var loweredcase = false

  // no need to verify that "this.length <= max_uint32" since it's a read-only
  // property of a typed array.

  // this behaves neither like string nor uint8array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ecma-262 6th edition,
  // section 13.3.3.7 runtime semantics: keyedbindinginitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // return early if start > this.length. done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

  if (end === undefined || end > this.length) {
    end = this.length
  }

  if (end <= 0) {
    return ''
  }

  // force coersion to uint32. this will also coerce falsey/nan values to 0.
  end >>>= 0
  start >>>= 0

  if (end <= start) {
    return ''
  }

  if (!encoding) encoding = 'utf8'

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexslice(this, start, end)

      case 'utf8':
      case 'utf-8':
        return utf8slice(this, start, end)

      case 'ascii':
        return asciislice(this, start, end)

      case 'latin1':
      case 'binary':
        return latin1slice(this, start, end)

      case 'base64':
        return base64slice(this, start, end)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leslice(this, start, end)

      default:
        if (loweredcase) throw new typeerror('unknown encoding: ' + encoding)
        encoding = (encoding + '').tolowercase()
        loweredcase = true
    }
  }
}

// the property is used by `buffer.isbuffer` and `is-buffer` (in safari 5-7) to detect
// buffer instances.
buffer.prototype._isbuffer = true

function swap (b, n, m) {
  var i = b[n]
  b[n] = b[m]
  b[m] = i
}

buffer.prototype.swap16 = function swap16 () {
  var len = this.length
  if (len % 2 !== 0) {
    throw new rangeerror('buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

buffer.prototype.swap32 = function swap32 () {
  var len = this.length
  if (len % 4 !== 0) {
    throw new rangeerror('buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

buffer.prototype.swap64 = function swap64 () {
  var len = this.length
  if (len % 8 !== 0) {
    throw new rangeerror('buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

buffer.prototype.tostring = function tostring () {
  var length = this.length | 0
  if (length === 0) return ''
  if (arguments.length === 0) return utf8slice(this, 0, length)
  return slowtostring.apply(this, arguments)
}

buffer.prototype.equals = function equals (b) {
  if (!buffer.isbuffer(b)) throw new typeerror('argument must be a buffer')
  if (this === b) return true
  return buffer.compare(this, b) === 0
}

buffer.prototype.inspect = function inspect () {
  var str = ''
  var max = exports.inspect_max_bytes
  if (this.length > 0) {
    str = this.tostring('hex', 0, max).match(/.{2}/g).join(' ')
    if (this.length > max) str += ' ... '
  }
  return '<buffer ' + str + '>'
}

buffer.prototype.compare = function compare (target, start, end, thisstart, thisend) {
  if (!buffer.isbuffer(target)) {
    throw new typeerror('argument must be a buffer')
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisstart === undefined) {
    thisstart = 0
  }
  if (thisend === undefined) {
    thisend = this.length
  }

  if (start < 0 || end > target.length || thisstart < 0 || thisend > this.length) {
    throw new rangeerror('out of range index')
  }

  if (thisstart >= thisend && start >= end) {
    return 0
  }
  if (thisstart >= thisend) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisstart >>>= 0
  thisend >>>= 0

  if (this === target) return 0

  var x = thisend - thisstart
  var y = end - start
  var len = math.min(x, y)

  var thiscopy = this.slice(thisstart, thisend)
  var targetcopy = target.slice(start, end)

  for (var i = 0; i < len; ++i) {
    if (thiscopy[i] !== targetcopy[i]) {
      x = thiscopy[i]
      y = targetcopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

// finds either the first index of `val` in `buffer` at offset >= `byteoffset`,
// or the last index of `val` in `buffer` at offset <= `byteoffset`.
//
// arguments:
// - buffer - a buffer to search
// - val - a string, buffer, or number
// - byteoffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexof, false for lastindexof
function bidirectionalindexof (buffer, val, byteoffset, encoding, dir) {
  // empty buffer means no match
  if (buffer.length === 0) return -1

  // normalize byteoffset
  if (typeof byteoffset === 'string') {
    encoding = byteoffset
    byteoffset = 0
  } else if (byteoffset > 0x7fffffff) {
    byteoffset = 0x7fffffff
  } else if (byteoffset < -0x80000000) {
    byteoffset = -0x80000000
  }
  byteoffset = +byteoffset  // coerce to number.
  if (isnan(byteoffset)) {
    // byteoffset: it it's undefined, null, nan, "foo", etc, search whole buffer
    byteoffset = dir ? 0 : (buffer.length - 1)
  }

  // normalize byteoffset: negative offsets start from the end of the buffer
  if (byteoffset < 0) byteoffset = buffer.length + byteoffset
  if (byteoffset >= buffer.length) {
    if (dir) return -1
    else byteoffset = buffer.length - 1
  } else if (byteoffset < 0) {
    if (dir) byteoffset = 0
    else return -1
  }

  // normalize val
  if (typeof val === 'string') {
    val = buffer.from(val, encoding)
  }

  // finally, search either indexof (if dir is true) or lastindexof
  if (buffer.isbuffer(val)) {
    // special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayindexof(buffer, val, byteoffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xff // search for a byte value [0-255]
    if (buffer.typed_array_support &&
        typeof uint8array.prototype.indexof === 'function') {
      if (dir) {
        return uint8array.prototype.indexof.call(buffer, val, byteoffset)
      } else {
        return uint8array.prototype.lastindexof.call(buffer, val, byteoffset)
      }
    }
    return arrayindexof(buffer, [ val ], byteoffset, encoding, dir)
  }

  throw new typeerror('val must be string, number or buffer')
}

function arrayindexof (arr, val, byteoffset, encoding, dir) {
  var indexsize = 1
  var arrlength = arr.length
  var vallength = val.length

  if (encoding !== undefined) {
    encoding = string(encoding).tolowercase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexsize = 2
      arrlength /= 2
      vallength /= 2
      byteoffset /= 2
    }
  }

  function read (buf, i) {
    if (indexsize === 1) {
      return buf[i]
    } else {
      return buf.readuint16be(i * indexsize)
    }
  }

  var i
  if (dir) {
    var foundindex = -1
    for (i = byteoffset; i < arrlength; i++) {
      if (read(arr, i) === read(val, foundindex === -1 ? 0 : i - foundindex)) {
        if (foundindex === -1) foundindex = i
        if (i - foundindex + 1 === vallength) return foundindex * indexsize
      } else {
        if (foundindex !== -1) i -= i - foundindex
        foundindex = -1
      }
    }
  } else {
    if (byteoffset + vallength > arrlength) byteoffset = arrlength - vallength
    for (i = byteoffset; i >= 0; i--) {
      var found = true
      for (var j = 0; j < vallength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

  return -1
}

buffer.prototype.includes = function includes (val, byteoffset, encoding) {
  return this.indexof(val, byteoffset, encoding) !== -1
}

buffer.prototype.indexof = function indexof (val, byteoffset, encoding) {
  return bidirectionalindexof(this, val, byteoffset, encoding, true)
}

buffer.prototype.lastindexof = function lastindexof (val, byteoffset, encoding) {
  return bidirectionalindexof(this, val, byteoffset, encoding, false)
}

function hexwrite (buf, string, offset, length) {
  offset = number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  // must be an even number of digits
  var strlen = string.length
  if (strlen % 2 !== 0) throw new typeerror('invalid hex string')

  if (length > strlen / 2) {
    length = strlen / 2
  }
  for (var i = 0; i < length; ++i) {
    var parsed = parseint(string.substr(i * 2, 2), 16)
    if (isnan(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8write (buf, string, offset, length) {
  return blitbuffer(utf8tobytes(string, buf.length - offset), buf, offset, length)
}

function asciiwrite (buf, string, offset, length) {
  return blitbuffer(asciitobytes(string), buf, offset, length)
}

function latin1write (buf, string, offset, length) {
  return asciiwrite(buf, string, offset, length)
}

function base64write (buf, string, offset, length) {
  return blitbuffer(base64tobytes(string), buf, offset, length)
}

function ucs2write (buf, string, offset, length) {
  return blitbuffer(utf16letobytes(string, buf.length - offset), buf, offset, length)
}

buffer.prototype.write = function write (string, offset, length, encoding) {
  // buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // buffer#write(string, offset[, length][, encoding])
  } else if (isfinite(offset)) {
    offset = offset | 0
    if (isfinite(length)) {
      length = length | 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  // legacy write(string, encoding, offset, length) - remove in v0.13
  } else {
    throw new error(
      'buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new rangeerror('attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  var loweredcase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexwrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8write(this, string, offset, length)

      case 'ascii':
        return asciiwrite(this, string, offset, length)

      case 'latin1':
      case 'binary':
        return latin1write(this, string, offset, length)

      case 'base64':
        // warning: maxlength not taken into account in base64write
        return base64write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2write(this, string, offset, length)

      default:
        if (loweredcase) throw new typeerror('unknown encoding: ' + encoding)
        encoding = ('' + encoding).tolowercase()
        loweredcase = true
    }
  }
}

buffer.prototype.tojson = function tojson () {
  return {
    type: 'buffer',
    data: array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.frombytearray(buf)
  } else {
    return base64.frombytearray(buf.slice(start, end))
  }
}

function utf8slice (buf, start, end) {
  end = math.min(buf.length, end)
  var res = []

  var i = start
  while (i < end) {
    var firstbyte = buf[i]
    var codepoint = null
    var bytespersequence = (firstbyte > 0xef) ? 4
      : (firstbyte > 0xdf) ? 3
      : (firstbyte > 0xbf) ? 2
      : 1

    if (i + bytespersequence <= end) {
      var secondbyte, thirdbyte, fourthbyte, tempcodepoint

      switch (bytespersequence) {
        case 1:
          if (firstbyte < 0x80) {
            codepoint = firstbyte
          }
          break
        case 2:
          secondbyte = buf[i + 1]
          if ((secondbyte & 0xc0) === 0x80) {
            tempcodepoint = (firstbyte & 0x1f) << 0x6 | (secondbyte & 0x3f)
            if (tempcodepoint > 0x7f) {
              codepoint = tempcodepoint
            }
          }
          break
        case 3:
          secondbyte = buf[i + 1]
          thirdbyte = buf[i + 2]
          if ((secondbyte & 0xc0) === 0x80 && (thirdbyte & 0xc0) === 0x80) {
            tempcodepoint = (firstbyte & 0xf) << 0xc | (secondbyte & 0x3f) << 0x6 | (thirdbyte & 0x3f)
            if (tempcodepoint > 0x7ff && (tempcodepoint < 0xd800 || tempcodepoint > 0xdfff)) {
              codepoint = tempcodepoint
            }
          }
          break
        case 4:
          secondbyte = buf[i + 1]
          thirdbyte = buf[i + 2]
          fourthbyte = buf[i + 3]
          if ((secondbyte & 0xc0) === 0x80 && (thirdbyte & 0xc0) === 0x80 && (fourthbyte & 0xc0) === 0x80) {
            tempcodepoint = (firstbyte & 0xf) << 0x12 | (secondbyte & 0x3f) << 0xc | (thirdbyte & 0x3f) << 0x6 | (fourthbyte & 0x3f)
            if (tempcodepoint > 0xffff && tempcodepoint < 0x110000) {
              codepoint = tempcodepoint
            }
          }
      }
    }

    if (codepoint === null) {
      // we did not generate a valid codepoint so insert a
      // replacement char (u+fffd) and advance only 1 byte
      codepoint = 0xfffd
      bytespersequence = 1
    } else if (codepoint > 0xffff) {
      // encode to utf16 (surrogate pair dance)
      codepoint -= 0x10000
      res.push(codepoint >>> 10 & 0x3ff | 0xd800)
      codepoint = 0xdc00 | codepoint & 0x3ff
    }

    res.push(codepoint)
    i += bytespersequence
  }

  return decodecodepointsarray(res)
}

// based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is chrome, with 0x10000 args.
// we go 1 magnitude less, for safety
var max_arguments_length = 0x1000

function decodecodepointsarray (codepoints) {
  var len = codepoints.length
  if (len <= max_arguments_length) {
    return string.fromcharcode.apply(string, codepoints) // avoid extra slice()
  }

  // decode in chunks to avoid "call stack size exceeded".
  var res = ''
  var i = 0
  while (i < len) {
    res += string.fromcharcode.apply(
      string,
      codepoints.slice(i, i += max_arguments_length)
    )
  }
  return res
}

function asciislice (buf, start, end) {
  var ret = ''
  end = math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += string.fromcharcode(buf[i] & 0x7f)
  }
  return ret
}

function latin1slice (buf, start, end) {
  var ret = ''
  end = math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += string.fromcharcode(buf[i])
  }
  return ret
}

function hexslice (buf, start, end) {
  var len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  var out = ''
  for (var i = start; i < end; ++i) {
    out += tohex(buf[i])
  }
  return out
}

function utf16leslice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += string.fromcharcode(bytes[i] + bytes[i + 1] * 256)
  }
  return res
}

buffer.prototype.slice = function slice (start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  var newbuf
  if (buffer.typed_array_support) {
    newbuf = this.subarray(start, end)
    newbuf.__proto__ = buffer.prototype
  } else {
    var slicelen = end - start
    newbuf = new buffer(slicelen, undefined)
    for (var i = 0; i < slicelen; ++i) {
      newbuf[i] = this[i + start]
    }
  }

  return newbuf
}

/*
 * need to make sure that buffer isn't trying to write out of bounds.
 */
function checkoffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new rangeerror('offset is not uint')
  if (offset + ext > length) throw new rangeerror('trying to access beyond buffer length')
}

buffer.prototype.readuintle = function readuintle (offset, bytelength, noassert) {
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) checkoffset(offset, bytelength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < bytelength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

buffer.prototype.readuintbe = function readuintbe (offset, bytelength, noassert) {
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) {
    checkoffset(offset, bytelength, this.length)
  }

  var val = this[offset + --bytelength]
  var mul = 1
  while (bytelength > 0 && (mul *= 0x100)) {
    val += this[offset + --bytelength] * mul
  }

  return val
}

buffer.prototype.readuint8 = function readuint8 (offset, noassert) {
  if (!noassert) checkoffset(offset, 1, this.length)
  return this[offset]
}

buffer.prototype.readuint16le = function readuint16le (offset, noassert) {
  if (!noassert) checkoffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

buffer.prototype.readuint16be = function readuint16be (offset, noassert) {
  if (!noassert) checkoffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

buffer.prototype.readuint32le = function readuint32le (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

buffer.prototype.readuint32be = function readuint32be (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

buffer.prototype.readintle = function readintle (offset, bytelength, noassert) {
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) checkoffset(offset, bytelength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < bytelength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= math.pow(2, 8 * bytelength)

  return val
}

buffer.prototype.readintbe = function readintbe (offset, bytelength, noassert) {
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) checkoffset(offset, bytelength, this.length)

  var i = bytelength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= math.pow(2, 8 * bytelength)

  return val
}

buffer.prototype.readint8 = function readint8 (offset, noassert) {
  if (!noassert) checkoffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

buffer.prototype.readint16le = function readint16le (offset, noassert) {
  if (!noassert) checkoffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xffff0000 : val
}

buffer.prototype.readint16be = function readint16be (offset, noassert) {
  if (!noassert) checkoffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xffff0000 : val
}

buffer.prototype.readint32le = function readint32le (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

buffer.prototype.readint32be = function readint32be (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

buffer.prototype.readfloatle = function readfloatle (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

buffer.prototype.readfloatbe = function readfloatbe (offset, noassert) {
  if (!noassert) checkoffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

buffer.prototype.readdoublele = function readdoublele (offset, noassert) {
  if (!noassert) checkoffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

buffer.prototype.readdoublebe = function readdoublebe (offset, noassert) {
  if (!noassert) checkoffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkint (buf, value, offset, ext, max, min) {
  if (!buffer.isbuffer(buf)) throw new typeerror('"buffer" argument must be a buffer instance')
  if (value > max || value < min) throw new rangeerror('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new rangeerror('index out of range')
}

buffer.prototype.writeuintle = function writeuintle (value, offset, bytelength, noassert) {
  value = +value
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) {
    var maxbytes = math.pow(2, 8 * bytelength) - 1
    checkint(this, value, offset, bytelength, maxbytes, 0)
  }

  var mul = 1
  var i = 0
  this[offset] = value & 0xff
  while (++i < bytelength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xff
  }

  return offset + bytelength
}

buffer.prototype.writeuintbe = function writeuintbe (value, offset, bytelength, noassert) {
  value = +value
  offset = offset | 0
  bytelength = bytelength | 0
  if (!noassert) {
    var maxbytes = math.pow(2, 8 * bytelength) - 1
    checkint(this, value, offset, bytelength, maxbytes, 0)
  }

  var i = bytelength - 1
  var mul = 1
  this[offset + i] = value & 0xff
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xff
  }

  return offset + bytelength
}

buffer.prototype.writeuint8 = function writeuint8 (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 1, 0xff, 0)
  if (!buffer.typed_array_support) value = math.floor(value)
  this[offset] = (value & 0xff)
  return offset + 1
}

function objectwriteuint16 (buf, value, offset, littleendian) {
  if (value < 0) value = 0xffff + value + 1
  for (var i = 0, j = math.min(buf.length - offset, 2); i < j; ++i) {
    buf[offset + i] = (value & (0xff << (8 * (littleendian ? i : 1 - i)))) >>>
      (littleendian ? i : 1 - i) * 8
  }
}

buffer.prototype.writeuint16le = function writeuint16le (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 2, 0xffff, 0)
  if (buffer.typed_array_support) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectwriteuint16(this, value, offset, true)
  }
  return offset + 2
}

buffer.prototype.writeuint16be = function writeuint16be (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 2, 0xffff, 0)
  if (buffer.typed_array_support) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectwriteuint16(this, value, offset, false)
  }
  return offset + 2
}

function objectwriteuint32 (buf, value, offset, littleendian) {
  if (value < 0) value = 0xffffffff + value + 1
  for (var i = 0, j = math.min(buf.length - offset, 4); i < j; ++i) {
    buf[offset + i] = (value >>> (littleendian ? i : 3 - i) * 8) & 0xff
  }
}

buffer.prototype.writeuint32le = function writeuint32le (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 4, 0xffffffff, 0)
  if (buffer.typed_array_support) {
    this[offset + 3] = (value >>> 24)
    this[offset + 2] = (value >>> 16)
    this[offset + 1] = (value >>> 8)
    this[offset] = (value & 0xff)
  } else {
    objectwriteuint32(this, value, offset, true)
  }
  return offset + 4
}

buffer.prototype.writeuint32be = function writeuint32be (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 4, 0xffffffff, 0)
  if (buffer.typed_array_support) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectwriteuint32(this, value, offset, false)
  }
  return offset + 4
}

buffer.prototype.writeintle = function writeintle (value, offset, bytelength, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) {
    var limit = math.pow(2, 8 * bytelength - 1)

    checkint(this, value, offset, bytelength, limit - 1, -limit)
  }

  var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xff
  while (++i < bytelength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xff
  }

  return offset + bytelength
}

buffer.prototype.writeintbe = function writeintbe (value, offset, bytelength, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) {
    var limit = math.pow(2, 8 * bytelength - 1)

    checkint(this, value, offset, bytelength, limit - 1, -limit)
  }

  var i = bytelength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xff
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xff
  }

  return offset + bytelength
}

buffer.prototype.writeint8 = function writeint8 (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 1, 0x7f, -0x80)
  if (!buffer.typed_array_support) value = math.floor(value)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

buffer.prototype.writeint16le = function writeint16le (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 2, 0x7fff, -0x8000)
  if (buffer.typed_array_support) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectwriteuint16(this, value, offset, true)
  }
  return offset + 2
}

buffer.prototype.writeint16be = function writeint16be (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 2, 0x7fff, -0x8000)
  if (buffer.typed_array_support) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectwriteuint16(this, value, offset, false)
  }
  return offset + 2
}

buffer.prototype.writeint32le = function writeint32le (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (buffer.typed_array_support) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    this[offset + 2] = (value >>> 16)
    this[offset + 3] = (value >>> 24)
  } else {
    objectwriteuint32(this, value, offset, true)
  }
  return offset + 4
}

buffer.prototype.writeint32be = function writeint32be (value, offset, noassert) {
  value = +value
  offset = offset | 0
  if (!noassert) checkint(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  if (buffer.typed_array_support) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectwriteuint32(this, value, offset, false)
  }
  return offset + 4
}

function checkieee754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new rangeerror('index out of range')
  if (offset < 0) throw new rangeerror('index out of range')
}

function writefloat (buf, value, offset, littleendian, noassert) {
  if (!noassert) {
    checkieee754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleendian, 23, 4)
  return offset + 4
}

buffer.prototype.writefloatle = function writefloatle (value, offset, noassert) {
  return writefloat(this, value, offset, true, noassert)
}

buffer.prototype.writefloatbe = function writefloatbe (value, offset, noassert) {
  return writefloat(this, value, offset, false, noassert)
}

function writedouble (buf, value, offset, littleendian, noassert) {
  if (!noassert) {
    checkieee754(buf, value, offset, 8, 1.7976931348623157e+308, -1.7976931348623157e+308)
  }
  ieee754.write(buf, value, offset, littleendian, 52, 8)
  return offset + 8
}

buffer.prototype.writedoublele = function writedoublele (value, offset, noassert) {
  return writedouble(this, value, offset, true, noassert)
}

buffer.prototype.writedoublebe = function writedoublebe (value, offset, noassert) {
  return writedouble(this, value, offset, false, noassert)
}

// copy(targetbuffer, targetstart=0, sourcestart=0, sourceend=buffer.length)
buffer.prototype.copy = function copy (target, targetstart, start, end) {
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetstart >= target.length) targetstart = target.length
  if (!targetstart) targetstart = 0
  if (end > 0 && end < start) end = start

  // copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // fatal error conditions
  if (targetstart < 0) {
    throw new rangeerror('targetstart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new rangeerror('sourcestart out of bounds')
  if (end < 0) throw new rangeerror('sourceend out of bounds')

  // are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetstart < end - start) {
    end = target.length - targetstart + start
  }

  var len = end - start
  var i

  if (this === target && start < targetstart && targetstart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetstart] = this[i + start]
    }
  } else if (len < 1000 || !buffer.typed_array_support) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetstart] = this[i + start]
    }
  } else {
    uint8array.prototype.set.call(
      target,
      this.subarray(start, start + len),
      targetstart
    )
  }

  return len
}

// usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
buffer.prototype.fill = function fill (val, start, end, encoding) {
  // handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (val.length === 1) {
      var code = val.charcodeat(0)
      if (code < 256) {
        val = code
      }
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new typeerror('encoding must be a string')
    }
    if (typeof encoding === 'string' && !buffer.isencoding(encoding)) {
      throw new typeerror('unknown encoding: ' + encoding)
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

  // invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new rangeerror('out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = buffer.isbuffer(val)
      ? val
      : utf8tobytes(new buffer(val, encoding).tostring())
    var len = bytes.length
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

// helper functions
// ================

var invalid_base64_re = /[^+\/0-9a-za-z-_]/g

function base64clean (str) {
  // node strips out invalid characters like \n and \t from the string, base64-js does not
  str = stringtrim(str).replace(invalid_base64_re, '')
  // node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function stringtrim (str) {
  if (str.trim) return str.trim()
  return str.replace(/^\s+|\s+$/g, '')
}

function tohex (n) {
  if (n < 16) return '0' + n.tostring(16)
  return n.tostring(16)
}

function utf8tobytes (string, units) {
  units = units || infinity
  var codepoint
  var length = string.length
  var leadsurrogate = null
  var bytes = []

  for (var i = 0; i < length; ++i) {
    codepoint = string.charcodeat(i)

    // is surrogate component
    if (codepoint > 0xd7ff && codepoint < 0xe000) {
      // last char was a lead
      if (!leadsurrogate) {
        // no lead yet
        if (codepoint > 0xdbff) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
          continue
        }

        // valid lead
        leadsurrogate = codepoint

        continue
      }

      // 2 leads in a row
      if (codepoint < 0xdc00) {
        if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
        leadsurrogate = codepoint
        continue
      }

      // valid surrogate pair
      codepoint = (leadsurrogate - 0xd800 << 10 | codepoint - 0xdc00) + 0x10000
    } else if (leadsurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd)
    }

    leadsurrogate = null

    // encode utf8
    if (codepoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codepoint)
    } else if (codepoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codepoint >> 0x6 | 0xc0,
        codepoint & 0x3f | 0x80
      )
    } else if (codepoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codepoint >> 0xc | 0xe0,
        codepoint >> 0x6 & 0x3f | 0x80,
        codepoint & 0x3f | 0x80
      )
    } else if (codepoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codepoint >> 0x12 | 0xf0,
        codepoint >> 0xc & 0x3f | 0x80,
        codepoint >> 0x6 & 0x3f | 0x80,
        codepoint & 0x3f | 0x80
      )
    } else {
      throw new error('invalid code point')
    }
  }

  return bytes
}

function asciitobytes (str) {
  var bytearray = []
  for (var i = 0; i < str.length; ++i) {
    // node's code seems to be doing this and not & 0x7f..
    bytearray.push(str.charcodeat(i) & 0xff)
  }
  return bytearray
}

function utf16letobytes (str, units) {
  var c, hi, lo
  var bytearray = []
  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

    c = str.charcodeat(i)
    hi = c >> 8
    lo = c % 256
    bytearray.push(lo)
    bytearray.push(hi)
  }

  return bytearray
}

function base64tobytes (str) {
  return base64.tobytearray(base64clean(str))
}

function blitbuffer (src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

function isnan (val) {
  return val !== val // eslint-disable-line no-self-compare
}

/* webpack var injection */}.call(this, __webpack_require__(15)))

/***/ }),

/***/ 322:
/***/ (function(module, exports) {

var max_uint32 = math.pow(2, 32);

var getuint64 = function(uint8) {
  var dv = new dataview(uint8.buffer, uint8.byteoffset, uint8.bytelength);
  var value;

  if (dv.getbiguint64) {
    value = dv.getbiguint64(0);

    if (value < number.max_safe_integer) {
      return number(value);
    }

    return value;
  }

  return (dv.getuint32(0) * max_uint32) + dv.getuint32(4);
};

module.exports = {
  getuint64: getuint64,
  max_uint32: max_uint32
};


/***/ }),

/***/ 325:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var getsidechannel = __webpack_require__(326);
var utils = __webpack_require__(178);
var formats = __webpack_require__(110);
var has = object.prototype.hasownproperty;

var arrayprefixgenerators = {
    brackets: function brackets(prefix) {
        return prefix + '[]';
    },
    comma: 'comma',
    indices: function indices(prefix, key) {
        return prefix + '[' + key + ']';
    },
    repeat: function repeat(prefix) {
        return prefix;
    }
};

var isarray = array.isarray;
var split = string.prototype.split;
var push = array.prototype.push;
var pushtoarray = function (arr, valueorarray) {
    push.apply(arr, isarray(valueorarray) ? valueorarray : [valueorarray]);
};

var toiso = date.prototype.toisostring;

var defaultformat = formats['default'];
var defaults = {
    addqueryprefix: false,
    allowdots: false,
    charset: 'utf-8',
    charsetsentinel: false,
    delimiter: '&',
    encode: true,
    encoder: utils.encode,
    encodevaluesonly: false,
    format: defaultformat,
    formatter: formats.formatters[defaultformat],
    // deprecated
    indices: false,
    serializedate: function serializedate(date) {
        return toiso.call(date);
    },
    skipnulls: false,
    strictnullhandling: false
};

var isnonnullishprimitive = function isnonnullishprimitive(v) {
    return typeof v === 'string'
        || typeof v === 'number'
        || typeof v === 'boolean'
        || typeof v === 'symbol'
        || typeof v === 'bigint';
};

var sentinel = {};

var stringify = function stringify(
    object,
    prefix,
    generatearrayprefix,
    commaroundtrip,
    strictnullhandling,
    skipnulls,
    encoder,
    filter,
    sort,
    allowdots,
    serializedate,
    format,
    formatter,
    encodevaluesonly,
    charset,
    sidechannel
) {
    var obj = object;

    var tmpsc = sidechannel;
    var step = 0;
    var findflag = false;
    while ((tmpsc = tmpsc.get(sentinel)) !== void undefined && !findflag) {
        // where object last appeared in the ref tree
        var pos = tmpsc.get(object);
        step += 1;
        if (typeof pos !== 'undefined') {
            if (pos === step) {
                throw new rangeerror('cyclic object value');
            } else {
                findflag = true; // break while
            }
        }
        if (typeof tmpsc.get(sentinel) === 'undefined') {
            step = 0;
        }
    }

    if (typeof filter === 'function') {
        obj = filter(prefix, obj);
    } else if (obj instanceof date) {
        obj = serializedate(obj);
    } else if (generatearrayprefix === 'comma' && isarray(obj)) {
        obj = utils.maybemap(obj, function (value) {
            if (value instanceof date) {
                return serializedate(value);
            }
            return value;
        });
    }

    if (obj === null) {
        if (strictnullhandling) {
            return encoder && !encodevaluesonly ? encoder(prefix, defaults.encoder, charset, 'key', format) : prefix;
        }

        obj = '';
    }

    if (isnonnullishprimitive(obj) || utils.isbuffer(obj)) {
        if (encoder) {
            var keyvalue = encodevaluesonly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);
            if (generatearrayprefix === 'comma' && encodevaluesonly) {
                var valuesarray = split.call(string(obj), ',');
                var valuesjoined = '';
                for (var i = 0; i < valuesarray.length; ++i) {
                    valuesjoined += (i === 0 ? '' : ',') + formatter(encoder(valuesarray[i], defaults.encoder, charset, 'value', format));
                }
                return [formatter(keyvalue) + (commaroundtrip && isarray(obj) && valuesarray.length === 1 ? '[]' : '') + '=' + valuesjoined];
            }
            return [formatter(keyvalue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];
        }
        return [formatter(prefix) + '=' + formatter(string(obj))];
    }

    var values = [];

    if (typeof obj === 'undefined') {
        return values;
    }

    var objkeys;
    if (generatearrayprefix === 'comma' && isarray(obj)) {
        // we need to join elements in
        objkeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
    } else if (isarray(filter)) {
        objkeys = filter;
    } else {
        var keys = object.keys(obj);
        objkeys = sort ? keys.sort(sort) : keys;
    }

    var adjustedprefix = commaroundtrip && isarray(obj) && obj.length === 1 ? prefix + '[]' : prefix;

    for (var j = 0; j < objkeys.length; ++j) {
        var key = objkeys[j];
        var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];

        if (skipnulls && value === null) {
            continue;
        }

        var keyprefix = isarray(obj)
            ? typeof generatearrayprefix === 'function' ? generatearrayprefix(adjustedprefix, key) : adjustedprefix
            : adjustedprefix + (allowdots ? '.' + key : '[' + key + ']');

        sidechannel.set(object, step);
        var valuesidechannel = getsidechannel();
        valuesidechannel.set(sentinel, sidechannel);
        pushtoarray(values, stringify(
            value,
            keyprefix,
            generatearrayprefix,
            commaroundtrip,
            strictnullhandling,
            skipnulls,
            encoder,
            filter,
            sort,
            allowdots,
            serializedate,
            format,
            formatter,
            encodevaluesonly,
            charset,
            valuesidechannel
        ));
    }

    return values;
};

var normalizestringifyoptions = function normalizestringifyoptions(opts) {
    if (!opts) {
        return defaults;
    }

    if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
        throw new typeerror('encoder has to be a function.');
    }

    var charset = opts.charset || defaults.charset;
    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
        throw new typeerror('the charset option must be either utf-8, iso-8859-1, or undefined');
    }

    var format = formats['default'];
    if (typeof opts.format !== 'undefined') {
        if (!has.call(formats.formatters, opts.format)) {
            throw new typeerror('unknown format option provided.');
        }
        format = opts.format;
    }
    var formatter = formats.formatters[format];

    var filter = defaults.filter;
    if (typeof opts.filter === 'function' || isarray(opts.filter)) {
        filter = opts.filter;
    }

    return {
        addqueryprefix: typeof opts.addqueryprefix === 'boolean' ? opts.addqueryprefix : defaults.addqueryprefix,
        allowdots: typeof opts.allowdots === 'undefined' ? defaults.allowdots : !!opts.allowdots,
        charset: charset,
        charsetsentinel: typeof opts.charsetsentinel === 'boolean' ? opts.charsetsentinel : defaults.charsetsentinel,
        delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
        encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
        encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
        encodevaluesonly: typeof opts.encodevaluesonly === 'boolean' ? opts.encodevaluesonly : defaults.encodevaluesonly,
        filter: filter,
        format: format,
        formatter: formatter,
        serializedate: typeof opts.serializedate === 'function' ? opts.serializedate : defaults.serializedate,
        skipnulls: typeof opts.skipnulls === 'boolean' ? opts.skipnulls : defaults.skipnulls,
        sort: typeof opts.sort === 'function' ? opts.sort : null,
        strictnullhandling: typeof opts.strictnullhandling === 'boolean' ? opts.strictnullhandling : defaults.strictnullhandling
    };
};

module.exports = function (object, opts) {
    var obj = object;
    var options = normalizestringifyoptions(opts);

    var objkeys;
    var filter;

    if (typeof options.filter === 'function') {
        filter = options.filter;
        obj = filter('', obj);
    } else if (isarray(options.filter)) {
        filter = options.filter;
        objkeys = filter;
    }

    var keys = [];

    if (typeof obj !== 'object' || obj === null) {
        return '';
    }

    var arrayformat;
    if (opts && opts.arrayformat in arrayprefixgenerators) {
        arrayformat = opts.arrayformat;
    } else if (opts && 'indices' in opts) {
        arrayformat = opts.indices ? 'indices' : 'repeat';
    } else {
        arrayformat = 'indices';
    }

    var generatearrayprefix = arrayprefixgenerators[arrayformat];
    if (opts && 'commaroundtrip' in opts && typeof opts.commaroundtrip !== 'boolean') {
        throw new typeerror('`commaroundtrip` must be a boolean, or absent');
    }
    var commaroundtrip = generatearrayprefix === 'comma' && opts && opts.commaroundtrip;

    if (!objkeys) {
        objkeys = object.keys(obj);
    }

    if (options.sort) {
        objkeys.sort(options.sort);
    }

    var sidechannel = getsidechannel();
    for (var i = 0; i < objkeys.length; ++i) {
        var key = objkeys[i];

        if (options.skipnulls && obj[key] === null) {
            continue;
        }
        pushtoarray(keys, stringify(
            obj[key],
            key,
            generatearrayprefix,
            commaroundtrip,
            options.strictnullhandling,
            options.skipnulls,
            options.encode ? options.encoder : null,
            options.filter,
            options.sort,
            options.allowdots,
            options.serializedate,
            options.format,
            options.formatter,
            options.encodevaluesonly,
            options.charset,
            sidechannel
        ));
    }

    var joined = keys.join(options.delimiter);
    var prefix = options.addqueryprefix === true ? '?' : '';

    if (options.charsetsentinel) {
        if (options.charset === 'iso-8859-1') {
            // encodeuricomponent('&#10003;'), the "numeric entity" representation of a checkmark
            prefix += 'utf8=%26%2310003%3b&';
        } else {
            // encodeuricomponent('✓')
            prefix += 'utf8=%e2%9c%93&';
        }
    }

    return joined.length > 0 ? prefix + joined : '';
};


/***/ }),

/***/ 333:
/***/ (function(module, exports, __webpack_require__) {

var hasmap = typeof map === 'function' && map.prototype;
var mapsizedescriptor = object.getownpropertydescriptor && hasmap ? object.getownpropertydescriptor(map.prototype, 'size') : null;
var mapsize = hasmap && mapsizedescriptor && typeof mapsizedescriptor.get === 'function' ? mapsizedescriptor.get : null;
var mapforeach = hasmap && map.prototype.foreach;
var hasset = typeof set === 'function' && set.prototype;
var setsizedescriptor = object.getownpropertydescriptor && hasset ? object.getownpropertydescriptor(set.prototype, 'size') : null;
var setsize = hasset && setsizedescriptor && typeof setsizedescriptor.get === 'function' ? setsizedescriptor.get : null;
var setforeach = hasset && set.prototype.foreach;
var hasweakmap = typeof weakmap === 'function' && weakmap.prototype;
var weakmaphas = hasweakmap ? weakmap.prototype.has : null;
var hasweakset = typeof weakset === 'function' && weakset.prototype;
var weaksethas = hasweakset ? weakset.prototype.has : null;
var hasweakref = typeof weakref === 'function' && weakref.prototype;
var weakrefderef = hasweakref ? weakref.prototype.deref : null;
var booleanvalueof = boolean.prototype.valueof;
var objecttostring = object.prototype.tostring;
var functiontostring = function.prototype.tostring;
var $match = string.prototype.match;
var $slice = string.prototype.slice;
var $replace = string.prototype.replace;
var $touppercase = string.prototype.touppercase;
var $tolowercase = string.prototype.tolowercase;
var $test = regexp.prototype.test;
var $concat = array.prototype.concat;
var $join = array.prototype.join;
var $arrslice = array.prototype.slice;
var $floor = math.floor;
var bigintvalueof = typeof bigint === 'function' ? bigint.prototype.valueof : null;
var gops = object.getownpropertysymbols;
var symtostring = typeof symbol === 'function' && typeof symbol.iterator === 'symbol' ? symbol.prototype.tostring : null;
var hasshammedsymbols = typeof symbol === 'function' && typeof symbol.iterator === 'object';
// ie, `has-tostringtag/shams
var tostringtag = typeof symbol === 'function' && symbol.tostringtag && (typeof symbol.tostringtag === hasshammedsymbols ? 'object' : 'symbol')
    ? symbol.tostringtag
    : null;
var isenumerable = object.prototype.propertyisenumerable;

var gpo = (typeof reflect === 'function' ? reflect.getprototypeof : object.getprototypeof) || (
    [].__proto__ === array.prototype // eslint-disable-line no-proto
        ? function (o) {
            return o.__proto__; // eslint-disable-line no-proto
        }
        : null
);

function addnumericseparator(num, str) {
    if (
        num === infinity
        || num === -infinity
        || num !== num
        || (num && num > -1000 && num < 1000)
        || $test.call(/e/, str)
    ) {
        return str;
    }
    var sepregex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
    if (typeof num === 'number') {
        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)
        if (int !== num) {
            var intstr = string(int);
            var dec = $slice.call(str, intstr.length + 1);
            return $replace.call(intstr, sepregex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');
        }
    }
    return $replace.call(str, sepregex, '$&_');
}

var utilinspect = __webpack_require__(334);
var inspectcustom = utilinspect.custom;
var inspectsymbol = issymbol(inspectcustom) ? inspectcustom : null;

module.exports = function inspect_(obj, options, depth, seen) {
    var opts = options || {};

    if (has(opts, 'quotestyle') && (opts.quotestyle !== 'single' && opts.quotestyle !== 'double')) {
        throw new typeerror('option "quotestyle" must be "single" or "double"');
    }
    if (
        has(opts, 'maxstringlength') && (typeof opts.maxstringlength === 'number'
            ? opts.maxstringlength < 0 && opts.maxstringlength !== infinity
            : opts.maxstringlength !== null
        )
    ) {
        throw new typeerror('option "maxstringlength", if provided, must be a positive integer, infinity, or `null`');
    }
    var custominspect = has(opts, 'custominspect') ? opts.custominspect : true;
    if (typeof custominspect !== 'boolean' && custominspect !== 'symbol') {
        throw new typeerror('option "custominspect", if provided, must be `true`, `false`, or `\'symbol\'`');
    }

    if (
        has(opts, 'indent')
        && opts.indent !== null
        && opts.indent !== '\t'
        && !(parseint(opts.indent, 10) === opts.indent && opts.indent > 0)
    ) {
        throw new typeerror('option "indent" must be "\\t", an integer > 0, or `null`');
    }
    if (has(opts, 'numericseparator') && typeof opts.numericseparator !== 'boolean') {
        throw new typeerror('option "numericseparator", if provided, must be `true` or `false`');
    }
    var numericseparator = opts.numericseparator;

    if (typeof obj === 'undefined') {
        return 'undefined';
    }
    if (obj === null) {
        return 'null';
    }
    if (typeof obj === 'boolean') {
        return obj ? 'true' : 'false';
    }

    if (typeof obj === 'string') {
        return inspectstring(obj, opts);
    }
    if (typeof obj === 'number') {
        if (obj === 0) {
            return infinity / obj > 0 ? '0' : '-0';
        }
        var str = string(obj);
        return numericseparator ? addnumericseparator(obj, str) : str;
    }
    if (typeof obj === 'bigint') {
        var bigintstr = string(obj) + 'n';
        return numericseparator ? addnumericseparator(obj, bigintstr) : bigintstr;
    }

    var maxdepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
    if (typeof depth === 'undefined') { depth = 0; }
    if (depth >= maxdepth && maxdepth > 0 && typeof obj === 'object') {
        return isarray(obj) ? '[array]' : '[object]';
    }

    var indent = getindent(opts, depth);

    if (typeof seen === 'undefined') {
        seen = [];
    } else if (indexof(seen, obj) >= 0) {
        return '[circular]';
    }

    function inspect(value, from, noindent) {
        if (from) {
            seen = $arrslice.call(seen);
            seen.push(from);
        }
        if (noindent) {
            var newopts = {
                depth: opts.depth
            };
            if (has(opts, 'quotestyle')) {
                newopts.quotestyle = opts.quotestyle;
            }
            return inspect_(value, newopts, depth + 1, seen);
        }
        return inspect_(value, opts, depth + 1, seen);
    }

    if (typeof obj === 'function' && !isregexp(obj)) { // in older engines, regexes are callable
        var name = nameof(obj);
        var keys = arrobjkeys(obj, inspect);
        return '[function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');
    }
    if (issymbol(obj)) {
        var symstring = hasshammedsymbols ? $replace.call(string(obj), /^(symbol\(.*\))_[^)]*$/, '$1') : symtostring.call(obj);
        return typeof obj === 'object' && !hasshammedsymbols ? markboxed(symstring) : symstring;
    }
    if (iselement(obj)) {
        var s = '<' + $tolowercase.call(string(obj.nodename));
        var attrs = obj.attributes || [];
        for (var i = 0; i < attrs.length; i++) {
            s += ' ' + attrs[i].name + '=' + wrapquotes(quote(attrs[i].value), 'double', opts);
        }
        s += '>';
        if (obj.childnodes && obj.childnodes.length) { s += '...'; }
        s += '</' + $tolowercase.call(string(obj.nodename)) + '>';
        return s;
    }
    if (isarray(obj)) {
        if (obj.length === 0) { return '[]'; }
        var xs = arrobjkeys(obj, inspect);
        if (indent && !singlelinevalues(xs)) {
            return '[' + indentedjoin(xs, indent) + ']';
        }
        return '[ ' + $join.call(xs, ', ') + ' ]';
    }
    if (iserror(obj)) {
        var parts = arrobjkeys(obj, inspect);
        if (!('cause' in error.prototype) && 'cause' in obj && !isenumerable.call(obj, 'cause')) {
            return '{ [' + string(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';
        }
        if (parts.length === 0) { return '[' + string(obj) + ']'; }
        return '{ [' + string(obj) + '] ' + $join.call(parts, ', ') + ' }';
    }
    if (typeof obj === 'object' && custominspect) {
        if (inspectsymbol && typeof obj[inspectsymbol] === 'function' && utilinspect) {
            return utilinspect(obj, { depth: maxdepth - depth });
        } else if (custominspect !== 'symbol' && typeof obj.inspect === 'function') {
            return obj.inspect();
        }
    }
    if (ismap(obj)) {
        var mapparts = [];
        mapforeach.call(obj, function (value, key) {
            mapparts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
        });
        return collectionof('map', mapsize.call(obj), mapparts, indent);
    }
    if (isset(obj)) {
        var setparts = [];
        setforeach.call(obj, function (value) {
            setparts.push(inspect(value, obj));
        });
        return collectionof('set', setsize.call(obj), setparts, indent);
    }
    if (isweakmap(obj)) {
        return weakcollectionof('weakmap');
    }
    if (isweakset(obj)) {
        return weakcollectionof('weakset');
    }
    if (isweakref(obj)) {
        return weakcollectionof('weakref');
    }
    if (isnumber(obj)) {
        return markboxed(inspect(number(obj)));
    }
    if (isbigint(obj)) {
        return markboxed(inspect(bigintvalueof.call(obj)));
    }
    if (isboolean(obj)) {
        return markboxed(booleanvalueof.call(obj));
    }
    if (isstring(obj)) {
        return markboxed(inspect(string(obj)));
    }
    if (!isdate(obj) && !isregexp(obj)) {
        var ys = arrobjkeys(obj, inspect);
        var isplainobject = gpo ? gpo(obj) === object.prototype : obj instanceof object || obj.constructor === object;
        var prototag = obj instanceof object ? '' : 'null prototype';
        var stringtag = !isplainobject && tostringtag && object(obj) === obj && tostringtag in obj ? $slice.call(tostr(obj), 8, -1) : prototag ? 'object' : '';
        var constructortag = isplainobject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
        var tag = constructortag + (stringtag || prototag ? '[' + $join.call($concat.call([], stringtag || [], prototag || []), ': ') + '] ' : '');
        if (ys.length === 0) { return tag + '{}'; }
        if (indent) {
            return tag + '{' + indentedjoin(ys, indent) + '}';
        }
        return tag + '{ ' + $join.call(ys, ', ') + ' }';
    }
    return string(obj);
};

function wrapquotes(s, defaultstyle, opts) {
    var quotechar = (opts.quotestyle || defaultstyle) === 'double' ? '"' : "'";
    return quotechar + s + quotechar;
}

function quote(s) {
    return $replace.call(string(s), /"/g, '&quot;');
}

function isarray(obj) { return tostr(obj) === '[object array]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function isdate(obj) { return tostr(obj) === '[object date]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function isregexp(obj) { return tostr(obj) === '[object regexp]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function iserror(obj) { return tostr(obj) === '[object error]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function isstring(obj) { return tostr(obj) === '[object string]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function isnumber(obj) { return tostr(obj) === '[object number]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }
function isboolean(obj) { return tostr(obj) === '[object boolean]' && (!tostringtag || !(typeof obj === 'object' && tostringtag in obj)); }

// symbol and bigint do have symbol.tostringtag by spec, so that can't be used to eliminate false positives
function issymbol(obj) {
    if (hasshammedsymbols) {
        return obj && typeof obj === 'object' && obj instanceof symbol;
    }
    if (typeof obj === 'symbol') {
        return true;
    }
    if (!obj || typeof obj !== 'object' || !symtostring) {
        return false;
    }
    try {
        symtostring.call(obj);
        return true;
    } catch (e) {}
    return false;
}

function isbigint(obj) {
    if (!obj || typeof obj !== 'object' || !bigintvalueof) {
        return false;
    }
    try {
        bigintvalueof.call(obj);
        return true;
    } catch (e) {}
    return false;
}

var hasown = object.prototype.hasownproperty || function (key) { return key in this; };
function has(obj, key) {
    return hasown.call(obj, key);
}

function tostr(obj) {
    return objecttostring.call(obj);
}

function nameof(f) {
    if (f.name) { return f.name; }
    var m = $match.call(functiontostring.call(f), /^function\s*([\w$]+)/);
    if (m) { return m[1]; }
    return null;
}

function indexof(xs, x) {
    if (xs.indexof) { return xs.indexof(x); }
    for (var i = 0, l = xs.length; i < l; i++) {
        if (xs[i] === x) { return i; }
    }
    return -1;
}

function ismap(x) {
    if (!mapsize || !x || typeof x !== 'object') {
        return false;
    }
    try {
        mapsize.call(x);
        try {
            setsize.call(x);
        } catch (s) {
            return true;
        }
        return x instanceof map; // core-js workaround, pre-v2.5.0
    } catch (e) {}
    return false;
}

function isweakmap(x) {
    if (!weakmaphas || !x || typeof x !== 'object') {
        return false;
    }
    try {
        weakmaphas.call(x, weakmaphas);
        try {
            weaksethas.call(x, weaksethas);
        } catch (s) {
            return true;
        }
        return x instanceof weakmap; // core-js workaround, pre-v2.5.0
    } catch (e) {}
    return false;
}

function isweakref(x) {
    if (!weakrefderef || !x || typeof x !== 'object') {
        return false;
    }
    try {
        weakrefderef.call(x);
        return true;
    } catch (e) {}
    return false;
}

function isset(x) {
    if (!setsize || !x || typeof x !== 'object') {
        return false;
    }
    try {
        setsize.call(x);
        try {
            mapsize.call(x);
        } catch (m) {
            return true;
        }
        return x instanceof set; // core-js workaround, pre-v2.5.0
    } catch (e) {}
    return false;
}

function isweakset(x) {
    if (!weaksethas || !x || typeof x !== 'object') {
        return false;
    }
    try {
        weaksethas.call(x, weaksethas);
        try {
            weakmaphas.call(x, weakmaphas);
        } catch (s) {
            return true;
        }
        return x instanceof weakset; // core-js workaround, pre-v2.5.0
    } catch (e) {}
    return false;
}

function iselement(x) {
    if (!x || typeof x !== 'object') { return false; }
    if (typeof htmlelement !== 'undefined' && x instanceof htmlelement) {
        return true;
    }
    return typeof x.nodename === 'string' && typeof x.getattribute === 'function';
}

function inspectstring(str, opts) {
    if (str.length > opts.maxstringlength) {
        var remaining = str.length - opts.maxstringlength;
        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
        return inspectstring($slice.call(str, 0, opts.maxstringlength), opts) + trailer;
    }
    // eslint-disable-next-line no-control-regex
    var s = $replace.call($replace.call(str, /(['\\])/g, '\\$1'), /[\x00-\x1f]/g, lowbyte);
    return wrapquotes(s, 'single', opts);
}

function lowbyte(c) {
    var n = c.charcodeat(0);
    var x = {
        8: 'b',
        9: 't',
        10: 'n',
        12: 'f',
        13: 'r'
    }[n];
    if (x) { return '\\' + x; }
    return '\\x' + (n < 0x10 ? '0' : '') + $touppercase.call(n.tostring(16));
}

function markboxed(str) {
    return 'object(' + str + ')';
}

function weakcollectionof(type) {
    return type + ' { ? }';
}

function collectionof(type, size, entries, indent) {
    var joinedentries = indent ? indentedjoin(entries, indent) : $join.call(entries, ', ');
    return type + ' (' + size + ') {' + joinedentries + '}';
}

function singlelinevalues(xs) {
    for (var i = 0; i < xs.length; i++) {
        if (indexof(xs[i], '\n') >= 0) {
            return false;
        }
    }
    return true;
}

function getindent(opts, depth) {
    var baseindent;
    if (opts.indent === '\t') {
        baseindent = '\t';
    } else if (typeof opts.indent === 'number' && opts.indent > 0) {
        baseindent = $join.call(array(opts.indent + 1), ' ');
    } else {
        return null;
    }
    return {
        base: baseindent,
        prev: $join.call(array(depth + 1), baseindent)
    };
}

function indentedjoin(xs, indent) {
    if (xs.length === 0) { return ''; }
    var linejoiner = '\n' + indent.prev + indent.base;
    return linejoiner + $join.call(xs, ',' + linejoiner) + '\n' + indent.prev;
}

function arrobjkeys(obj, inspect) {
    var isarr = isarray(obj);
    var xs = [];
    if (isarr) {
        xs.length = obj.length;
        for (var i = 0; i < obj.length; i++) {
            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
        }
    }
    var syms = typeof gops === 'function' ? gops(obj) : [];
    var symmap;
    if (hasshammedsymbols) {
        symmap = {};
        for (var k = 0; k < syms.length; k++) {
            symmap['$' + syms[k]] = syms[k];
        }
    }

    for (var key in obj) { // eslint-disable-line no-restricted-syntax
        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
        if (isarr && string(number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
        if (hasshammedsymbols && symmap['$' + key] instanceof symbol) {
            // this is to prevent shammed symbols, which are stored as strings, from being included in the string key section
            continue; // eslint-disable-line no-restricted-syntax, no-continue
        } else if ($test.call(/[^\w$]/, key)) {
            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
        } else {
            xs.push(key + ': ' + inspect(obj[key], obj));
        }
    }
    if (typeof gops === 'function') {
        for (var j = 0; j < syms.length; j++) {
            if (isenumerable.call(obj, syms[j])) {
                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
            }
        }
    }
    return xs;
}


/***/ }),

/***/ 335:
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(178);

var has = object.prototype.hasownproperty;
var isarray = array.isarray;

var defaults = {
    allowdots: false,
    allowprototypes: false,
    allowsparse: false,
    arraylimit: 20,
    charset: 'utf-8',
    charsetsentinel: false,
    comma: false,
    decoder: utils.decode,
    delimiter: '&',
    depth: 5,
    ignorequeryprefix: false,
    interpretnumericentities: false,
    parameterlimit: 1000,
    parsearrays: true,
    plainobjects: false,
    strictnullhandling: false
};

var interpretnumericentities = function (str) {
    return str.replace(/&#(\d+);/g, function ($0, numberstr) {
        return string.fromcharcode(parseint(numberstr, 10));
    });
};

var parsearrayvalue = function (val, options) {
    if (val && typeof val === 'string' && options.comma && val.indexof(',') > -1) {
        return val.split(',');
    }

    return val;
};

// this is what browsers will submit when the ✓ character occurs in an
// application/x-www-form-urlencoded body and the encoding of the page containing
// the form is iso-8859-1, or when the submitted form has an accept-charset
// attribute of iso-8859-1. presumably also with other charsets that do not contain
// the ✓ character, such as us-ascii.
var isosentinel = 'utf8=%26%2310003%3b'; // encodeuricomponent('&#10003;')

// these are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
var charsetsentinel = 'utf8=%e2%9c%93'; // encodeuricomponent('✓')

var parsevalues = function parsequerystringvalues(str, options) {
    var obj = {};
    var cleanstr = options.ignorequeryprefix ? str.replace(/^\?/, '') : str;
    var limit = options.parameterlimit === infinity ? undefined : options.parameterlimit;
    var parts = cleanstr.split(options.delimiter, limit);
    var skipindex = -1; // keep track of where the utf8 sentinel was found
    var i;

    var charset = options.charset;
    if (options.charsetsentinel) {
        for (i = 0; i < parts.length; ++i) {
            if (parts[i].indexof('utf8=') === 0) {
                if (parts[i] === charsetsentinel) {
                    charset = 'utf-8';
                } else if (parts[i] === isosentinel) {
                    charset = 'iso-8859-1';
                }
                skipindex = i;
                i = parts.length; // the eslint settings do not allow break;
            }
        }
    }

    for (i = 0; i < parts.length; ++i) {
        if (i === skipindex) {
            continue;
        }
        var part = parts[i];

        var bracketequalspos = part.indexof(']=');
        var pos = bracketequalspos === -1 ? part.indexof('=') : bracketequalspos + 1;

        var key, val;
        if (pos === -1) {
            key = options.decoder(part, defaults.decoder, charset, 'key');
            val = options.strictnullhandling ? null : '';
        } else {
            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
            val = utils.maybemap(
                parsearrayvalue(part.slice(pos + 1), options),
                function (encodedval) {
                    return options.decoder(encodedval, defaults.decoder, charset, 'value');
                }
            );
        }

        if (val && options.interpretnumericentities && charset === 'iso-8859-1') {
            val = interpretnumericentities(val);
        }

        if (part.indexof('[]=') > -1) {
            val = isarray(val) ? [val] : val;
        }

        if (has.call(obj, key)) {
            obj[key] = utils.combine(obj[key], val);
        } else {
            obj[key] = val;
        }
    }

    return obj;
};

var parseobject = function (chain, val, options, valuesparsed) {
    var leaf = valuesparsed ? val : parsearrayvalue(val, options);

    for (var i = chain.length - 1; i >= 0; --i) {
        var obj;
        var root = chain[i];

        if (root === '[]' && options.parsearrays) {
            obj = [].concat(leaf);
        } else {
            obj = options.plainobjects ? object.create(null) : {};
            var cleanroot = root.charat(0) === '[' && root.charat(root.length - 1) === ']' ? root.slice(1, -1) : root;
            var index = parseint(cleanroot, 10);
            if (!options.parsearrays && cleanroot === '') {
                obj = { 0: leaf };
            } else if (
                !isnan(index)
                && root !== cleanroot
                && string(index) === cleanroot
                && index >= 0
                && (options.parsearrays && index <= options.arraylimit)
            ) {
                obj = [];
                obj[index] = leaf;
            } else if (cleanroot !== '__proto__') {
                obj[cleanroot] = leaf;
            }
        }

        leaf = obj;
    }

    return leaf;
};

var parsekeys = function parsequerystringkeys(givenkey, val, options, valuesparsed) {
    if (!givenkey) {
        return;
    }

    // transform dot notation to bracket notation
    var key = options.allowdots ? givenkey.replace(/\.([^.[]+)/g, '[$1]') : givenkey;

    // the regex chunks

    var brackets = /(\[[^[\]]*])/;
    var child = /(\[[^[\]]*])/g;

    // get the parent

    var segment = options.depth > 0 && brackets.exec(key);
    var parent = segment ? key.slice(0, segment.index) : key;

    // stash the parent if it exists

    var keys = [];
    if (parent) {
        // if we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
        if (!options.plainobjects && has.call(object.prototype, parent)) {
            if (!options.allowprototypes) {
                return;
            }
        }

        keys.push(parent);
    }

    // loop through children appending to the array until we hit depth

    var i = 0;
    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
        i += 1;
        if (!options.plainobjects && has.call(object.prototype, segment[1].slice(1, -1))) {
            if (!options.allowprototypes) {
                return;
            }
        }
        keys.push(segment[1]);
    }

    // if there's a remainder, just add whatever is left

    if (segment) {
        keys.push('[' + key.slice(segment.index) + ']');
    }

    return parseobject(keys, val, options, valuesparsed);
};

var normalizeparseoptions = function normalizeparseoptions(opts) {
    if (!opts) {
        return defaults;
    }

    if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {
        throw new typeerror('decoder has to be a function.');
    }

    if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
        throw new typeerror('the charset option must be either utf-8, iso-8859-1, or undefined');
    }
    var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;

    return {
        allowdots: typeof opts.allowdots === 'undefined' ? defaults.allowdots : !!opts.allowdots,
        allowprototypes: typeof opts.allowprototypes === 'boolean' ? opts.allowprototypes : defaults.allowprototypes,
        allowsparse: typeof opts.allowsparse === 'boolean' ? opts.allowsparse : defaults.allowsparse,
        arraylimit: typeof opts.arraylimit === 'number' ? opts.arraylimit : defaults.arraylimit,
        charset: charset,
        charsetsentinel: typeof opts.charsetsentinel === 'boolean' ? opts.charsetsentinel : defaults.charsetsentinel,
        comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
        decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
        delimiter: typeof opts.delimiter === 'string' || utils.isregexp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
        // eslint-disable-next-line no-implicit-coercion, no-extra-parens
        depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,
        ignorequeryprefix: opts.ignorequeryprefix === true,
        interpretnumericentities: typeof opts.interpretnumericentities === 'boolean' ? opts.interpretnumericentities : defaults.interpretnumericentities,
        parameterlimit: typeof opts.parameterlimit === 'number' ? opts.parameterlimit : defaults.parameterlimit,
        parsearrays: opts.parsearrays !== false,
        plainobjects: typeof opts.plainobjects === 'boolean' ? opts.plainobjects : defaults.plainobjects,
        strictnullhandling: typeof opts.strictnullhandling === 'boolean' ? opts.strictnullhandling : defaults.strictnullhandling
    };
};

module.exports = function (str, opts) {
    var options = normalizeparseoptions(opts);

    if (str === '' || str === null || typeof str === 'undefined') {
        return options.plainobjects ? object.create(null) : {};
    }

    var tempobj = typeof str === 'string' ? parsevalues(str, options) : str;
    var obj = options.plainobjects ? object.create(null) : {};

    // iterate over the keys and setup the new object

    var keys = object.keys(tempobj);
    for (var i = 0; i < keys.length; ++i) {
        var key = keys[i];
        var newobj = parsekeys(key, tempobj[key], options, typeof str === 'string');
        obj = utils.merge(obj, newobj, options);
    }

    if (options.allowsparse === true) {
        return obj;
    }

    return utils.compact(obj);
};


/***/ }),

/***/ 37:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export version */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return addsidxsegmentstoplaylist$1; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return generatesidxkey; });
/* unused harmony export inheritattributes */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return parse; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return parseutctiming; });
/* unused harmony export stringtompdxml */
/* unused harmony export tom3u8 */
/* unused harmony export toplaylists */
/* harmony import */ var _videojs_vhs_utils_es_resolve_url__webpack_imported_module_0__ = __webpack_require__(53);
/* harmony import */ var global_window__webpack_imported_module_1__ = __webpack_require__(0);
/* harmony import */ var global_window__webpack_imported_module_1___default = /*#__pure__*/__webpack_require__.n(global_window__webpack_imported_module_1__);
/* harmony import */ var _videojs_vhs_utils_es_media_groups__webpack_imported_module_2__ = __webpack_require__(193);
/* harmony import */ var _videojs_vhs_utils_es_decode_b64_to_uint8_array__webpack_imported_module_3__ = __webpack_require__(89);
/* harmony import */ var _xmldom_xmldom__webpack_imported_module_4__ = __webpack_require__(194);
/* harmony import */ var _xmldom_xmldom__webpack_imported_module_4___default = /*#__pure__*/__webpack_require__.n(_xmldom_xmldom__webpack_imported_module_4__);
/*! @name mpd-parser @version 0.21.1 @license apache-2.0 */






var version = "0.21.1";

var isobject = function isobject(obj) {
  return !!obj && typeof obj === 'object';
};

var merge = function merge() {
  for (var _len = arguments.length, objects = new array(_len), _key = 0; _key < _len; _key++) {
    objects[_key] = arguments[_key];
  }

  return objects.reduce(function (result, source) {
    if (typeof source !== 'object') {
      return result;
    }

    object.keys(source).foreach(function (key) {
      if (array.isarray(result[key]) && array.isarray(source[key])) {
        result[key] = result[key].concat(source[key]);
      } else if (isobject(result[key]) && isobject(source[key])) {
        result[key] = merge(result[key], source[key]);
      } else {
        result[key] = source[key];
      }
    });
    return result;
  }, {});
};
var values = function values(o) {
  return object.keys(o).map(function (k) {
    return o[k];
  });
};

var range = function range(start, end) {
  var result = [];

  for (var i = start; i < end; i++) {
    result.push(i);
  }

  return result;
};
var flatten = function flatten(lists) {
  return lists.reduce(function (x, y) {
    return x.concat(y);
  }, []);
};
var from = function from(list) {
  if (!list.length) {
    return [];
  }

  var result = [];

  for (var i = 0; i < list.length; i++) {
    result.push(list[i]);
  }

  return result;
};
var findindexes = function findindexes(l, key) {
  return l.reduce(function (a, e, i) {
    if (e[key]) {
      a.push(i);
    }

    return a;
  }, []);
};
/**
 * returns the first index that satisfies the matching function, or -1 if not found.
 *
 * only necessary because of ie11 support.
 *
 * @param {array} list - the list to search through
 * @param {function} matchingfunction - the matching function
 *
 * @return {number} the matching index or -1 if not found
 */

var findindex = function findindex(list, matchingfunction) {
  for (var i = 0; i < list.length; i++) {
    if (matchingfunction(list[i])) {
      return i;
    }
  }

  return -1;
};
/**
 * returns a union of the included lists provided each element can be identified by a key.
 *
 * @param {array} list - list of lists to get the union of
 * @param {function} keyfunction - the function to use as a key for each element
 *
 * @return {array} the union of the arrays
 */

var union = function union(lists, keyfunction) {
  return values(lists.reduce(function (acc, list) {
    list.foreach(function (el) {
      acc[keyfunction(el)] = el;
    });
    return acc;
  }, {}));
};

var errors = {
  invalid_number_of_period: 'invalid_number_of_period',
  dash_empty_manifest: 'dash_empty_manifest',
  dash_invalid_xml: 'dash_invalid_xml',
  no_base_url: 'no_base_url',
  missing_segment_information: 'missing_segment_information',
  segment_time_unspecified: 'segment_time_unspecified',
  unsupported_utc_timing_scheme: 'unsupported_utc_timing_scheme'
};

/**
 * @typedef {object} singleuri
 * @property {string} uri - relative location of segment
 * @property {string} resolveduri - resolved location of segment
 * @property {object} byterange - object containing information on how to make byte range
 *   requests following byte-range-spec per rfc2616.
 * @property {string} byterange.length - length of range request
 * @property {string} byterange.offset - byte offset of range request
 *
 * @see https://www.w3.org/protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
 */

/**
 * converts a urltype node (5.3.9.2.3 table 13) to a segment object
 * that conforms to how m3u8-parser is structured
 *
 * @see https://github.com/videojs/m3u8-parser
 *
 * @param {string} baseurl - baseurl provided by <baseurl> nodes
 * @param {string} source - source url for segment
 * @param {string} range - optional range used for range calls,
 *   follows  rfc 2616, clause 14.35.1
 * @return {singleuri} full segment information transformed into a format similar
 *   to m3u8-parser
 */

var urltypetosegment = function urltypetosegment(_ref) {
  var _ref$baseurl = _ref.baseurl,
      baseurl = _ref$baseurl === void 0 ? '' : _ref$baseurl,
      _ref$source = _ref.source,
      source = _ref$source === void 0 ? '' : _ref$source,
      _ref$range = _ref.range,
      range = _ref$range === void 0 ? '' : _ref$range,
      _ref$indexrange = _ref.indexrange,
      indexrange = _ref$indexrange === void 0 ? '' : _ref$indexrange;
  var segment = {
    uri: source,
    resolveduri: object(_videojs_vhs_utils_es_resolve_url__webpack_imported_module_0__[/* default */ "a"])(baseurl || '', source)
  };

  if (range || indexrange) {
    var rangestr = range ? range : indexrange;
    var ranges = rangestr.split('-'); // default to parsing this as a bigint if possible

    var startrange = global_window__webpack_imported_module_1___default.a.bigint ? global_window__webpack_imported_module_1___default.a.bigint(ranges[0]) : parseint(ranges[0], 10);
    var endrange = global_window__webpack_imported_module_1___default.a.bigint ? global_window__webpack_imported_module_1___default.a.bigint(ranges[1]) : parseint(ranges[1], 10); // convert back to a number if less than max_safe_integer

    if (startrange < number.max_safe_integer && typeof startrange === 'bigint') {
      startrange = number(startrange);
    }

    if (endrange < number.max_safe_integer && typeof endrange === 'bigint') {
      endrange = number(endrange);
    }

    var length;

    if (typeof endrange === 'bigint' || typeof startrange === 'bigint') {
      length = global_window__webpack_imported_module_1___default.a.bigint(endrange) - global_window__webpack_imported_module_1___default.a.bigint(startrange) + global_window__webpack_imported_module_1___default.a.bigint(1);
    } else {
      length = endrange - startrange + 1;
    }

    if (typeof length === 'bigint' && length < number.max_safe_integer) {
      length = number(length);
    } // byterange should be inclusive according to
    // rfc 2616, clause 14.35.1


    segment.byterange = {
      length: length,
      offset: startrange
    };
  }

  return segment;
};
var byterangetostring = function byterangetostring(byterange) {
  // `endrange` is one less than `offset + length` because the http range
  // header uses inclusive ranges
  var endrange;

  if (typeof byterange.offset === 'bigint' || typeof byterange.length === 'bigint') {
    endrange = global_window__webpack_imported_module_1___default.a.bigint(byterange.offset) + global_window__webpack_imported_module_1___default.a.bigint(byterange.length) - global_window__webpack_imported_module_1___default.a.bigint(1);
  } else {
    endrange = byterange.offset + byterange.length - 1;
  }

  return byterange.offset + "-" + endrange;
};

/**
 * parse the end number attribue that can be a string
 * number, or undefined.
 *
 * @param {string|number|undefined} endnumber
 *        the end number attribute.
 *
 * @return {number|null}
 *          the result of parsing the end number.
 */

var parseendnumber = function parseendnumber(endnumber) {
  if (endnumber && typeof endnumber !== 'number') {
    endnumber = parseint(endnumber, 10);
  }

  if (isnan(endnumber)) {
    return null;
  }

  return endnumber;
};
/**
 * functions for calculating the range of available segments in static and dynamic
 * manifests.
 */


var segmentrange = {
  /**
   * returns the entire range of available segments for a static mpd
   *
   * @param {object} attributes
   *        inheritied mpd attributes
   * @return {{ start: number, end: number }}
   *         the start and end numbers for available segments
   */
  static: function _static(attributes) {
    var duration = attributes.duration,
        _attributes$timescale = attributes.timescale,
        timescale = _attributes$timescale === void 0 ? 1 : _attributes$timescale,
        sourceduration = attributes.sourceduration,
        periodduration = attributes.periodduration;
    var endnumber = parseendnumber(attributes.endnumber);
    var segmentduration = duration / timescale;

    if (typeof endnumber === 'number') {
      return {
        start: 0,
        end: endnumber
      };
    }

    if (typeof periodduration === 'number') {
      return {
        start: 0,
        end: periodduration / segmentduration
      };
    }

    return {
      start: 0,
      end: sourceduration / segmentduration
    };
  },

  /**
   * returns the current live window range of available segments for a dynamic mpd
   *
   * @param {object} attributes
   *        inheritied mpd attributes
   * @return {{ start: number, end: number }}
   *         the start and end numbers for available segments
   */
  dynamic: function dynamic(attributes) {
    var now = attributes.now,
        clientoffset = attributes.clientoffset,
        availabilitystarttime = attributes.availabilitystarttime,
        _attributes$timescale2 = attributes.timescale,
        timescale = _attributes$timescale2 === void 0 ? 1 : _attributes$timescale2,
        duration = attributes.duration,
        _attributes$periodsta = attributes.periodstart,
        periodstart = _attributes$periodsta === void 0 ? 0 : _attributes$periodsta,
        _attributes$minimumup = attributes.minimumupdateperiod,
        minimumupdateperiod = _attributes$minimumup === void 0 ? 0 : _attributes$minimumup,
        _attributes$timeshift = attributes.timeshiftbufferdepth,
        timeshiftbufferdepth = _attributes$timeshift === void 0 ? infinity : _attributes$timeshift;
    var endnumber = parseendnumber(attributes.endnumber); // clientoffset is passed in at the top level of mpd-parser and is an offset calculated
    // after retrieving utc server time.

    var now = (now + clientoffset) / 1000; // wc stands for wall clock.
    // convert the period start time to epoch.

    var periodstartwc = availabilitystarttime + periodstart; // period end in epoch is manifest's retrieval time + time until next update.

    var periodendwc = now + minimumupdateperiod;
    var periodduration = periodendwc - periodstartwc;
    var segmentcount = math.ceil(periodduration * timescale / duration);
    var availablestart = math.floor((now - periodstartwc - timeshiftbufferdepth) * timescale / duration);
    var availableend = math.floor((now - periodstartwc) * timescale / duration);
    return {
      start: math.max(0, availablestart),
      end: typeof endnumber === 'number' ? endnumber : math.min(segmentcount, availableend)
    };
  }
};
/**
 * maps a range of numbers to objects with information needed to build the corresponding
 * segment list
 *
 * @name tosegmentscallback
 * @function
 * @param {number} number
 *        number of the segment
 * @param {number} index
 *        index of the number in the range list
 * @return {{ number: number, duration: number, timeline: number, time: number }}
 *         object with segment timing and duration info
 */

/**
 * returns a callback for array.prototype.map for mapping a range of numbers to
 * information needed to build the segment list.
 *
 * @param {object} attributes
 *        inherited mpd attributes
 * @return {tosegmentscallback}
 *         callback map function
 */

var tosegments = function tosegments(attributes) {
  return function (number) {
    var duration = attributes.duration,
        _attributes$timescale3 = attributes.timescale,
        timescale = _attributes$timescale3 === void 0 ? 1 : _attributes$timescale3,
        periodstart = attributes.periodstart,
        _attributes$startnumb = attributes.startnumber,
        startnumber = _attributes$startnumb === void 0 ? 1 : _attributes$startnumb;
    return {
      number: startnumber + number,
      duration: duration / timescale,
      timeline: periodstart,
      time: number * duration
    };
  };
};
/**
 * returns a list of objects containing segment timing and duration info used for
 * building the list of segments. this uses the @duration attribute specified
 * in the mpd manifest to derive the range of segments.
 *
 * @param {object} attributes
 *        inherited mpd attributes
 * @return {{number: number, duration: number, time: number, timeline: number}[]}
 *         list of objects with segment timing and duration info
 */

var parsebyduration = function parsebyduration(attributes) {
  var type = attributes.type,
      duration = attributes.duration,
      _attributes$timescale4 = attributes.timescale,
      timescale = _attributes$timescale4 === void 0 ? 1 : _attributes$timescale4,
      periodduration = attributes.periodduration,
      sourceduration = attributes.sourceduration;

  var _segmentrange$type = segmentrange[type](attributes),
      start = _segmentrange$type.start,
      end = _segmentrange$type.end;

  var segments = range(start, end).map(tosegments(attributes));

  if (type === 'static') {
    var index = segments.length - 1; // section is either a period or the full source

    var sectionduration = typeof periodduration === 'number' ? periodduration : sourceduration; // final segment may be less than full segment duration

    segments[index].duration = sectionduration - duration / timescale * index;
  }

  return segments;
};

/**
 * translates segmentbase into a set of segments.
 * (dash spec section 5.3.9.3.2) contains a set of <segmenturl> nodes.  each
 * node should be translated into segment.
 *
 * @param {object} attributes
 *   object containing all inherited attributes from parent elements with attribute
 *   names as keys
 * @return {object.<array>} list of segments
 */

var segmentsfrombase = function segmentsfrombase(attributes) {
  var baseurl = attributes.baseurl,
      _attributes$initializ = attributes.initialization,
      initialization = _attributes$initializ === void 0 ? {} : _attributes$initializ,
      sourceduration = attributes.sourceduration,
      _attributes$indexrang = attributes.indexrange,
      indexrange = _attributes$indexrang === void 0 ? '' : _attributes$indexrang,
      periodstart = attributes.periodstart,
      presentationtime = attributes.presentationtime,
      _attributes$number = attributes.number,
      number = _attributes$number === void 0 ? 0 : _attributes$number,
      duration = attributes.duration; // base url is required for segmentbase to work, per spec (section 5.3.9.2.1)

  if (!baseurl) {
    throw new error(errors.no_base_url);
  }

  var initsegment = urltypetosegment({
    baseurl: baseurl,
    source: initialization.sourceurl,
    range: initialization.range
  });
  var segment = urltypetosegment({
    baseurl: baseurl,
    source: baseurl,
    indexrange: indexrange
  });
  segment.map = initsegment; // if there is a duration, use it, otherwise use the given duration of the source
  // (since segmentbase is only for one total segment)

  if (duration) {
    var segmenttimeinfo = parsebyduration(attributes);

    if (segmenttimeinfo.length) {
      segment.duration = segmenttimeinfo[0].duration;
      segment.timeline = segmenttimeinfo[0].timeline;
    }
  } else if (sourceduration) {
    segment.duration = sourceduration;
    segment.timeline = periodstart;
  } // if presentation time is provided, these segments are being generated by sidx
  // references, and should use the time provided. for the general case of segmentbase,
  // there should only be one segment in the period, so its presentation time is the same
  // as its period start.


  segment.presentationtime = presentationtime || periodstart;
  segment.number = number;
  return [segment];
};
/**
 * given a playlist, a sidx box, and a baseurl, update the segment list of the playlist
 * according to the sidx information given.
 *
 * playlist.sidx has metadadata about the sidx where-as the sidx param
 * is the parsed sidx box itself.
 *
 * @param {object} playlist the playlist to update the sidx information for
 * @param {object} sidx the parsed sidx box
 * @return {object} the playlist object with the updated sidx information
 */

var addsidxsegmentstoplaylist$1 = function addsidxsegmentstoplaylist(playlist, sidx, baseurl) {
  // retain init segment information
  var initsegment = playlist.sidx.map ? playlist.sidx.map : null; // retain source duration from initial main manifest parsing

  var sourceduration = playlist.sidx.duration; // retain source timeline

  var timeline = playlist.timeline || 0;
  var sidxbyterange = playlist.sidx.byterange;
  var sidxend = sidxbyterange.offset + sidxbyterange.length; // retain timescale of the parsed sidx

  var timescale = sidx.timescale; // referencetype 1 refers to other sidx boxes

  var mediareferences = sidx.references.filter(function (r) {
    return r.referencetype !== 1;
  });
  var segments = [];
  var type = playlist.endlist ? 'static' : 'dynamic';
  var periodstart = playlist.sidx.timeline;
  var presentationtime = periodstart;
  var number = playlist.mediasequence || 0; // firstoffset is the offset from the end of the sidx box

  var startindex; // eslint-disable-next-line

  if (typeof sidx.firstoffset === 'bigint') {
    startindex = global_window__webpack_imported_module_1___default.a.bigint(sidxend) + sidx.firstoffset;
  } else {
    startindex = sidxend + sidx.firstoffset;
  }

  for (var i = 0; i < mediareferences.length; i++) {
    var reference = sidx.references[i]; // size of the referenced (sub)segment

    var size = reference.referencedsize; // duration of the referenced (sub)segment, in  the  timescale
    // this will be converted to seconds when generating segments

    var duration = reference.subsegmentduration; // should be an inclusive range

    var endindex = void 0; // eslint-disable-next-line

    if (typeof startindex === 'bigint') {
      endindex = startindex + global_window__webpack_imported_module_1___default.a.bigint(size) - global_window__webpack_imported_module_1___default.a.bigint(1);
    } else {
      endindex = startindex + size - 1;
    }

    var indexrange = startindex + "-" + endindex;
    var attributes = {
      baseurl: baseurl,
      timescale: timescale,
      timeline: timeline,
      periodstart: periodstart,
      presentationtime: presentationtime,
      number: number,
      duration: duration,
      sourceduration: sourceduration,
      indexrange: indexrange,
      type: type
    };
    var segment = segmentsfrombase(attributes)[0];

    if (initsegment) {
      segment.map = initsegment;
    }

    segments.push(segment);

    if (typeof startindex === 'bigint') {
      startindex += global_window__webpack_imported_module_1___default.a.bigint(size);
    } else {
      startindex += size;
    }

    presentationtime += duration / timescale;
    number++;
  }

  playlist.segments = segments;
  return playlist;
};

var supported_media_types = ['audio', 'subtitles']; // allow one 60fps frame as leniency (arbitrarily chosen)

var time_fudge = 1 / 60;
/**
 * given a list of timelinestarts, combines, dedupes, and sorts them.
 *
 * @param {timelinestart[]} timelinestarts - list of timeline starts
 *
 * @return {timelinestart[]} the combined and deduped timeline starts
 */

var getuniquetimelinestarts = function getuniquetimelinestarts(timelinestarts) {
  return union(timelinestarts, function (_ref) {
    var timeline = _ref.timeline;
    return timeline;
  }).sort(function (a, b) {
    return a.timeline > b.timeline ? 1 : -1;
  });
};
/**
 * finds the playlist with the matching name attribute.
 *
 * @param {array} playlists - playlists to search through
 * @param {string} name - the name attribute to search for
 *
 * @return {object|null} the matching playlist object, or null
 */

var findplaylistwithname = function findplaylistwithname(playlists, name) {
  for (var i = 0; i < playlists.length; i++) {
    if (playlists[i].attributes.name === name) {
      return playlists[i];
    }
  }

  return null;
};
/**
 * gets a flattened array of media group playlists.
 *
 * @param {object} manifest - the main manifest object
 *
 * @return {array} the media group playlists
 */

var getmediagroupplaylists = function getmediagroupplaylists(manifest) {
  var mediagroupplaylists = [];
  object(_videojs_vhs_utils_es_media_groups__webpack_imported_module_2__[/* foreachmediagroup */ "a"])(manifest, supported_media_types, function (properties, type, group, label) {
    mediagroupplaylists = mediagroupplaylists.concat(properties.playlists || []);
  });
  return mediagroupplaylists;
};
/**
 * updates the playlist's media sequence numbers.
 *
 * @param {object} config - options object
 * @param {object} config.playlist - the playlist to update
 * @param {number} config.mediasequence - the mediasequence number to start with
 */

var updatemediasequenceforplaylist = function updatemediasequenceforplaylist(_ref2) {
  var playlist = _ref2.playlist,
      mediasequence = _ref2.mediasequence;
  playlist.mediasequence = mediasequence;
  playlist.segments.foreach(function (segment, index) {
    segment.number = playlist.mediasequence + index;
  });
};
/**
 * updates the media and discontinuity sequence numbers of newplaylists given oldplaylists
 * and a complete list of timeline starts.
 *
 * if no matching playlist is found, only the discontinuity sequence number of the playlist
 * will be updated.
 *
 * since early available timelines are not supported, at least one segment must be present.
 *
 * @param {object} config - options object
 * @param {object[]} oldplaylists - the old playlists to use as a reference
 * @param {object[]} newplaylists - the new playlists to update
 * @param {object} timelinestarts - all timelinestarts seen in the stream to this point
 */

var updatesequencenumbers = function updatesequencenumbers(_ref3) {
  var oldplaylists = _ref3.oldplaylists,
      newplaylists = _ref3.newplaylists,
      timelinestarts = _ref3.timelinestarts;
  newplaylists.foreach(function (playlist) {
    playlist.discontinuitysequence = findindex(timelinestarts, function (_ref4) {
      var timeline = _ref4.timeline;
      return timeline === playlist.timeline;
    }); // playlists names come from dash representation ids, which are mandatory
    // (see iso_23009-1-2012 5.3.5.2).
    //
    // if the same representation existed in a prior period, it will retain the same name.

    var oldplaylist = findplaylistwithname(oldplaylists, playlist.attributes.name);

    if (!oldplaylist) {
      // since this is a new playlist, the media sequence values can start from 0 without
      // consequence.
      return;
    } // todo better support for live sidx
    //
    // as of this writing, mpd-parser does not support multiperiod sidx (in live or vod).
    // this is evident by a playlist only having a single sidx reference. in a multiperiod
    // playlist there would need to be multiple sidx references. in addition, live sidx is
    // not supported when the sidx properties change on refreshes.
    //
    // in the future, if support needs to be added, the merging logic here can be called
    // after sidx references are resolved. for now, exit early to prevent exceptions being
    // thrown due to undefined references.


    if (playlist.sidx) {
      return;
    } // since we don't yet support early available timelines, we don't need to support
    // playlists with no segments.


    var firstnewsegment = playlist.segments[0];
    var oldmatchingsegmentindex = findindex(oldplaylist.segments, function (oldsegment) {
      return math.abs(oldsegment.presentationtime - firstnewsegment.presentationtime) < time_fudge;
    }); // no matching segment from the old playlist means the entire playlist was refreshed.
    // in this case the media sequence should account for this update, and the new segments
    // should be marked as discontinuous from the prior content, since the last prior
    // timeline was removed.

    if (oldmatchingsegmentindex === -1) {
      updatemediasequenceforplaylist({
        playlist: playlist,
        mediasequence: oldplaylist.mediasequence + oldplaylist.segments.length
      });
      playlist.segments[0].discontinuity = true;
      playlist.discontinuitystarts.unshift(0); // no matching segment does not necessarily mean there's missing content.
      //
      // if the new playlist's timeline is the same as the last seen segment's timeline,
      // then a discontinuity can be added to identify that there's potentially missing
      // content. if there's no missing content, the discontinuity should still be rather
      // harmless. it's possible that if segment durations are accurate enough, that the
      // existence of a gap can be determined using the presentation times and durations,
      // but if the segment timing info is off, it may introduce more problems than simply
      // adding the discontinuity.
      //
      // if the new playlist's timeline is different from the last seen segment's timeline,
      // then a discontinuity can be added to identify that this is the first seen segment
      // of a new timeline. however, the logic at the start of this function that
      // determined the disconinuity sequence by timeline index is now off by one (the
      // discontinuity of the newest timeline hasn't yet fallen off the manifest...since
      // we added it), so the disconinuity sequence must be decremented.
      //
      // a period may also have a duration of zero, so the case of no segments is handled
      // here even though we don't yet support early available periods.

      if (!oldplaylist.segments.length && playlist.timeline > oldplaylist.timeline || oldplaylist.segments.length && playlist.timeline > oldplaylist.segments[oldplaylist.segments.length - 1].timeline) {
        playlist.discontinuitysequence--;
      }

      return;
    } // if the first segment matched with a prior segment on a discontinuity (it's matching
    // on the first segment of a period), then the discontinuitysequence shouldn't be the
    // timeline's matching one, but instead should be the one prior, and the first segment
    // of the new manifest should be marked with a discontinuity.
    //
    // the reason for this special case is that discontinuity sequence shows how many
    // discontinuities have fallen off of the playlist, and discontinuities are marked on
    // the first segment of a new "timeline." because of this, while dash will retain that
    // period while the "timeline" exists, hls keeps track of it via the discontinuity
    // sequence, and that first segment is an indicator, but can be removed before that
    // timeline is gone.


    var oldmatchingsegment = oldplaylist.segments[oldmatchingsegmentindex];

    if (oldmatchingsegment.discontinuity && !firstnewsegment.discontinuity) {
      firstnewsegment.discontinuity = true;
      playlist.discontinuitystarts.unshift(0);
      playlist.discontinuitysequence--;
    }

    updatemediasequenceforplaylist({
      playlist: playlist,
      mediasequence: oldplaylist.segments[oldmatchingsegmentindex].number
    });
  });
};
/**
 * given an old parsed manifest object and a new parsed manifest object, updates the
 * sequence and timing values within the new manifest to ensure that it lines up with the
 * old.
 *
 * @param {array} oldmanifest - the old main manifest object
 * @param {array} newmanifest - the new main manifest object
 *
 * @return {object} the updated new manifest object
 */

var positionmanifestontimeline = function positionmanifestontimeline(_ref5) {
  var oldmanifest = _ref5.oldmanifest,
      newmanifest = _ref5.newmanifest;
  // starting from v4.1.2 of the iop, section 4.4.3.3 states:
  //
  // "mpd@availabilitystarttime and period@start shall not be changed over mpd updates."
  //
  // this was added from https://github.com/dash-industry-forum/dash-if-iop/issues/160
  //
  // because of this change, and the difficulty of supporting periods with changing start
  // times, periods with changing start times are not supported. this makes the logic much
  // simpler, since periods with the same start time can be considerred the same period
  // across refreshes.
  //
  // to give an example as to the difficulty of handling periods where the start time may
  // change, if a single period manifest is refreshed with another manifest with a single
  // period, and both the start and end times are increased, then the only way to determine
  // if it's a new period or an old one that has changed is to look through the segments of
  // each playlist and determine the presentation time bounds to find a match. in addition,
  // if the period start changed to exceed the old period end, then there would be no
  // match, and it would not be possible to determine whether the refreshed period is a new
  // one or the old one.
  var oldplaylists = oldmanifest.playlists.concat(getmediagroupplaylists(oldmanifest));
  var newplaylists = newmanifest.playlists.concat(getmediagroupplaylists(newmanifest)); // save all seen timelinestarts to the new manifest. although this potentially means that
  // there's a "memory leak" in that it will never stop growing, in reality, only a couple
  // of properties are saved for each seen period. even long running live streams won't
  // generate too many periods, unless the stream is watched for decades. in the future,
  // this can be optimized by mapping to discontinuity sequence numbers for each timeline,
  // but it may not become an issue, and the additional info can be useful for debugging.

  newmanifest.timelinestarts = getuniquetimelinestarts([oldmanifest.timelinestarts, newmanifest.timelinestarts]);
  updatesequencenumbers({
    oldplaylists: oldplaylists,
    newplaylists: newplaylists,
    timelinestarts: newmanifest.timelinestarts
  });
  return newmanifest;
};

var generatesidxkey = function generatesidxkey(sidx) {
  return sidx && sidx.uri + '-' + byterangetostring(sidx.byterange);
};

var mergediscontiguousplaylists = function mergediscontiguousplaylists(playlists) {
  var mergedplaylists = values(playlists.reduce(function (acc, playlist) {
    // assuming playlist ids are the same across periods
    // todo: handle multiperiod where representation sets are not the same
    // across periods
    var name = playlist.attributes.id + (playlist.attributes.lang || '');

    if (!acc[name]) {
      // first period
      acc[name] = playlist;
      acc[name].attributes.timelinestarts = [];
    } else {
      // subsequent periods
      if (playlist.segments) {
        var _acc$name$segments;

        // first segment of subsequent periods signal a discontinuity
        if (playlist.segments[0]) {
          playlist.segments[0].discontinuity = true;
        }

        (_acc$name$segments = acc[name].segments).push.apply(_acc$name$segments, playlist.segments);
      } // bubble up contentprotection, this assumes all drm content
      // has the same contentprotection


      if (playlist.attributes.contentprotection) {
        acc[name].attributes.contentprotection = playlist.attributes.contentprotection;
      }
    }

    acc[name].attributes.timelinestarts.push({
      // although they represent the same number, it's important to have both to make it
      // compatible with hls potentially having a similar attribute.
      start: playlist.attributes.periodstart,
      timeline: playlist.attributes.periodstart
    });
    return acc;
  }, {}));
  return mergedplaylists.map(function (playlist) {
    playlist.discontinuitystarts = findindexes(playlist.segments || [], 'discontinuity');
    return playlist;
  });
};

var addsidxsegmentstoplaylist = function addsidxsegmentstoplaylist(playlist, sidxmapping) {
  var sidxkey = generatesidxkey(playlist.sidx);
  var sidxmatch = sidxkey && sidxmapping[sidxkey] && sidxmapping[sidxkey].sidx;

  if (sidxmatch) {
    addsidxsegmentstoplaylist$1(playlist, sidxmatch, playlist.sidx.resolveduri);
  }

  return playlist;
};
var addsidxsegmentstoplaylists = function addsidxsegmentstoplaylists(playlists, sidxmapping) {
  if (sidxmapping === void 0) {
    sidxmapping = {};
  }

  if (!object.keys(sidxmapping).length) {
    return playlists;
  }

  for (var i in playlists) {
    playlists[i] = addsidxsegmentstoplaylist(playlists[i], sidxmapping);
  }

  return playlists;
};
var formataudioplaylist = function formataudioplaylist(_ref, isaudioonly) {
  var _attributes;

  var attributes = _ref.attributes,
      segments = _ref.segments,
      sidx = _ref.sidx,
      mediasequence = _ref.mediasequence,
      discontinuitysequence = _ref.discontinuitysequence,
      discontinuitystarts = _ref.discontinuitystarts;
  var playlist = {
    attributes: (_attributes = {
      name: attributes.id,
      bandwidth: attributes.bandwidth,
      codecs: attributes.codecs
    }, _attributes['program-id'] = 1, _attributes),
    uri: '',
    endlist: attributes.type === 'static',
    timeline: attributes.periodstart,
    resolveduri: '',
    targetduration: attributes.duration,
    discontinuitysequence: discontinuitysequence,
    discontinuitystarts: discontinuitystarts,
    timelinestarts: attributes.timelinestarts,
    mediasequence: mediasequence,
    segments: segments
  };

  if (attributes.contentprotection) {
    playlist.contentprotection = attributes.contentprotection;
  }

  if (sidx) {
    playlist.sidx = sidx;
  }

  if (isaudioonly) {
    playlist.attributes.audio = 'audio';
    playlist.attributes.subtitles = 'subs';
  }

  return playlist;
};
var formatvttplaylist = function formatvttplaylist(_ref2) {
  var _m3u8attributes;

  var attributes = _ref2.attributes,
      segments = _ref2.segments,
      mediasequence = _ref2.mediasequence,
      discontinuitystarts = _ref2.discontinuitystarts,
      discontinuitysequence = _ref2.discontinuitysequence;

  if (typeof segments === 'undefined') {
    // vtt tracks may use single file in baseurl
    segments = [{
      uri: attributes.baseurl,
      timeline: attributes.periodstart,
      resolveduri: attributes.baseurl || '',
      duration: attributes.sourceduration,
      number: 0
    }]; // targetduration should be the same duration as the only segment

    attributes.duration = attributes.sourceduration;
  }

  var m3u8attributes = (_m3u8attributes = {
    name: attributes.id,
    bandwidth: attributes.bandwidth
  }, _m3u8attributes['program-id'] = 1, _m3u8attributes);

  if (attributes.codecs) {
    m3u8attributes.codecs = attributes.codecs;
  }

  return {
    attributes: m3u8attributes,
    uri: '',
    endlist: attributes.type === 'static',
    timeline: attributes.periodstart,
    resolveduri: attributes.baseurl || '',
    targetduration: attributes.duration,
    timelinestarts: attributes.timelinestarts,
    discontinuitystarts: discontinuitystarts,
    discontinuitysequence: discontinuitysequence,
    mediasequence: mediasequence,
    segments: segments
  };
};
var organizeaudioplaylists = function organizeaudioplaylists(playlists, sidxmapping, isaudioonly) {
  if (sidxmapping === void 0) {
    sidxmapping = {};
  }

  if (isaudioonly === void 0) {
    isaudioonly = false;
  }

  var mainplaylist;
  var formattedplaylists = playlists.reduce(function (a, playlist) {
    var role = playlist.attributes.role && playlist.attributes.role.value || '';
    var language = playlist.attributes.lang || '';
    var label = playlist.attributes.label || 'main';

    if (language && !playlist.attributes.label) {
      var rolelabel = role ? " (" + role + ")" : '';
      label = "" + playlist.attributes.lang + rolelabel;
    }

    if (!a[label]) {
      a[label] = {
        language: language,
        autoselect: true,
        default: role === 'main',
        playlists: [],
        uri: ''
      };
    }

    var formatted = addsidxsegmentstoplaylist(formataudioplaylist(playlist, isaudioonly), sidxmapping);
    a[label].playlists.push(formatted);

    if (typeof mainplaylist === 'undefined' && role === 'main') {
      mainplaylist = playlist;
      mainplaylist.default = true;
    }

    return a;
  }, {}); // if no playlists have role "main", mark the first as main

  if (!mainplaylist) {
    var firstlabel = object.keys(formattedplaylists)[0];
    formattedplaylists[firstlabel].default = true;
  }

  return formattedplaylists;
};
var organizevttplaylists = function organizevttplaylists(playlists, sidxmapping) {
  if (sidxmapping === void 0) {
    sidxmapping = {};
  }

  return playlists.reduce(function (a, playlist) {
    var label = playlist.attributes.lang || 'text';

    if (!a[label]) {
      a[label] = {
        language: label,
        default: false,
        autoselect: false,
        playlists: [],
        uri: ''
      };
    }

    a[label].playlists.push(addsidxsegmentstoplaylist(formatvttplaylist(playlist), sidxmapping));
    return a;
  }, {});
};

var organizecaptionservices = function organizecaptionservices(captionservices) {
  return captionservices.reduce(function (svcobj, svc) {
    if (!svc) {
      return svcobj;
    }

    svc.foreach(function (service) {
      var channel = service.channel,
          language = service.language;
      svcobj[language] = {
        autoselect: false,
        default: false,
        instreamid: channel,
        language: language
      };

      if (service.hasownproperty('aspectratio')) {
        svcobj[language].aspectratio = service.aspectratio;
      }

      if (service.hasownproperty('easyreader')) {
        svcobj[language].easyreader = service.easyreader;
      }

      if (service.hasownproperty('3d')) {
        svcobj[language]['3d'] = service['3d'];
      }
    });
    return svcobj;
  }, {});
};

var formatvideoplaylist = function formatvideoplaylist(_ref3) {
  var _attributes2;

  var attributes = _ref3.attributes,
      segments = _ref3.segments,
      sidx = _ref3.sidx,
      discontinuitystarts = _ref3.discontinuitystarts;
  var playlist = {
    attributes: (_attributes2 = {
      name: attributes.id,
      audio: 'audio',
      subtitles: 'subs',
      resolution: {
        width: attributes.width,
        height: attributes.height
      },
      codecs: attributes.codecs,
      bandwidth: attributes.bandwidth
    }, _attributes2['program-id'] = 1, _attributes2),
    uri: '',
    endlist: attributes.type === 'static',
    timeline: attributes.periodstart,
    resolveduri: '',
    targetduration: attributes.duration,
    discontinuitystarts: discontinuitystarts,
    timelinestarts: attributes.timelinestarts,
    segments: segments
  };

  if (attributes.contentprotection) {
    playlist.contentprotection = attributes.contentprotection;
  }

  if (sidx) {
    playlist.sidx = sidx;
  }

  return playlist;
};

var videoonly = function videoonly(_ref4) {
  var attributes = _ref4.attributes;
  return attributes.mimetype === 'video/mp4' || attributes.mimetype === 'video/webm' || attributes.contenttype === 'video';
};

var audioonly = function audioonly(_ref5) {
  var attributes = _ref5.attributes;
  return attributes.mimetype === 'audio/mp4' || attributes.mimetype === 'audio/webm' || attributes.contenttype === 'audio';
};

var vttonly = function vttonly(_ref6) {
  var attributes = _ref6.attributes;
  return attributes.mimetype === 'text/vtt' || attributes.contenttype === 'text';
};
/**
 * contains start and timeline properties denoting a timeline start. for dash, these will
 * be the same number.
 *
 * @typedef {object} timelinestart
 * @property {number} start - the start time of the timeline
 * @property {number} timeline - the timeline number
 */

/**
 * adds appropriate media and discontinuity sequence values to the segments and playlists.
 *
 * throughout mpd-parser, the `number` attribute is used in relation to `startnumber`, a
 * dash specific attribute used in constructing segment uri's from templates. however, from
 * an hls perspective, the `number` attribute on a segment would be its `mediasequence`
 * value, which should start at the original media sequence value (or 0) and increment by 1
 * for each segment thereafter. since dash's `startnumber` values are independent per
 * period, it doesn't make sense to use it for `number`. instead, assume everything starts
 * from a 0 mediasequence value and increment from there.
 *
 * note that vhs currently doesn't use the `number` property, but it can be helpful for
 * debugging and making sense of the manifest.
 *
 * for live playlists, to account for values increasing in manifests when periods are
 * removed on refreshes, merging logic should be used to update the numbers to their
 * appropriate values (to ensure they're sequential and increasing).
 *
 * @param {object[]} playlists - the playlists to update
 * @param {timelinestart[]} timelinestarts - the timeline starts for the manifest
 */


var addmediasequencevalues = function addmediasequencevalues(playlists, timelinestarts) {
  // increment all segments sequentially
  playlists.foreach(function (playlist) {
    playlist.mediasequence = 0;
    playlist.discontinuitysequence = findindex(timelinestarts, function (_ref7) {
      var timeline = _ref7.timeline;
      return timeline === playlist.timeline;
    });

    if (!playlist.segments) {
      return;
    }

    playlist.segments.foreach(function (segment, index) {
      segment.number = index;
    });
  });
};
/**
 * given a media group object, flattens all playlists within the media group into a single
 * array.
 *
 * @param {object} mediagroupobject - the media group object
 *
 * @return {object[]}
 *         the media group playlists
 */

var flattenmediagroupplaylists = function flattenmediagroupplaylists(mediagroupobject) {
  if (!mediagroupobject) {
    return [];
  }

  return object.keys(mediagroupobject).reduce(function (acc, label) {
    var labelcontents = mediagroupobject[label];
    return acc.concat(labelcontents.playlists);
  }, []);
};
var tom3u8 = function tom3u8(_ref8) {
  var _mediagroups;

  var dashplaylists = _ref8.dashplaylists,
      locations = _ref8.locations,
      _ref8$sidxmapping = _ref8.sidxmapping,
      sidxmapping = _ref8$sidxmapping === void 0 ? {} : _ref8$sidxmapping,
      previousmanifest = _ref8.previousmanifest;

  if (!dashplaylists.length) {
    return {};
  } // grab all main manifest attributes


  var _dashplaylists$0$attr = dashplaylists[0].attributes,
      duration = _dashplaylists$0$attr.sourceduration,
      type = _dashplaylists$0$attr.type,
      suggestedpresentationdelay = _dashplaylists$0$attr.suggestedpresentationdelay,
      minimumupdateperiod = _dashplaylists$0$attr.minimumupdateperiod;
  var videoplaylists = mergediscontiguousplaylists(dashplaylists.filter(videoonly)).map(formatvideoplaylist);
  var audioplaylists = mergediscontiguousplaylists(dashplaylists.filter(audioonly));
  var vttplaylists = mergediscontiguousplaylists(dashplaylists.filter(vttonly));
  var captions = dashplaylists.map(function (playlist) {
    return playlist.attributes.captionservices;
  }).filter(boolean);
  var manifest = {
    allowcache: true,
    discontinuitystarts: [],
    segments: [],
    endlist: true,
    mediagroups: (_mediagroups = {
      audio: {},
      video: {}
    }, _mediagroups['closed-captions'] = {}, _mediagroups.subtitles = {}, _mediagroups),
    uri: '',
    duration: duration,
    playlists: addsidxsegmentstoplaylists(videoplaylists, sidxmapping)
  };

  if (minimumupdateperiod >= 0) {
    manifest.minimumupdateperiod = minimumupdateperiod * 1000;
  }

  if (locations) {
    manifest.locations = locations;
  }

  if (type === 'dynamic') {
    manifest.suggestedpresentationdelay = suggestedpresentationdelay;
  }

  var isaudioonly = manifest.playlists.length === 0;
  var organizedaudiogroup = audioplaylists.length ? organizeaudioplaylists(audioplaylists, sidxmapping, isaudioonly) : null;
  var organizedvttgroup = vttplaylists.length ? organizevttplaylists(vttplaylists, sidxmapping) : null;
  var formattedplaylists = videoplaylists.concat(flattenmediagroupplaylists(organizedaudiogroup), flattenmediagroupplaylists(organizedvttgroup));
  var playlisttimelinestarts = formattedplaylists.map(function (_ref9) {
    var timelinestarts = _ref9.timelinestarts;
    return timelinestarts;
  });
  manifest.timelinestarts = getuniquetimelinestarts(playlisttimelinestarts);
  addmediasequencevalues(formattedplaylists, manifest.timelinestarts);

  if (organizedaudiogroup) {
    manifest.mediagroups.audio.audio = organizedaudiogroup;
  }

  if (organizedvttgroup) {
    manifest.mediagroups.subtitles.subs = organizedvttgroup;
  }

  if (captions.length) {
    manifest.mediagroups['closed-captions'].cc = organizecaptionservices(captions);
  }

  if (previousmanifest) {
    return positionmanifestontimeline({
      oldmanifest: previousmanifest,
      newmanifest: manifest
    });
  }

  return manifest;
};

/**
 * calculates the r (repetition) value for a live stream (for the final segment
 * in a manifest where the r value is negative 1)
 *
 * @param {object} attributes
 *        object containing all inherited attributes from parent elements with attribute
 *        names as keys
 * @param {number} time
 *        current time (typically the total time up until the final segment)
 * @param {number} duration
 *        duration property for the given <s />
 *
 * @return {number}
 *        r value to reach the end of the given period
 */
var getlivervalue = function getlivervalue(attributes, time, duration) {
  var now = attributes.now,
      clientoffset = attributes.clientoffset,
      availabilitystarttime = attributes.availabilitystarttime,
      _attributes$timescale = attributes.timescale,
      timescale = _attributes$timescale === void 0 ? 1 : _attributes$timescale,
      _attributes$periodsta = attributes.periodstart,
      periodstart = _attributes$periodsta === void 0 ? 0 : _attributes$periodsta,
      _attributes$minimumup = attributes.minimumupdateperiod,
      minimumupdateperiod = _attributes$minimumup === void 0 ? 0 : _attributes$minimumup;
  var now = (now + clientoffset) / 1000;
  var periodstartwc = availabilitystarttime + periodstart;
  var periodendwc = now + minimumupdateperiod;
  var periodduration = periodendwc - periodstartwc;
  return math.ceil((periodduration * timescale - time) / duration);
};
/**
 * uses information provided by segmenttemplate.segmenttimeline to determine segment
 * timing and duration
 *
 * @param {object} attributes
 *        object containing all inherited attributes from parent elements with attribute
 *        names as keys
 * @param {object[]} segmenttimeline
 *        list of objects representing the attributes of each s element contained within
 *
 * @return {{number: number, duration: number, time: number, timeline: number}[]}
 *         list of objects with segment timing and duration info
 */


var parsebytimeline = function parsebytimeline(attributes, segmenttimeline) {
  var type = attributes.type,
      _attributes$minimumup2 = attributes.minimumupdateperiod,
      minimumupdateperiod = _attributes$minimumup2 === void 0 ? 0 : _attributes$minimumup2,
      _attributes$media = attributes.media,
      media = _attributes$media === void 0 ? '' : _attributes$media,
      sourceduration = attributes.sourceduration,
      _attributes$timescale2 = attributes.timescale,
      timescale = _attributes$timescale2 === void 0 ? 1 : _attributes$timescale2,
      _attributes$startnumb = attributes.startnumber,
      startnumber = _attributes$startnumb === void 0 ? 1 : _attributes$startnumb,
      timeline = attributes.periodstart;
  var segments = [];
  var time = -1;

  for (var sindex = 0; sindex < segmenttimeline.length; sindex++) {
    var s = segmenttimeline[sindex];
    var duration = s.d;
    var repeat = s.r || 0;
    var segmenttime = s.t || 0;

    if (time < 0) {
      // first segment
      time = segmenttime;
    }

    if (segmenttime && segmenttime > time) {
      // discontinuity
      // todo: how to handle this type of discontinuity
      // timeline++ here would treat it like hls discontuity and content would
      // get appended without gap
      // e.g.
      //  <s t="0" d="1" />
      //  <s d="1" />
      //  <s d="1" />
      //  <s t="5" d="1" />
      // would have $time$ values of [0, 1, 2, 5]
      // should this be appened at time positions [0, 1, 2, 3],(#ext-x-discontinuity)
      // or [0, 1, 2, gap, gap, 5]? (#ext-x-gap)
      // does the value of sourceduration consider this when calculating arbitrary
      // negative @r repeat value?
      // e.g. same elements as above with this added at the end
      //  <s d="1" r="-1" />
      //  with a sourceduration of 10
      // would the 2 gaps be included in the time duration calculations resulting in
      // 8 segments with $time$ values of [0, 1, 2, 5, 6, 7, 8, 9] or 10 segments
      // with $time$ values of [0, 1, 2, 5, 6, 7, 8, 9, 10, 11] ?
      time = segmenttime;
    }

    var count = void 0;

    if (repeat < 0) {
      var nexts = sindex + 1;

      if (nexts === segmenttimeline.length) {
        // last segment
        if (type === 'dynamic' && minimumupdateperiod > 0 && media.indexof('$number$') > 0) {
          count = getlivervalue(attributes, time, duration);
        } else {
          // todo: this may be incorrect depending on conclusion of todo above
          count = (sourceduration * timescale - time) / duration;
        }
      } else {
        count = (segmenttimeline[nexts].t - time) / duration;
      }
    } else {
      count = repeat + 1;
    }

    var end = startnumber + segments.length + count;
    var number = startnumber + segments.length;

    while (number < end) {
      segments.push({
        number: number,
        duration: duration / timescale,
        time: time,
        timeline: timeline
      });
      time += duration;
      number++;
    }
  }

  return segments;
};

var identifierpattern = /\$([a-z]*)(?:(%0)([0-9]+)d)?\$/g;
/**
 * replaces template identifiers with corresponding values. to be used as the callback
 * for string.prototype.replace
 *
 * @name replacecallback
 * @function
 * @param {string} match
 *        entire match of identifier
 * @param {string} identifier
 *        name of matched identifier
 * @param {string} format
 *        format tag string. its presence indicates that padding is expected
 * @param {string} width
 *        desired length of the replaced value. values less than this width shall be left
 *        zero padded
 * @return {string}
 *         replacement for the matched identifier
 */

/**
 * returns a function to be used as a callback for string.prototype.replace to replace
 * template identifiers
 *
 * @param {obect} values
 *        object containing values that shall be used to replace known identifiers
 * @param {number} values.representationid
 *        value of the representation@id attribute
 * @param {number} values.number
 *        number of the corresponding segment
 * @param {number} values.bandwidth
 *        value of the representation@bandwidth attribute.
 * @param {number} values.time
 *        timestamp value of the corresponding segment
 * @return {replacecallback}
 *         callback to be used with string.prototype.replace to replace identifiers
 */

var identifierreplacement = function identifierreplacement(values) {
  return function (match, identifier, format, width) {
    if (match === '$$') {
      // escape sequence
      return '$';
    }

    if (typeof values[identifier] === 'undefined') {
      return match;
    }

    var value = '' + values[identifier];

    if (identifier === 'representationid') {
      // format tag shall not be present with representationid
      return value;
    }

    if (!format) {
      width = 1;
    } else {
      width = parseint(width, 10);
    }

    if (value.length >= width) {
      return value;
    }

    return "" + new array(width - value.length + 1).join('0') + value;
  };
};
/**
 * constructs a segment url from a template string
 *
 * @param {string} url
 *        template string to construct url from
 * @param {obect} values
 *        object containing values that shall be used to replace known identifiers
 * @param {number} values.representationid
 *        value of the representation@id attribute
 * @param {number} values.number
 *        number of the corresponding segment
 * @param {number} values.bandwidth
 *        value of the representation@bandwidth attribute.
 * @param {number} values.time
 *        timestamp value of the corresponding segment
 * @return {string}
 *         segment url with identifiers replaced
 */

var constructtemplateurl = function constructtemplateurl(url, values) {
  return url.replace(identifierpattern, identifierreplacement(values));
};
/**
 * generates a list of objects containing timing and duration information about each
 * segment needed to generate segment uris and the complete segment object
 *
 * @param {object} attributes
 *        object containing all inherited attributes from parent elements with attribute
 *        names as keys
 * @param {object[]|undefined} segmenttimeline
 *        list of objects representing the attributes of each s element contained within
 *        the segmenttimeline element
 * @return {{number: number, duration: number, time: number, timeline: number}[]}
 *         list of objects with segment timing and duration info
 */

var parsetemplateinfo = function parsetemplateinfo(attributes, segmenttimeline) {
  if (!attributes.duration && !segmenttimeline) {
    // if neither @duration or segmenttimeline are present, then there shall be exactly
    // one media segment
    return [{
      number: attributes.startnumber || 1,
      duration: attributes.sourceduration,
      time: 0,
      timeline: attributes.periodstart
    }];
  }

  if (attributes.duration) {
    return parsebyduration(attributes);
  }

  return parsebytimeline(attributes, segmenttimeline);
};
/**
 * generates a list of segments using information provided by the segmenttemplate element
 *
 * @param {object} attributes
 *        object containing all inherited attributes from parent elements with attribute
 *        names as keys
 * @param {object[]|undefined} segmenttimeline
 *        list of objects representing the attributes of each s element contained within
 *        the segmenttimeline element
 * @return {object[]}
 *         list of segment objects
 */

var segmentsfromtemplate = function segmentsfromtemplate(attributes, segmenttimeline) {
  var templatevalues = {
    representationid: attributes.id,
    bandwidth: attributes.bandwidth || 0
  };
  var _attributes$initializ = attributes.initialization,
      initialization = _attributes$initializ === void 0 ? {
    sourceurl: '',
    range: ''
  } : _attributes$initializ;
  var mapsegment = urltypetosegment({
    baseurl: attributes.baseurl,
    source: constructtemplateurl(initialization.sourceurl, templatevalues),
    range: initialization.range
  });
  var segments = parsetemplateinfo(attributes, segmenttimeline);
  return segments.map(function (segment) {
    templatevalues.number = segment.number;
    templatevalues.time = segment.time;
    var uri = constructtemplateurl(attributes.media || '', templatevalues); // see dash spec section 5.3.9.2.2
    // - if timescale isn't present on any level, default to 1.

    var timescale = attributes.timescale || 1; // - if presentationtimeoffset isn't present on any level, default to 0

    var presentationtimeoffset = attributes.presentationtimeoffset || 0;
    var presentationtime = // even if the @t attribute is not specified for the segment, segment.time is
    // calculated in mpd-parser prior to this, so it's assumed to be available.
    attributes.periodstart + (segment.time - presentationtimeoffset) / timescale;
    var map = {
      uri: uri,
      timeline: segment.timeline,
      duration: segment.duration,
      resolveduri: object(_videojs_vhs_utils_es_resolve_url__webpack_imported_module_0__[/* default */ "a"])(attributes.baseurl || '', uri),
      map: mapsegment,
      number: segment.number,
      presentationtime: presentationtime
    };
    return map;
  });
};

/**
 * converts a <segmenturl> (of type urltype from the dash spec 5.3.9.2 table 14)
 * to an object that matches the output of a segment in videojs/mpd-parser
 *
 * @param {object} attributes
 *   object containing all inherited attributes from parent elements with attribute
 *   names as keys
 * @param {object} segmenturl
 *   <segmenturl> node to translate into a segment object
 * @return {object} translated segment object
 */

var segmenturltosegmentobject = function segmenturltosegmentobject(attributes, segmenturl) {
  var baseurl = attributes.baseurl,
      _attributes$initializ = attributes.initialization,
      initialization = _attributes$initializ === void 0 ? {} : _attributes$initializ;
  var initsegment = urltypetosegment({
    baseurl: baseurl,
    source: initialization.sourceurl,
    range: initialization.range
  });
  var segment = urltypetosegment({
    baseurl: baseurl,
    source: segmenturl.media,
    range: segmenturl.mediarange
  });
  segment.map = initsegment;
  return segment;
};
/**
 * generates a list of segments using information provided by the segmentlist element
 * segmentlist (dash spec section 5.3.9.3.2) contains a set of <segmenturl> nodes.  each
 * node should be translated into segment.
 *
 * @param {object} attributes
 *   object containing all inherited attributes from parent elements with attribute
 *   names as keys
 * @param {object[]|undefined} segmenttimeline
 *        list of objects representing the attributes of each s element contained within
 *        the segmenttimeline element
 * @return {object.<array>} list of segments
 */


var segmentsfromlist = function segmentsfromlist(attributes, segmenttimeline) {
  var duration = attributes.duration,
      _attributes$segmentur = attributes.segmenturls,
      segmenturls = _attributes$segmentur === void 0 ? [] : _attributes$segmentur,
      periodstart = attributes.periodstart; // per spec (5.3.9.2.1) no way to determine segment duration or
  // if both segmenttimeline and @duration are defined, it is outside of spec.

  if (!duration && !segmenttimeline || duration && segmenttimeline) {
    throw new error(errors.segment_time_unspecified);
  }

  var segmenturlmap = segmenturls.map(function (segmenturlobject) {
    return segmenturltosegmentobject(attributes, segmenturlobject);
  });
  var segmenttimeinfo;

  if (duration) {
    segmenttimeinfo = parsebyduration(attributes);
  }

  if (segmenttimeline) {
    segmenttimeinfo = parsebytimeline(attributes, segmenttimeline);
  }

  var segments = segmenttimeinfo.map(function (segmenttime, index) {
    if (segmenturlmap[index]) {
      var segment = segmenturlmap[index]; // see dash spec section 5.3.9.2.2
      // - if timescale isn't present on any level, default to 1.

      var timescale = attributes.timescale || 1; // - if presentationtimeoffset isn't present on any level, default to 0

      var presentationtimeoffset = attributes.presentationtimeoffset || 0;
      segment.timeline = segmenttime.timeline;
      segment.duration = segmenttime.duration;
      segment.number = segmenttime.number;
      segment.presentationtime = periodstart + (segmenttime.time - presentationtimeoffset) / timescale;
      return segment;
    } // since we're mapping we should get rid of any blank segments (in case
    // the given segmenttimeline is handling for more elements than we have
    // segmenturls for).

  }).filter(function (segment) {
    return segment;
  });
  return segments;
};

var generatesegments = function generatesegments(_ref) {
  var attributes = _ref.attributes,
      segmentinfo = _ref.segmentinfo;
  var segmentattributes;
  var segmentsfn;

  if (segmentinfo.template) {
    segmentsfn = segmentsfromtemplate;
    segmentattributes = merge(attributes, segmentinfo.template);
  } else if (segmentinfo.base) {
    segmentsfn = segmentsfrombase;
    segmentattributes = merge(attributes, segmentinfo.base);
  } else if (segmentinfo.list) {
    segmentsfn = segmentsfromlist;
    segmentattributes = merge(attributes, segmentinfo.list);
  }

  var segmentsinfo = {
    attributes: attributes
  };

  if (!segmentsfn) {
    return segmentsinfo;
  }

  var segments = segmentsfn(segmentattributes, segmentinfo.segmenttimeline); // the @duration attribute will be used to determin the playlist's targetduration which
  // must be in seconds. since we've generated the segment list, we no longer need
  // @duration to be in @timescale units, so we can convert it here.

  if (segmentattributes.duration) {
    var _segmentattributes = segmentattributes,
        duration = _segmentattributes.duration,
        _segmentattributes$ti = _segmentattributes.timescale,
        timescale = _segmentattributes$ti === void 0 ? 1 : _segmentattributes$ti;
    segmentattributes.duration = duration / timescale;
  } else if (segments.length) {
    // if there is no @duration attribute, use the largest segment duration as
    // as target duration
    segmentattributes.duration = segments.reduce(function (max, segment) {
      return math.max(max, math.ceil(segment.duration));
    }, 0);
  } else {
    segmentattributes.duration = 0;
  }

  segmentsinfo.attributes = segmentattributes;
  segmentsinfo.segments = segments; // this is a sidx box without actual segment information

  if (segmentinfo.base && segmentattributes.indexrange) {
    segmentsinfo.sidx = segments[0];
    segmentsinfo.segments = [];
  }

  return segmentsinfo;
};
var toplaylists = function toplaylists(representations) {
  return representations.map(generatesegments);
};

var findchildren = function findchildren(element, name) {
  return from(element.childnodes).filter(function (_ref) {
    var tagname = _ref.tagname;
    return tagname === name;
  });
};
var getcontent = function getcontent(element) {
  return element.textcontent.trim();
};

var parseduration = function parseduration(str) {
  var seconds_in_year = 365 * 24 * 60 * 60;
  var seconds_in_month = 30 * 24 * 60 * 60;
  var seconds_in_day = 24 * 60 * 60;
  var seconds_in_hour = 60 * 60;
  var seconds_in_min = 60; // p10y10m10dt10h10m10.1s

  var durationregex = /p(?:(\d*)y)?(?:(\d*)m)?(?:(\d*)d)?(?:t(?:(\d*)h)?(?:(\d*)m)?(?:([\d.]*)s)?)?/;
  var match = durationregex.exec(str);

  if (!match) {
    return 0;
  }

  var _match$slice = match.slice(1),
      year = _match$slice[0],
      month = _match$slice[1],
      day = _match$slice[2],
      hour = _match$slice[3],
      minute = _match$slice[4],
      second = _match$slice[5];

  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);
};
var parsedate = function parsedate(str) {
  // date format without timezone according to iso 8601
  // yyy-mm-ddthh:mm:ss.ssssss
  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
  // expressed by ending with 'z'

  if (dateregex.test(str)) {
    str += 'z';
  }

  return date.parse(str);
};

var parsers = {
  /**
   * specifies the duration of the entire media presentation. format is a duration string
   * as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the duration in seconds
   */
  mediapresentationduration: function mediapresentationduration(value) {
    return parseduration(value);
  },

  /**
   * specifies the segment availability start time for all segments referred to in this
   * mpd. for a dynamic manifest, it specifies the anchor for the earliest availability
   * time. format is a date string as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the date as seconds from unix epoch
   */
  availabilitystarttime: function availabilitystarttime(value) {
    return parsedate(value) / 1000;
  },

  /**
   * specifies the smallest period between potential changes to the mpd. format is a
   * duration string as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the duration in seconds
   */
  minimumupdateperiod: function minimumupdateperiod(value) {
    return parseduration(value);
  },

  /**
   * specifies the suggested presentation delay. format is a
   * duration string as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the duration in seconds
   */
  suggestedpresentationdelay: function suggestedpresentationdelay(value) {
    return parseduration(value);
  },

  /**
   * specifices the type of mpd. can be either "static" or "dynamic"
   *
   * @param {string} value
   *        value of attribute as a string
   *
   * @return {string}
   *         the type as a string
   */
  type: function type(value) {
    return value;
  },

  /**
   * specifies the duration of the smallest time shifting buffer for any representation
   * in the mpd. format is a duration string as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the duration in seconds
   */
  timeshiftbufferdepth: function timeshiftbufferdepth(value) {
    return parseduration(value);
  },

  /**
   * specifies the periodstart time of the period relative to the availabilitystarttime.
   * format is a duration string as specified in iso 8601
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the duration in seconds
   */
  start: function start(value) {
    return parseduration(value);
  },

  /**
   * specifies the width of the visual presentation
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed width
   */
  width: function width(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the height of the visual presentation
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed height
   */
  height: function height(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the bitrate of the representation
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed bandwidth
   */
  bandwidth: function bandwidth(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the number of the first media segment in this representation in the period
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed number
   */
  startnumber: function startnumber(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the timescale in units per seconds
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed timescale
   */
  timescale: function timescale(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the presentationtimeoffset.
   *
   * @param {string} value
   *        value of the attribute as a string
   *
   * @return {number}
   *         the parsed presentationtimeoffset
   */
  presentationtimeoffset: function presentationtimeoffset(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the constant approximate segment duration
   * note: the <period> element also contains an @duration attribute. this duration
   *       specifies the duration of the period. this attribute is currently not
   *       supported by the rest of the parser, however we still check for it to prevent
   *       errors.
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed duration
   */
  duration: function duration(value) {
    var parsedvalue = parseint(value, 10);

    if (isnan(parsedvalue)) {
      return parseduration(value);
    }

    return parsedvalue;
  },

  /**
   * specifies the segment duration, in units of the value of the @timescale.
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed duration
   */
  d: function d(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the mpd start time, in @timescale units, the first segment in the series
   * starts relative to the beginning of the period
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed time
   */
  t: function t(value) {
    return parseint(value, 10);
  },

  /**
   * specifies the repeat count of the number of following contiguous segments with the
   * same duration expressed by the value of @d
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {number}
   *         the parsed number
   */
  r: function r(value) {
    return parseint(value, 10);
  },

  /**
   * default parser for all other attributes. acts as a no-op and just returns the value
   * as a string
   *
   * @param {string} value
   *        value of attribute as a string
   * @return {string}
   *         unparsed value
   */
  default: function default(value) {
    return value;
  }
};
/**
 * gets all the attributes and values of the provided node, parses attributes with known
 * types, and returns an object with attribute names mapped to values.
 *
 * @param {node} el
 *        the node to parse attributes from
 * @return {object}
 *         object with all attributes of el parsed
 */

var parseattributes = function parseattributes(el) {
  if (!(el && el.attributes)) {
    return {};
  }

  return from(el.attributes).reduce(function (a, e) {
    var parsefn = parsers[e.name] || parsers.default;
    a[e.name] = parsefn(e.value);
    return a;
  }, {});
};

var keysystemsmap = {
  'urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b': 'org.w3.clearkey',
  'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed': 'com.widevine.alpha',
  'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready',
  'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb': 'com.adobe.primetime'
};
/**
 * builds a list of urls that is the product of the reference urls and baseurl values
 *
 * @param {string[]} referenceurls
 *        list of reference urls to resolve to
 * @param {node[]} baseurlelements
 *        list of baseurl nodes from the mpd
 * @return {string[]}
 *         list of resolved urls
 */

var buildbaseurls = function buildbaseurls(referenceurls, baseurlelements) {
  if (!baseurlelements.length) {
    return referenceurls;
  }

  return flatten(referenceurls.map(function (reference) {
    return baseurlelements.map(function (baseurlelement) {
      return object(_videojs_vhs_utils_es_resolve_url__webpack_imported_module_0__[/* default */ "a"])(reference, getcontent(baseurlelement));
    });
  }));
};
/**
 * contains all segment information for its containing adaptationset
 *
 * @typedef {object} segmentinformation
 * @property {object|undefined} template
 *           contains the attributes for the segmenttemplate node
 * @property {object[]|undefined} segmenttimeline
 *           contains a list of atrributes for each s node within the segmenttimeline node
 * @property {object|undefined} list
 *           contains the attributes for the segmentlist node
 * @property {object|undefined} base
 *           contains the attributes for the segmentbase node
 */

/**
 * returns all available segment information contained within the adaptationset node
 *
 * @param {node} adaptationset
 *        the adaptationset node to get segment information from
 * @return {segmentinformation}
 *         the segment information contained within the provided adaptationset
 */

var getsegmentinformation = function getsegmentinformation(adaptationset) {
  var segmenttemplate = findchildren(adaptationset, 'segmenttemplate')[0];
  var segmentlist = findchildren(adaptationset, 'segmentlist')[0];
  var segmenturls = segmentlist && findchildren(segmentlist, 'segmenturl').map(function (s) {
    return merge({
      tag: 'segmenturl'
    }, parseattributes(s));
  });
  var segmentbase = findchildren(adaptationset, 'segmentbase')[0];
  var segmenttimelineparentnode = segmentlist || segmenttemplate;
  var segmenttimeline = segmenttimelineparentnode && findchildren(segmenttimelineparentnode, 'segmenttimeline')[0];
  var segmentinitializationparentnode = segmentlist || segmentbase || segmenttemplate;
  var segmentinitialization = segmentinitializationparentnode && findchildren(segmentinitializationparentnode, 'initialization')[0]; // segmenttemplate is handled slightly differently, since it can have both
  // @initialization and an <initialization> node.  @initialization can be templated,
  // while the node can have a url and range specified.  if the <segmenttemplate> has
  // both @initialization and an <initialization> subelement we opt to override with
  // the node, as this interaction is not defined in the spec.

  var template = segmenttemplate && parseattributes(segmenttemplate);

  if (template && segmentinitialization) {
    template.initialization = segmentinitialization && parseattributes(segmentinitialization);
  } else if (template && template.initialization) {
    // if it is @initialization we convert it to an object since this is the format that
    // later functions will rely on for the initialization segment.  this is only valid
    // for <segmenttemplate>
    template.initialization = {
      sourceurl: template.initialization
    };
  }

  var segmentinfo = {
    template: template,
    segmenttimeline: segmenttimeline && findchildren(segmenttimeline, 's').map(function (s) {
      return parseattributes(s);
    }),
    list: segmentlist && merge(parseattributes(segmentlist), {
      segmenturls: segmenturls,
      initialization: parseattributes(segmentinitialization)
    }),
    base: segmentbase && merge(parseattributes(segmentbase), {
      initialization: parseattributes(segmentinitialization)
    })
  };
  object.keys(segmentinfo).foreach(function (key) {
    if (!segmentinfo[key]) {
      delete segmentinfo[key];
    }
  });
  return segmentinfo;
};
/**
 * contains segment information and attributes needed to construct a playlist object
 * from a representation
 *
 * @typedef {object} representationinformation
 * @property {segmentinformation} segmentinfo
 *           segment information for this representation
 * @property {object} attributes
 *           inherited attributes for this representation
 */

/**
 * maps a representation node to an object containing segment information and attributes
 *
 * @name inheritbaseurlscallback
 * @function
 * @param {node} representation
 *        representation node from the mpd
 * @return {representationinformation}
 *         representation information needed to construct a playlist object
 */

/**
 * returns a callback for array.prototype.map for mapping representation nodes to
 * segment information and attributes using inherited baseurl nodes.
 *
 * @param {object} adaptationsetattributes
 *        contains attributes inherited by the adaptationset
 * @param {string[]} adaptationsetbaseurls
 *        contains list of resolved base urls inherited by the adaptationset
 * @param {segmentinformation} adaptationsetsegmentinfo
 *        contains segment information for the adaptationset
 * @return {inheritbaseurlscallback}
 *         callback map function
 */

var inheritbaseurls = function inheritbaseurls(adaptationsetattributes, adaptationsetbaseurls, adaptationsetsegmentinfo) {
  return function (representation) {
    var repbaseurlelements = findchildren(representation, 'baseurl');
    var repbaseurls = buildbaseurls(adaptationsetbaseurls, repbaseurlelements);
    var attributes = merge(adaptationsetattributes, parseattributes(representation));
    var representationsegmentinfo = getsegmentinformation(representation);
    return repbaseurls.map(function (baseurl) {
      return {
        segmentinfo: merge(adaptationsetsegmentinfo, representationsegmentinfo),
        attributes: merge(attributes, {
          baseurl: baseurl
        })
      };
    });
  };
};
/**
 * tranforms a series of content protection nodes to
 * an object containing pssh data by key system
 *
 * @param {node[]} contentprotectionnodes
 *        content protection nodes
 * @return {object}
 *        object containing pssh data by key system
 */

var generatekeysysteminformation = function generatekeysysteminformation(contentprotectionnodes) {
  return contentprotectionnodes.reduce(function (acc, node) {
    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
    // as a lowercase string it also mentions it should be treated as case-insensitive on input. since the key system
    // uuids in the keysystemsmap are hardcoded as lowercase in the codebase there isn't any reason not to do
    // .tolowercase() on the input uuid string from the manifest (at least i could not think of one).

    if (attributes.schemeiduri) {
      attributes.schemeiduri = attributes.schemeiduri.tolowercase();
    }

    var keysystem = keysystemsmap[attributes.schemeiduri];

    if (keysystem) {
      acc[keysystem] = {
        attributes: attributes
      };
      var psshnode = findchildren(node, 'cenc:pssh')[0];

      if (psshnode) {
        var pssh = getcontent(psshnode);
        acc[keysystem].pssh = pssh && object(_videojs_vhs_utils_es_decode_b64_to_uint8_array__webpack_imported_module_3__[/* default */ "a"])(pssh);
      }
    }

    return acc;
  }, {});
}; // defined in ansi_scte 214-1 2016


var parsecaptionservicemetadata = function parsecaptionservicemetadata(service) {
  // 608 captions
  if (service.schemeiduri === 'urn:scte:dash:cc:cea-608:2015') {
    var values = typeof service.value !== 'string' ? [] : service.value.split(';');
    return values.map(function (value) {
      var channel;
      var language; // default language to value

      language = value;

      if (/^cc\d=/.test(value)) {
        var _value$split = value.split('=');

        channel = _value$split[0];
        language = _value$split[1];
      } else if (/^cc\d$/.test(value)) {
        channel = value;
      }

      return {
        channel: channel,
        language: language
      };
    });
  } else if (service.schemeiduri === 'urn:scte:dash:cc:cea-708:2015') {
    var _values = typeof service.value !== 'string' ? [] : service.value.split(';');

    return _values.map(function (value) {
      var flags = {
        // service or channel number 1-63
        'channel': undefined,
        // language is a 3alpha per iso 639.2/b
        // field is required
        'language': undefined,
        // bit 1/0 or ?
        // default value is 1, meaning 16:9 aspect ratio, 0 is 4:3, ? is unknown
        'aspectratio': 1,
        // bit 1/0
        // easy reader flag indicated the text is tailed to the needs of beginning readers
        // default 0, or off
        'easyreader': 0,
        // bit 1/0
        // if 3d metadata is present (cea-708.1) then 1
        // default 0
        '3d': 0
      };

      if (/=/.test(value)) {
        var _value$split2 = value.split('='),
            channel = _value$split2[0],
            _value$split2$ = _value$split2[1],
            opts = _value$split2$ === void 0 ? '' : _value$split2$;

        flags.channel = channel;
        flags.language = value;
        opts.split(',').foreach(function (opt) {
          var _opt$split = opt.split(':'),
              name = _opt$split[0],
              val = _opt$split[1];

          if (name === 'lang') {
            flags.language = val; // er for easyreadery
          } else if (name === 'er') {
            flags.easyreader = number(val); // war for wide aspect ratio
          } else if (name === 'war') {
            flags.aspectratio = number(val);
          } else if (name === '3d') {
            flags['3d'] = number(val);
          }
        });
      } else {
        flags.language = value;
      }

      if (flags.channel) {
        flags.channel = 'service' + flags.channel;
      }

      return flags;
    });
  }
};
/**
 * maps an adaptationset node to a list of representation information objects
 *
 * @name torepresentationscallback
 * @function
 * @param {node} adaptationset
 *        adaptationset node from the mpd
 * @return {representationinformation[]}
 *         list of objects containing representaion information
 */

/**
 * returns a callback for array.prototype.map for mapping adaptationset nodes to a list of
 * representation information objects
 *
 * @param {object} periodattributes
 *        contains attributes inherited by the period
 * @param {string[]} periodbaseurls
 *        contains list of resolved base urls inherited by the period
 * @param {string[]} periodsegmentinfo
 *        contains segment information at the period level
 * @return {torepresentationscallback}
 *         callback map function
 */

var torepresentations = function torepresentations(periodattributes, periodbaseurls, periodsegmentinfo) {
  return function (adaptationset) {
    var adaptationsetattributes = parseattributes(adaptationset);
    var adaptationsetbaseurls = buildbaseurls(periodbaseurls, findchildren(adaptationset, 'baseurl'));
    var role = findchildren(adaptationset, 'role')[0];
    var roleattributes = {
      role: parseattributes(role)
    };
    var attrs = merge(periodattributes, adaptationsetattributes, roleattributes);
    var accessibility = findchildren(adaptationset, 'accessibility')[0];
    var captionservices = parsecaptionservicemetadata(parseattributes(accessibility));

    if (captionservices) {
      attrs = merge(attrs, {
        captionservices: captionservices
      });
    }

    var label = findchildren(adaptationset, 'label')[0];

    if (label && label.childnodes.length) {
      var labelval = label.childnodes[0].nodevalue.trim();
      attrs = merge(attrs, {
        label: labelval
      });
    }

    var contentprotection = generatekeysysteminformation(findchildren(adaptationset, 'contentprotection'));

    if (object.keys(contentprotection).length) {
      attrs = merge(attrs, {
        contentprotection: contentprotection
      });
    }

    var segmentinfo = getsegmentinformation(adaptationset);
    var representations = findchildren(adaptationset, 'representation');
    var adaptationsetsegmentinfo = merge(periodsegmentinfo, segmentinfo);
    return flatten(representations.map(inheritbaseurls(attrs, adaptationsetbaseurls, adaptationsetsegmentinfo)));
  };
};
/**
 * contains all period information for mapping nodes onto adaptation sets.
 *
 * @typedef {object} periodinformation
 * @property {node} period.node
 *           period node from the mpd
 * @property {object} period.attributes
 *           parsed period attributes from node plus any added
 */

/**
 * maps a periodinformation object to a list of representation information objects for all
 * adaptationset nodes contained within the period.
 *
 * @name toadaptationsetscallback
 * @function
 * @param {periodinformation} period
 *        period object containing necessary period information
 * @param {number} periodstart
 *        start time of the period within the mpd
 * @return {representationinformation[]}
 *         list of objects containing representaion information
 */

/**
 * returns a callback for array.prototype.map for mapping period nodes to a list of
 * representation information objects
 *
 * @param {object} mpdattributes
 *        contains attributes inherited by the mpd
 * @param {string[]} mpdbaseurls
 *        contains list of resolved base urls inherited by the mpd
 * @return {toadaptationsetscallback}
 *         callback map function
 */

var toadaptationsets = function toadaptationsets(mpdattributes, mpdbaseurls) {
  return function (period, index) {
    var periodbaseurls = buildbaseurls(mpdbaseurls, findchildren(period.node, 'baseurl'));
    var periodattributes = merge(mpdattributes, {
      periodstart: period.attributes.start
    });

    if (typeof period.attributes.duration === 'number') {
      periodattributes.periodduration = period.attributes.duration;
    }

    var adaptationsets = findchildren(period.node, 'adaptationset');
    var periodsegmentinfo = getsegmentinformation(period.node);
    return flatten(adaptationsets.map(torepresentations(periodattributes, periodbaseurls, periodsegmentinfo)));
  };
};
/**
 * gets period@start property for a given period.
 *
 * @param {object} options
 *        options object
 * @param {object} options.attributes
 *        period attributes
 * @param {object} [options.priorperiodattributes]
 *        prior period attributes (if prior period is available)
 * @param {string} options.mpdtype
 *        the mpd@type these periods came from
 * @return {number|null}
 *         the period start, or null if it's an early available period or error
 */

var getperiodstart = function getperiodstart(_ref) {
  var attributes = _ref.attributes,
      priorperiodattributes = _ref.priorperiodattributes,
      mpdtype = _ref.mpdtype;

  // summary of period start time calculation from dash spec section 5.3.2.1
  //
  // a period's start is the first period's start + time elapsed after playing all
  // prior periods to this one. periods continue one after the other in time (without
  // gaps) until the end of the presentation.
  //
  // the value of period@start should be:
  // 1. if period@start is present: value of period@start
  // 2. if previous period exists and it has @duration: previous period@start +
  //    previous period@duration
  // 3. if this is first period and mpd@type is 'static': 0
  // 4. in all other cases, consider the period an "early available period" (note: not
  //    currently supported)
  // (1)
  if (typeof attributes.start === 'number') {
    return attributes.start;
  } // (2)


  if (priorperiodattributes && typeof priorperiodattributes.start === 'number' && typeof priorperiodattributes.duration === 'number') {
    return priorperiodattributes.start + priorperiodattributes.duration;
  } // (3)


  if (!priorperiodattributes && mpdtype === 'static') {
    return 0;
  } // (4)
  // there is currently no logic for calculating the period@start value if there is
  // no period@start or prior period@start and period@duration available. this is not made
  // explicit by the dash interop guidelines or the dash spec, however, since there's
  // nothing about any other resolution strategies, it's implied. thus, this case should
  // be considered an early available period, or error, and null should suffice for both
  // of those cases.


  return null;
};
/**
 * traverses the mpd xml tree to generate a list of representation information objects
 * that have inherited attributes from parent nodes
 *
 * @param {node} mpd
 *        the root node of the mpd
 * @param {object} options
 *        available options for inheritattributes
 * @param {string} options.manifesturi
 *        the uri source of the mpd
 * @param {number} options.now
 *        current time per dash iop.  default is current time in ms since epoch
 * @param {number} options.clientoffset
 *        client time difference from now (in milliseconds)
 * @return {representationinformation[]}
 *         list of objects containing representation information
 */

var inheritattributes = function inheritattributes(mpd, options) {
  if (options === void 0) {
    options = {};
  }

  var _options = options,
      _options$manifesturi = _options.manifesturi,
      manifesturi = _options$manifesturi === void 0 ? '' : _options$manifesturi,
      _options$now = _options.now,
      now = _options$now === void 0 ? date.now() : _options$now,
      _options$clientoffset = _options.clientoffset,
      clientoffset = _options$clientoffset === void 0 ? 0 : _options$clientoffset;
  var periodnodes = findchildren(mpd, 'period');

  if (!periodnodes.length) {
    throw new error(errors.invalid_number_of_period);
  }

  var locations = findchildren(mpd, 'location');
  var mpdattributes = parseattributes(mpd);
  var mpdbaseurls = buildbaseurls([manifesturi], findchildren(mpd, 'baseurl')); // see dash spec section 5.3.1.2, semantics of mpd element. default type to 'static'.

  mpdattributes.type = mpdattributes.type || 'static';
  mpdattributes.sourceduration = mpdattributes.mediapresentationduration || 0;
  mpdattributes.now = now;
  mpdattributes.clientoffset = clientoffset;

  if (locations.length) {
    mpdattributes.locations = locations.map(getcontent);
  }

  var periods = []; // since toadaptationsets acts on individual periods right now, the simplest approach to
  // adding properties that require looking at prior periods is to parse attributes and add
  // missing ones before toadaptationsets is called. if more such properties are added, it
  // may be better to refactor toadaptationsets.

  periodnodes.foreach(function (node, index) {
    var attributes = parseattributes(node); // use the last modified prior period, as it may contain added information necessary
    // for this period.

    var priorperiod = periods[index - 1];
    attributes.start = getperiodstart({
      attributes: attributes,
      priorperiodattributes: priorperiod ? priorperiod.attributes : null,
      mpdtype: mpdattributes.type
    });
    periods.push({
      node: node,
      attributes: attributes
    });
  });
  return {
    locations: mpdattributes.locations,
    representationinfo: flatten(periods.map(toadaptationsets(mpdattributes, mpdbaseurls)))
  };
};

var stringtompdxml = function stringtompdxml(manifeststring) {
  if (manifeststring === '') {
    throw new error(errors.dash_empty_manifest);
  }

  var parser = new _xmldom_xmldom__webpack_imported_module_4__["domparser"]();
  var xml;
  var mpd;

  try {
    xml = parser.parsefromstring(manifeststring, 'application/xml');
    mpd = xml && xml.documentelement.tagname === 'mpd' ? xml.documentelement : null;
  } catch (e) {// ie 11 throwsw on invalid xml
  }

  if (!mpd || mpd && mpd.getelementsbytagname('parsererror').length > 0) {
    throw new error(errors.dash_invalid_xml);
  }

  return mpd;
};

/**
 * parses the manifest for a utctiming node, returning the nodes attributes if found
 *
 * @param {string} mpd
 *        xml string of the mpd manifest
 * @return {object|null}
 *         attributes of utctiming node specified in the manifest. null if none found
 */

var parseutctimingscheme = function parseutctimingscheme(mpd) {
  var utctimingnode = findchildren(mpd, 'utctiming')[0];

  if (!utctimingnode) {
    return null;
  }

  var attributes = parseattributes(utctimingnode);

  switch (attributes.schemeiduri) {
    case 'urn:mpeg:dash:utc:http-head:2014':
    case 'urn:mpeg:dash:utc:http-head:2012':
      attributes.method = 'head';
      break;

    case 'urn:mpeg:dash:utc:http-xsdate:2014':
    case 'urn:mpeg:dash:utc:http-iso:2014':
    case 'urn:mpeg:dash:utc:http-xsdate:2012':
    case 'urn:mpeg:dash:utc:http-iso:2012':
      attributes.method = 'get';
      break;

    case 'urn:mpeg:dash:utc:direct:2014':
    case 'urn:mpeg:dash:utc:direct:2012':
      attributes.method = 'direct';
      attributes.value = date.parse(attributes.value);
      break;

    case 'urn:mpeg:dash:utc:http-ntp:2014':
    case 'urn:mpeg:dash:utc:ntp:2014':
    case 'urn:mpeg:dash:utc:sntp:2014':
    default:
      throw new error(errors.unsupported_utc_timing_scheme);
  }

  return attributes;
};

var version = version;
/*
 * given a dash manifest string and options, parses the dash manifest into an object in the
 * form outputed by m3u8-parser and accepted by videojs/http-streaming.
 *
 * for live dash manifests, if `previousmanifest` is provided in options, then the newly
 * parsed dash manifest will have its media sequence and discontinuity sequence values
 * updated to reflect its position relative to the prior manifest.
 *
 * @param {string} manifeststring - the dash manifest as a string
 * @param {options} [options] - any options
 *
 * @return {object} the manifest object
 */

var parse = function parse(manifeststring, options) {
  if (options === void 0) {
    options = {};
  }

  var parsedmanifestinfo = inheritattributes(stringtompdxml(manifeststring), options);
  var playlists = toplaylists(parsedmanifestinfo.representationinfo);
  return tom3u8({
    dashplaylists: playlists,
    locations: parsedmanifestinfo.locations,
    sidxmapping: options.sidxmapping,
    previousmanifest: options.previousmanifest
  });
};
/**
 * parses the manifest for a utctiming node, returning the nodes attributes if found
 *
 * @param {string} manifeststring
 *        xml string of the mpd manifest
 * @return {object|null}
 *         attributes of utctiming node specified in the manifest. null if none found
 */


var parseutctiming = function parseutctiming(manifeststring) {
  return parseutctimingscheme(stringtompdxml(manifeststring));
};




/***/ }),

/***/ 64:
/***/ (function(module, exports) {

/**
 * mux.js
 *
 * copyright (c) brightcove
 * licensed apache-2.0 https://github.com/videojs/mux.js/blob/master/license
 */
var
  one_second_in_ts = 90000, // 90khz clock
  secondstovideots,
  secondstoaudiots,
  videotstoseconds,
  audiotstoseconds,
  audiotstovideots,
  videotstoaudiots,
  metadatatstoseconds;

secondstovideots = function(seconds) {
  return seconds * one_second_in_ts;
};

secondstoaudiots = function(seconds, samplerate) {
  return seconds * samplerate;
};

videotstoseconds = function(timestamp) {
  return timestamp / one_second_in_ts;
};

audiotstoseconds = function(timestamp, samplerate) {
  return timestamp / samplerate;
};

audiotstovideots = function(timestamp, samplerate) {
  return secondstovideots(audiotstoseconds(timestamp, samplerate));
};

videotstoaudiots = function(timestamp, samplerate) {
  return secondstoaudiots(videotstoseconds(timestamp), samplerate);
};

/**
 * adjust id3 tag or caption timing information by the timeline pts values
 * (if keeporiginaltimestamps is false) and convert to seconds
 */
metadatatstoseconds = function(timestamp, timelinestartpts, keeporiginaltimestamps) {
  return videotstoseconds(keeporiginaltimestamps ? timestamp : timestamp - timelinestartpts);
};

module.exports = {
  one_second_in_ts: one_second_in_ts,
  secondstovideots: secondstovideots,
  secondstoaudiots: secondstoaudiots,
  videotstoseconds: videotstoseconds,
  audiotstoseconds: audiotstoseconds,
  audiotstovideots: audiotstovideots,
  videotstoaudiots: videotstoaudiots,
  metadatatstoseconds: metadatatstoseconds
};


/***/ })

}]);