https://www.classicon.com/files/theme/js/video-js/videojs-http-streaming.js?v=1981966a

136                  if (!relativeParts.query) {
137                    builtParts.query = baseParts.query;
138                  }
139                }
140              } else {
141                // 6) The last segment of the base URL's path (anything
142                // following the rightmost slash "/", or the entire path if no
143                // slash is present) is removed and the embedded URL's path is
144                // appended in its place.
145                var baseURLPath = baseParts.path;
146                var newPath = baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) + relativeParts.path;
147                builtParts.path = URLToolkit.normalizePath(newPath);
148              }
149            }
150          }
151
152          if (builtParts.path === null) {
153            builtParts.path = opts.alwaysNormalize ? URLToolkit.normalizePath(relativeParts.path) : relativeParts.path;
154          }
155
156          return URLToolkit.buildURLFromParts(builtParts);
157        },
158        parseURL: function (url) {
159          var parts = URL_REGEX.exec(url);
160
161          if (!parts) {
162            return null;
163          }
164
165          return {
166            scheme: parts[1] || '',
167            netLoc: parts[2] || '',
168            path: parts[3] || '',
169            params: parts[4] || '',
170            query: parts[5] || '',
171            fragment: parts[6] || ''
172          };
173        },
174        normalizePath: function (path) {
175          // The following operations are
176          // then applied, in order, to the new path:
177          // 6a) All occurrences of "./", where "." is a complete path
178          // segment, are removed.
179          // 6b) If the path ends with "." as a complete path segment,
180          // that "." is removed.
181          path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, ''); // 6c) All occurrences of "<segment>/../", where <segment> is a
182          // complete path segment not equal to "..", are removed.
183          // Removal of these path segments is performed iteratively,
184          // removing the leftmost matching pattern on each iteration,
185          // until no matching pattern remains.
186          // 6d) If the path ends with "<segment>/..", where <segment> is a
187          // complete path segment not equal to "..", that
188          // "<segment>/.." is removed.
189
190          while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) {}
191
192          return path.split('').reverse().join('');
193        },
194        buildURLFromParts: function (parts) {
195          return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
196        }
197      };
198      module.exports = URLToolkit;
199    })();
200  })(urlToolkit);
201
202  var URLToolkit = urlToolkit.exports;
203
204  var DEFAULT_LOCATION = 'http://example.com';
205
206  var resolveUrl$1 = function resolveUrl(baseUrl, relativeUrl) {
207    // return early if we don't need to resolve
208    if (/^[a-z]+:/i.test(relativeUrl)) {
209      return relativeUrl;
210    } // if baseUrl is a data URI, ignore it and resolve everything relative to window.location
211
212
213    if (/^data:/.test(baseUrl)) {
214      baseUrl = window.location && window.location.href || '';
215    } // IE11 supports URL but not the URL constructor
216    // feature detect the behavior we want
217
218
219    var nativeURL = typeof window.URL === 'function';
220    var protocolLess = /^\/\//.test(baseUrl); // remove location if window.location isn't available (i.e. we're in node)
221    // and if baseUrl isn't an absolute url
222
223    var removeLocation = !window.location && !/\/\//i.test(baseUrl); // if the base URL is relative then combine with the current location
224
225    if (nativeURL) {
226      baseUrl = new window.URL(baseUrl, window.location || DEFAULT_LOCATION);
227    } else if (!/\/\//i.test(baseUrl)) {
228      baseUrl = URLToolkit.buildAbsoluteURL(window.location && window.location.href || '', baseUrl);
229    }
230
231    if (nativeURL) {
232      var newUrl = new URL(relativeUrl, baseUrl); // if we're a protocol-less url, remove the protocol
233      // and if we're location-less, remove the location
234      // otherwise, return the url unmodified
235
236      if (removeLocation) {
237        return newUrl.href.slice(DEFAULT_LOCATION.length);
238      } else if (protocolLess) {
239        return newUrl.href.slice(newUrl.protocol.length);
240      }
241
242      return newUrl.href;
243    }
244
245    return URLToolkit.buildAbsoluteURL(baseUrl, relativeUrl);
246  };
247
248  /**
249   * @file resolve-url.js - Handling how URLs are resolved and manipulated
250   */
251  const resolveUrl = resolveUrl$1;
252  /**
253   * If the xhr request was redirected, return the responseURL, otherwise,
254   * return the original url.
255   *
256   * @api private
257   *
258   * @param  {string} url - an url being requested
259   * @param  {XMLHttpRequest}

259 req - xhr request result
260   *
261   * @return {string}
262   */
263
264  const resolveManifestRedirect = (url, req) => {
265    // To understand how the responseURL below is set and generated:
266    // - https://fetch.spec.whatwg.org/#concept-response-url
267    // - https://fetch.spec.whatwg.org/#atomic-http-redirect-handling
268    if (req && req.responseURL && url !== req.responseURL) {
269      return req.responseURL;
270    }
271
272    return url;
273  };
274
275  const logger = source => {
276    if (videojs__default["default"].log.debug) {
277      return videojs__default["default"].log.debug.bind(videojs__default["default"], 'VHS:', `${source} >`);
278    }
279
280    return function () {};
281  };
282
283  /**
284   * @file stream.js
285   */
286
287  /**
288   * A lightweight readable stream implemention that handles event dispatching.
289   *
290   * @class Stream
291   */
292  var Stream = /*#__PURE__*/function () {
293    function Stream() {
294      this.listeners = {};
295    }
296    /**
297     * Add a listener for a specified event type.
298     *
299     * @param {string} type the event name
300     * @param {Function} listener the callback to be invoked when an event of
301     * the specified type occurs
302     */
303
304
305    var _proto = Stream.prototype;
306
307    _proto.on = function on(type, listener) {
308      if (!this.listeners[type]) {
309        this.listeners[type] = [];
310      }
311
312      this.listeners[type].push(listener);
313    }
314    /**
315     * Remove a listener for a specified event type.
316     *
317     * @param {string} type the event name
318     * @param {Function} listener  a function previously registered for this
319     * type of event through `on`
320     * @return {boolean} if we could turn it off or not
321     */
322    ;
323
324    _proto.off = function off(type, listener) {
325      if (!this.listeners[type]) {
326        return false;
327      }
328
329      var index = this.listeners[type].indexOf(listener); // TODO: which is better?
330      // In Video.js we slice listener functions
331      // on trigger so that it does not mess up the order
332      // while we loop through.
333      //
334      // Here we slice on off so that the loop in trigger
335      // can continue using it's old reference to loop without
336      // messing up the order.
337
338      this.listeners[type] = this.listeners[type].slice(0);
339      this.listeners[type].splice(index, 1);
340      return index > -1;
341    }
342    /**
343     * Trigger an event of the specified type on this stream. Any additional
344     * arguments to this function are passed as parameters to event listeners.
345     *
346     * @param {string} type the event name
347     */
348    ;
349
350    _proto.trigger = function trigger(type) {
351      var callbacks = this.listeners[type];
352
353      if (!callbacks) {
354        return;
355      } // Slicing the arguments on every invocation of this method
356      // can add a significant amount of overhead. Avoid the
357      // intermediate object creation for the common case of a
358      // single callback argument
359
360
361      if (arguments.length === 2) {
362        var length = callbacks.length;
363
364        for (var i = 0; i < length; ++i) {
365          callbacks[i].call(this, arguments[1]);
366        }
367      } else {
368        var args = Array.prototype.slice.call(arguments, 1);
369        var _length = callbacks.length;
370
371        for (var _i = 0; _i < _length; ++_i) {
372          callbacks[_i].apply(this, args);
373        }
374      }
375    }
376    /**
377     * Destroys the stream and cleans up.
378     */
379    ;
380
381    _proto.dispose = function dispose() {
382      this.listeners = {};
383    }
384    /**
385     * Forwards all `data` events on this stream to the destination stream. The
386     * destination stream should provide a method `push` to receive the data
387     * events as they arrive.
388     *
389     * @param {Stream} destination the stream that will receive all `data` events
390     * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
391     */
392    ;
393
394    _proto.pipe = function pipe(destination) {
395      this.on('data', function (data) {
396        destination.push(data);
397      });
398    };
399
400    return Stream;
401  }();
402
403  var atob = function atob(s) {
404    return window.atob ? window.atob(s) : Buffer.from(s, 'base64').toString('binary');
405  };
406
407  function decodeB64ToUint8Array(b64Text) {
408    var decodedString = atob(b64Text);
409    var array = new Uint8Array(decodedString.length);
410
411    for (var i = 0; i < decodedString.length; i++) {
412      array[i] = decodedString.charCodeAt(i);
413    }
414
415    return array;
416  }
417
418  /*! @name m3u8-parser @version 7.1.0 @license Apache-2.0 */
419  /**
420   * @file m3u8/line-stream.js
421   */
422
423  /**
424   * A stream that buffers string input and generates a `data` event for each
425   * line.
426   *
427   * @class LineStream
428   * @extends Stream
429   */
430
431  class LineStream extends Stream {
432    constructor() {
433      super();
434      this.buffer = '';
435    }
436    /**
437     * Add new data to be parsed.
438     *
439     * @param {string} data the text to process
440     */
441
442
443    push(data) {
444      let nextNewline;
445      this.buffer += data;
446      nextNewline = this.buffer.indexOf('\n');
447
448      for (; nextNewline > -1; nextNewline = this.buffer.indexOf('\n')) {
449        this.trigger('data', this.buffer.substring(0, nextNewline));
450        this.buffer = this.buffer.substring(nextNewline + 1);
451      }
452    }
453
454  }
455
456  const TAB = String.fromCharCode(0x09);
457
458  const parseByterange = function (byterangeString) {
459    // optionally match and capture 0+ digits before `@`
460    // optionally match and capture 0+ digits after `@`
461    const match = /([0-9.]*)?@?([0-9.]*)?/.exec(byterangeString || '');
462    const result = {};
463
464    if (match[1]) {
465      result.length = parseInt(match[1], 10);
466    }
467
468    if (match[2]) {
469      result.offset = parseInt(match[2], 10);
470    }
471
472    return result;
473  };
474  /**
475   * "forgiving" attribute list psuedo-grammar:
476   * attributes -> keyvalue (',' keyvalue)*
477   * keyvalue   -> key '=' value
478   * key        -> [^=]*
479   * value      -> '"' [^"]* '"' | [^,]*
480   */
481
482
483  const attributeSeparator = function () {

484    const key = '[^=]*';
485    const value = '"[^"]*"|[^,]*';
486    const keyvalue = '(?:' + key + ')=(?:' + value + ')';
487    return new RegExp('(?:^|,)(' + keyvalue + ')');
488  };
489  /**
490   * Parse attributes from a line given the separator
491   *
492   * @param {string} attributes the attribute line to parse
493   */
494
495
496  const parseAttributes$1 = function (attributes) {
497    const result = {};
498
499    if (!attributes) {
500      return result;
501    } // split the string using attributes as the separator
502
503
504    const attrs = attributes.split(attributeSeparator());
505    let i = attrs.length;
506    let attr;
507
508    while (i--) {
509      // filter out unmatched portions of the string
510      if (attrs[i] === '') {
511        continue;
512      } // split the key and value
513
514
515      attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1); // trim whitespace and remove optional quotes around the value
516
517      attr[0] = attr[0].replace(/^\s+|\s+$/g, '');
518      attr[1] = attr[1].replace(/^\s+|\s+$/g, '');
519      attr[1] = attr[1].replace(/^['"](.*)['"]$/g, '$1');
520      result[attr[0]] = attr[1];
521    }
522
523    return result;
524  };
525  /**
526   * A line-level M3U8 parser event stream. It expects to receive input one
527   * line at a time and performs a context-free parse of its contents. A stream
528   * interpretation of a manifest can be useful if the manifest is expected to
529   * be too large to fit comfortably into memory or the entirety of the input
530   * is not immediately available. Otherwise, it's probably much easier to work
531   * with a regular `Parser` object.
532   *
533   * Produces `data` events with an object that captures the parser's
534   * interpretation of the input. That object has a property `tag` that is one
535   * of `uri`, `comment`, or `tag`. URIs only have a single additional
536   * property, `line`, which captures the entirety of the input without
537   * interpretation. Comments similarly have a single additional property
538   * `text` which is the input without the leading `#`.
539   *
540   * Tags always have a property `tagType` which is the lower-cased version of
541   * the M3U8 directive without the `#EXT` or `#EXT-X-` prefix. For instance,
542   * `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
543   * tags are given the tag type `unknown` and a single additional property
544   * `data` with the remainder of the input.
545   *
546   * @class ParseStream
547   * @extends Stream
548   */
549
550
551  class ParseStream extends Stream {
552    constructor() {
553      super();
554      this.customParsers = [];
555      this.tagMappers = [];
556    }
557    /**
558     * Parses an additional line of input.
559     *
560     * @param {string} line a single line of an M3U8 file to parse
561     */
562
563
564    push(line) {
565      let match;
566      let event; // strip whitespace
567
568      line = line.trim();
569
570      if (line.length === 0) {
571        // ignore empty lines
572        return;
573      } // URIs
574
575
576      if (line[0] !== '#') {
577        this.trigger('data', {
578          type: 'uri',
579          uri: line
580        });
581        return;
582      } // map tags
583
584
585      const newLines = this.tagMappers.reduce((acc, mapper) => {
586        const mappedLine = mapper(line); // skip if unchanged
587
588        if (mappedLine === line) {
589          return acc;
590        }
591
592        return acc.concat([mappedLine]);
593      }, [line]);
594      newLines.forEach(newLine => {
595        for (let i = 0; i < this.customParsers.length; i++) {
596          if (this.customParsers[i].call(this, newLine)) {
597            return;
598          }
599        } // Comments
600
601
602        if (newLine.indexOf('#EXT') !== 0) {
603          this.trigger('data', {
604            type: 'comment',
605            text: newLine.slice(1)
606          });
607          return;
608        } // strip off any carriage returns here so the regex matching
609        // doesn't have to account for them.
610
611
612        newLine = newLine.replace('\r', ''); // Tags
613
614        match = /^#EXTM3U/.exec(newLine);
615
616        if (match) {
617          this.trigger('data', {
618            type: 'tag',
619            tagType: 'm3u'
620          });
621          return;
622        }
623
624        match = /^#EXTINF:([0-9\.]*)?,?(.*)?$/.exec(newLine);
625
626        if (match) {
627          event = {
628            type: 'tag',
629            tagType: 'inf'
630          };
631
632          if (match[1]) {
633            event.duration = parseFloat(match[1]);
634          }
635
636          if (match[2]) {
637            event.title = match[2];
638          }
639
640          this.trigger('data', event);
641          return;
642        }
643
644        match = /^#EXT-X-TARGETDURATION:([0-9.]*)?/.exec(newLine);
645
646        if (match) {
647          event = {
648            type: 'tag',
649            tagType: 'targetduration'
650          };
651
652          if (match[1]) {
653            event.duration = parseInt(match[1], 10);
654          }
655
656          this.trigger('data', event);
657          return;
658        }
659
660        match = /^#EXT-X-VERSION:([0-9.]*)?/.exec(newLine);
661
662        if (match) {
663          event = {
664            type: 'tag',
665            tagType: 'version'
666          };
667
668          if (match[1]) {
669            event.version = parseInt(match[1], 10);
670          }
671
672          this.trigger('data', event);
673          return;
674        }
675
676        match = /^#EXT-X-MEDIA-SEQUENCE:(\-?[0-9.]*)?/.exec(newLine);
677
678        if (match) {
679          event = {
680            type: 'tag',
681            tagType: 'media-sequence'
682          };
683
684          if (match[1]) {
685            event.number = parseInt(match[1], 10);
686          }
687
688          this.trigger('data', event);
689          return;
690        }
691
692        match = /^#EXT-X-DISCONTINUITY-SEQUENCE:(\-?[0-9.]*)?/.exec(newLine);
693
694        if (match) {
695          event = {
696            type: 'tag',
697            tagType: 'discontinuity-sequence'
698          };
699
700          if (match[1]) {
701            event.number = parseInt(match[1], 10);
702          }
703
704          this.trigger('data', event);
705          return;
706        }
707
708        match = /^#EXT-X-PLAYLIST-TYPE:(.*)?$/.exec(newLine);
709
710        if (match) {
711          event = {
712            type: 'tag',
713            tagType: 'playlist-type'
714          };
715
716          if (match[1]) {
717            event.playlistType = match[1];
718          }
719
720          this.trigger('data', event);
721          return;
722        }
723
724        match = /^#EXT-X-BYTERANGE:(.*)?$/.exec(newLine);
725
726        if (match) {
727          event = _extends(parseByterange(match[1]), {
728            type: 'tag',
729            tagType: 'byterange'
730          });
731          this.trigger('data', event);
732          return;
733        }
734
735        match = /^#EXT-X-ALLOW-CACHE:(YES|NO)?/.exec(newLine);
736
737        if (match) {
738          event = {
739            type: 'tag',
740            tagType: 'allow-cache'
741          };
742
743          if (match[1]) {
744            event.allowed = !/NO/.test(match[1]);
745          }
746
747          this.trigger('data', event);
748          return;
749        }
750
751        match = /^#EXT-X-MAP:(.*)$/.exec(newLine);
752
753        if (match) {
754          event = {
755            type: 'tag',
756            tagType: 'map'
757          };
758
759          if (match[1]) {
760            const attributes = parseAttributes$1(match[1]);
761
762            if (attributes.URI) {
763              event.uri = attributes.URI;
764            }
765
766            if (attributes.BYTERANGE) {
767              event.byterange = parseByterange(attributes.BYTERANGE);
768            }
769          }
770
771          this.trigger('data', event);
772          return;
773        }
774
775        match = /^#EXT-X-STREAM-INF:(.*)$/.exec(newLine);
776
777        if (match) {
778          event = {
779            type: 'tag',
780            tagType: 'stream-inf'
781          };
782
783          if (match[1]) {
784            event.attributes = parseAttributes$1(match[1]);
785
786            if (event.attributes.RESOLUTION) {
787              const split = event.attributes.RESOLUTION.split('x');
788              const resolution = {};
789
790              if (split[0]) {
791                resolution.width = parseInt(split[0], 10);
792              }
793
794              if (split[1]) {
795                resolution.height = parseInt(split[1], 10);
796              }
797
798              event.attributes.RESOLUTION = resolution;
799            }
800
801            if (event.attributes.BANDWIDTH) {
802              event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
803            }
804
805            if (event.attributes['FRAME-RATE']) {
806              event.attributes['FRAME-RATE'] = parseFloat(event.attributes['FRAME-RATE']);
807            }
808
809            if (event.attributes['PROGRAM-ID']) {
810              event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);
811            }
812          }
813
814          this.trigger('data', event);
815          return;
816        }
817
818        match = /^#EXT-X-MEDIA:(.*)$/.exec(newLine);
819
820        if (match) {
821          event = {
822            type: 'tag',
823            tagType: 'media'
824          };
825
826          if (match[1]) {
827            event.attributes = parseAttributes$1(match[1]);
828          }
829
830          this.trigger('data', event);
831          return;
832        }
833
834        match = /^#EXT-X-ENDLIST/.exec(newLine);
835
836        if (match) {
837          this.trigger('data', {
838            type: 'tag',
839            tagType: 'endlist'
840          });
841          return;
842        }
843
844        match = /^#EXT-X-DISCONTINUITY/.exec(newLine);
845
846        if (match) {
847          this.trigger('data', {
848            type: 'tag',
849            tagType: 'discontinuity'
850          });
851          return;
852        }
853
854        match = /^#EXT-X-PROGRAM-DATE-TIME:(.*)$/.exec(newLine);
855
856        if (match) {
857          event = {
858            type: 'tag',
859            tagType: 'program-date-time'
860          };
861
862          if (match[1]) {
863            event.dateTimeString = match[1];
864            event.dateTimeObject = new Date(match[1]);
865          }
866
867          this.trigger('data', event);
868          return;
869        }
870
871        match = /^#EXT-X-KEY:(.*)$/.exec(newLine);
872
873        if (match) {
874          event = {
875            type: 'tag',
876            tagType: 'key'
877          };
878
879          if (match[1]) {
880            event.attributes = parseAttributes$1(match[1]); // parse the IV string into a Uint32Array
881
882            if (event.attributes.IV) {
883              if (event.attributes.IV.substring(0, 2).toLowerCase() === '0x') {
884                event.attributes.IV = event.attributes.IV.substring(2);
885              }
886
887              event.attributes.IV = event.attributes.IV.match(/.{8}/g);
888              event.attributes.IV[0] = parseInt(event.attributes.IV[0], 16);
889              event.attributes.IV[1] = parseInt(event.attributes.IV[1], 16);
890              event.attributes.IV[2] = parseInt(event.attributes.IV[2], 16);
891              event.attributes.IV[3] = parseInt(event.attributes.IV[3], 16);
892              event.attributes.IV = new Uint32Array(event.attributes.IV);
893            }
894          }
895
896          this.trigger('data', event);
897          return;
898        }
899
900        match = /^#EXT-X-START:(.*)$/.exec(newLine);
901
902        if (match) {
903          event = {
904            type: 'tag',
905            tagType: 'start'
906          };
907
908          if (match[1]) {
909            event.attributes = parseAttributes$1(match[1]);
910            event.attributes['TIME-OFFSET'] = parseFloat(event.attributes['TIME-OFFSET']);
911            event.attributes.PRECISE = /YES/.test(event.attributes.PRECISE);
912          }
913
914          this.trigger('data', event);
915          return;
916        }
917
918        match = /^#EXT-X-CUE-OUT-CONT:(.*)?$/.exec(newLine);
919
920        if (match) {
921          event = {
922            type: 'tag',
923            tagType: 'cue-out-cont'
924          };
925
926          if (match[1]) {
927            event.data = match[1];
928          } else {
929            event.data = '';
930          }
931
932          this.trigger('data', event);
933          return;
934        }
935
936        match = /^#EXT-X-CUE-OUT:(.*)?$/.exec(newLine);
937
938        if (match) {
939          event = {
940            type: 'tag',
941            tagType: 'cue-out'
942          };
943
944          if (match[1]) {
945            event.data = match[1];
946          } else {
947            event.data = '';
948          }
949
950          this.trigger('data', event);
951          return;
952        }
953
954        match = /^#EXT-X-CUE-IN:(.*)?$/.exec(newLine);
955
956        if (match) {
957          event = {
958            type: 'tag',
959            tagType: 'cue-in'
960          };
961
962          if (match[1]) {
963            event.data = match[1];
964          } else {
965            event.data = '';
966          }
967
968          this.trigger('data', event);
969          return;
970        }
971
972        match = /^#EXT-X-SKIP:(.*)$/.exec(newLine);
973
974        if (match && match[1]) {
975          event = {
976            type: 'tag',
977            tagType: 'skip'
978          };
979          event.attributes = parseAttributes$1(match[1]);
980
981          if (event.attributes.hasOwnProperty('SKIPPED-SEGMENTS')) {
982            event.attributes['SKIPPED-SEGMENTS'] = parseInt(event.attributes['SKIPPED-SEGMENTS'], 10);
983          }
984
985          if (event.attributes.hasOwnProperty('RECENTLY-REMOVED-DATERANGES')) {
986            event.attributes['RECENTLY-REMOVED-DATERANGES'] = event.attributes['RECENTLY-REMOVED-DATERANGES'].split(TAB);
987          }
988
989          this.trigger('data', event);
990          return;
991        }
992
993        match = /^#EXT-X-PART:(.*)$/.exec(newLine);
994
995        if (match && match[1]) {
996          event = {
997            type: 'tag',
998            tagType: 'part'
999          };
1000          event.attributes = parseAttributes$1(match[1]);
1001          ['DURATION'].forEach(function (key) {
1002            if (event.attributes.hasOwnProperty(key)) {
1003              event.attributes[key] = parseFloat(event.attributes[key]);
1004            }
1005          });
1006          ['INDEPENDENT', 'GAP'].forEach(function (key) {
1007            if (event.attributes.hasOwnProperty(key)) {
1008              event.attributes[key] = /YES/.test(event.attributes[key]);
1009            }
1010          });
1011
1012          if (event.attributes.hasOwnProperty('BYTERANGE')) {
1013            event.attributes.byterange = parseByterange(event.attributes.BYTERANGE);
1014          }
1015
1016          this.trigger('data', event);
1017          return;
1018        }
1019
1020        match = /^#EXT-X-SERVER-CONTROL:(.*)$/.exec(newLine);
1021
1022        if (match && match[1]) {
1023          event = {
1024            type: 'tag',
1025            tagType: 'server-control'
1026          };
1027          event.attributes = parseAttributes$1(match[1]);
1028          ['CAN-SKIP-UNTIL', 'PART-HOLD-BACK', 'HOLD-BACK'].forEach(function (key) {
1029            if (event.attributes.hasOwnProperty(key)) {
1030              event.attributes[key] = parseFloat(event.attributes[key]);
1031            }
1032          });
1033          ['CAN-SKIP-DATERANGES', 'CAN-BLOCK-RELOAD'].forEach(function (key) {
1034            if (event.attributes.hasOwnProperty(key)) {
1035              event.attributes[key] = /YES/.test(event.attributes[key]);
1036            }
1037          });
1038          this.trigger('data', event);
1039          return;
1040        }
1041
1042        match = /^#EXT-X-PART-INF:(.*)$/.exec(newLine);
1043
1044        if (match && match[1]) {
1045          event = {
1046            type: 'tag',
1047            tagType: 'part-inf'
1048          };
1049          event.attributes = parseAttributes$1(match[1]);
1050          ['PART-TARGET'].forEach(function (key) {
1051            if (event.attributes.hasOwnProperty(key)) {
1052              event.attributes[key] = parseFloat(event.attributes[key]);
1053            }
1054          });
1055          this.trigger('data', event);
1056          return;
1057        }
1058
1059        match = /^#EXT-X-PRELOAD-HINT:(.*)$/.exec(newLine);
1060
1061        if (match && match[1]) {
1062          event = {
1063            type: 'tag',
1064            tagType: 'preload-hint'
1065          };
1066          event.attributes = parseAttributes$1(match[1]);
1067          ['BYTERANGE-START', 'BYTERANGE-LENGTH'].forEach(function (key) {
1068            if (event.attributes.hasOwnProperty(key)) {
1069              event.attributes[key] = parseInt(event.attributes[key], 10);
1070              const subkey = key === 'BYTERANGE-LENGTH' ? 'length' : 'offset';
1071              event.attributes.byterange = event.attributes.byterange || {};
1072              event.attributes.byterange[subkey] = event.attributes[key]; // only keep the parsed byterange object.
1073
1074              delete event.attributes[key];
1075            }
1076          });
1077          this.trigger('data', event);
1078          return;
1079        }
1080
1081        match = /^#EXT-X-RENDITION-REPORT:(.*)$/.exec(newLine);
1082
1083        if (match && match[1]) {
1084          event = {
1085            type: 'tag',
1086            tagType: 'rendition-report'
1087          };
1088          event.attributes = parseAttributes$1(match[1]);
1089          ['LAST-MSN', 'LAST-PART'].forEach(function (key) {
1090            if (event.attributes.hasOwnProperty(key)) {
1091              event.attributes[key] = parseInt(event.attributes[key], 10);
1092            }
1093          });
1094          this.trigger('data', event);
1095          return;
1096        }
1097
1098        match = /^#EXT-X-DATERANGE:(.*)$/.exec(newLine);
1099
1100        if (match && match[1]) {
1101          event = {
1102            type: 'tag',
1103            tagType: 'daterange'
1104          };
1105          event.attributes = parseAttributes$1(match[1]);
1106          ['ID', 'CLASS'].forEach(function (key) {
1107            if (event.attributes.hasOwnProperty(key)) {
1108              event.attributes[key] = String(event.attributes[key]);
1109            }
1110          });
1111          ['START-DATE', 'END-DATE'].forEach(function (key) {
1112            if (event.attributes.hasOwnProperty(key)) {
1113              event.attributes[key] = new Date(event.attributes[key]);
1114            }
1115          });
1116          ['DURATION', 'PLANNED-DURATION'].forEach(function (key) {
1117            if (event.attributes.hasOwnProperty(key)) {
1118              event.attributes[key] = parseFloat(event.attributes[key]);
1119            }
1120          });
1121          ['END-ON-NEXT'].forEach(function (key) {
1122            if (event.attributes.hasOwnProperty(key)) {
1123              event.attributes[key] = /YES/i.test(event.attributes[key]);
1124            }
1125          });
1126          ['SCTE35-CMD', ' SCTE35-OUT', 'SCTE35-IN'].forEach(function (key) {
1127            if (event.attributes.hasOwnProperty(key)) {
1128              event.attributes[key] = event.attributes[key].toString(16);
1129            }
1130          });
1131          const clientAttributePattern = /^X-([A-Z]+-)+[A-Z]+$/;
1132
1133          for (const key in event.attributes) {
1134            if (!clientAttributePattern.test(key)) {
1135              continue;
1136            }
1137
1138            const isHexaDecimal = /[0-9A-Fa-f]{6}/g.test(event.attributes[key]);
1139            const isDecimalFloating = /^\d+(\.\d+)?$/.test(event.attributes[key]);
1140            event.attributes[key] = isHexaDecimal ? event.attributes[key].toString(16) : isDecimalFloating ? parseFloat(event.attributes[key]) : String(event.attributes[key]);
1141          }
1142
1143          this.trigger('data', event);
1144          return;
1145        }
1146
1147        match = /^#EXT-X-INDEPENDENT-SEGMENTS/.exec(newLine);
1148
1149        if (match) {
1150          this.trigger('data', {
1151            type: 'tag',
1152            tagType: 'independent-segments'
1153          });
1154          return;
1155        }
1156
1157        match = /^#EXT-X-CONTENT-STEERING:(.*)$/.exec(newLine);
1158
1159        if (match) {
1160          event = {
1161            type: 'tag',
1162            tagType: 'content-steering'
1163          };
1164          event.attributes = parseAttributes$1(match[1]);
1165          this.trigger('data', event);
1166          return;
1167        } // unknown tag type
1168
1169
1170        this.trigger('data', {
1171          type: 'tag',
1172          data: newLine.slice(4)
1173        });
1174      });
1175    }
1176    /**
1177     * Add a parser for custom headers
1178     *
1179     * @param {Object}   options              a map of options for the added parser
1180     * @param {RegExp}   options.expression   a regular expression to match the custom header
1181     * @param {string}   options.customType   the custom type to register to the output
1182     * @param {Function} [options.dataParser] function to parse the line into an object
1183     * @param {boolean}  [options.segment]    should tag data be attached to the segment object
1184     */
1185
1186
1187    addParser({
1188      expression,
1189      customType,
1190      dataParser,
1191      segment
1192    }) {
1193      if (typeof dataParser !== 'function') {
1194        dataParser = line => line;
1195      }
1196
1197      this.customParsers.push(line => {
1198        const match = expression.exec(line);
1199
1200        if (match) {
1201          this.trigger('data', {
1202            type: 'custom',
1203            data: dataParser(line),
1204            customType,
1205            segment
1206          });
1207          return true;
1208        }
1209      });
1210    }
1211    /**
1212     * Add a custom header mapper
1213     *
1214     * @param {Object}   options
1215     * @param {RegExp}   options.expression   a regular expression to match the custom header
1216     * @param {Function} options.map          function to translate tag into a different tag
1217     */
1218
1219
1220    addTagMapper({
1221      expression,
1222      map
1223    }) {
1224      const mapFn = line => {
1225        if (expression.test(line)) {
1226          return map(line);
1227        }
1228
1229        return line;
1230      };
1231
1232      this.tagMappers.push(mapFn);
1233    }
1234
1235  }
1236
1237  const camelCase = str => str.toLowerCase().replace(/-(\w)/g, a => a[1].toUpperCase());
1238
1239  const camelCaseKeys = function (attributes) {
1240    const result = {};
1241    Object.keys(attributes).forEach(function (key) {
1242      result[camelCase(key)] = attributes[key];
1243    });
1244    return result;
1245  }; // set SERVER-CONTROL hold back based upon targetDuration and partTargetDuration
1246  // we need this helper because defaults are based upon targetDuration and
1247  // partTargetDuration being set, but they may not be if SERVER-CONTROL appears before
1248  // target durations are set.
1249
1250
1251  const setHoldBack = function (manifest) {
1252    const {
1253      serverControl,
1254      targetDuration,
1255      partTargetDuration
1256    } = manifest;
1257
1258    if (!serverControl) {
1259      return;
1260    }
1261
1262    const tag = '#EXT-X-SERVER-CONTROL';
1263    const hb = 'holdBack';
1264    const phb = 'partHoldBack';
1265    const minTargetDuration = targetDuration && targetDuration * 3;
1266    const minPartDuration = partTargetDuration && partTargetDuration * 2;
1267
1268    if (targetDuration && !serverControl.hasOwnProperty(hb)) {
1269      serverControl[hb] = minTargetDuration;
1270      this.trigger('info', {
1271        message: `${tag} defaulting HOLD-BACK to targetDuration * 3 (${minTargetDuration}).`
1272      });
1273    }
1274
1275    if (minTargetDuration && serverControl[hb] < minTargetDuration) {
1276      this.trigger('warn', {
1277        message: `${tag} clamping HOLD-BACK (${serverControl[hb]}) to targetDuration * 3 (${minTargetDuration})`
1278      });
1279      serverControl[hb] = minTargetDuration;
1280    } // default no part hold back to part target duration * 3
1281
1282
1283    if (partTargetDuration && !serverControl.hasOwnProperty(phb)) {
1284      serverControl[phb] = partTargetDuration * 3;
1285      this.trigger('info', {
1286        message: `${tag} defaulting PART-HOLD-BACK to partTargetDuration * 3 (${serverControl[phb]}).`
1287      });
1288    } // if part hold back is too small default it to part target duration * 2
1289
1290
1291    if (partTargetDuration && serverControl[phb] < minPartDuration) {
1292      this.trigger('warn', {
1293        message: `${tag} clamping PART-HOLD-BACK (${serverControl[phb]}) to partTargetDuration * 2 (${minPartDuration}).`
1294      });
1295      serverControl[phb] = minPartDuration;
1296    }
1297  };
1298  /**
1299   * A parser for M3U8 files. The current interpretation of the input is
1300   * exposed as a property `manifest` on parser objects. It's just two lines to
1301   * create and parse a manifest once you have the contents available as a string:
1302   *
1303   * ```js
1304   * var parser = new m3u8.Parser();
1305   * parser.push(xhr.responseText);
1306   * ```
1307   *
1308   * New input can later be applied to update the manifest object by calling
1309   * `push` again.
1310   *
1311   * The parser attempts to create a usable manifest object even if the
1312   * underlying input is somewhat nonsensical. It emits `info` and `warning`
1313   * events during the parse if it encounters input that seems invalid or
1314   * requires some property of the manifest object to be defaulted.
1315   *
1316   * @class Parser
1317   * @extends Stream
1318   */
1319
1320
1321  class Parser extends Stream {
1322    constructor() {
1323      super();
1324      this.lineStream = new LineStream();
1325      this.parseStream = new ParseStream();
1326      this.lineStream.pipe(this.parseStream);
1327      this.lastProgramDateTime = null;
1328      /* eslint-disable consistent-this */
1329
1330      const self = this;
1331      /* eslint-enable consistent-this */
1332
1333      const uris = [];
1334      let currentUri = {}; // if specified, the active EXT-X-MAP definition
1335
1336      let currentMap; // if specified, the active decryption key
1337
1338      let key;
1339      let hasParts = false;
1340
1341      const noop = function () {};
1342
1343      const defaultMediaGroups = {
1344        'AUDIO': {},
1345        'VIDEO': {},
1346        'CLOSED-CAPTIONS': {},
1347        'SUBTITLES': {}
1348      }; // This is the Widevine UUID from DASH IF IOP. The same exact string is
1349      // used in MPDs with Widevine encrypted streams.
1350
1351      const widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities
1352
1353      let currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data
1354
1355      this.manifest = {
1356        allowCache: true,
1357        discontinuityStarts: [],
1358        dateRanges: [],
1359        segments: []
1360      }; // keep track of the last seen segment's byte range end, as segments are not required
1361      // to provide the offset, in which case it defaults to the next byte after the
1362      // previous segment
1363
1364      let lastByterangeEnd = 0; // keep track of the last seen part's byte range end.
1365
1366      let lastPartByterangeEnd = 0;
1367      const dateRangeTags = {};
1368      this.on('end', () => {
1369        // only add preloadSegment if we don't yet have a uri for it.
1370        // and we actually have parts/preloadHints
1371        if (currentUri.uri || !currentUri.parts && !currentUri.preloadHints) {
1372          return;
1373        }
1374
1375        if (!currentUri.map && currentMap) {
1376          currentUri.map = currentMap;
1377        }
1378
1379        if (!currentUri.key && key) {
1380          currentUri.key = key;
1381        }
1382
1383        if (!currentUri.timeline && typeof currentTimeline === 'number') {
1384          currentUri.timeline = currentTimeline;
1385        }
1386
1387        this.manifest.preloadSegment = currentUri;
1388      }); // update the manifest with the m3u8 entry from the parse stream
1389
1390      this.parseStream.on('data', function (entry) {
1391        let mediaGroup;
1392        let rendition;

1392
1393        ({
1394          tag() {
1395            // switch based on the tag type
1396            (({
1397              version() {
1398                if (entry.version) {
1399                  this.manifest.version = entry.version;
1400                }
1401              },
1402
1403              'allow-cache'() {
1404                this.manifest.allowCache = entry.allowed;
1405
1406                if (!('allowed' in entry)) {
1407                  this.trigger('info', {
1408                    message: 'defaulting allowCache to YES'
1409                  });
1410                  this.manifest.allowCache = true;
1411                }
1412              },
1413
1414              byterange() {
1415                const byterange = {};
1416
1417                if ('length' in entry) {
1418                  currentUri.byterange = byterange;
1419                  byterange.length = entry.length;
1420
1421                  if (!('offset' in entry)) {
1422                    /*
1423                     * From the latest spec (as of this writing):
1424                     * https://tools.ietf.org/html/draft-pantos-http-live-streaming-23#section-4.3.2.2
1425                     *
1426                     * Same text since EXT-X-BYTERANGE's introduction in draft 7:
1427                     * https://tools.ietf.org/html/draft-pantos-http-live-streaming-07#section-3.3.1)
1428                     *
1429                     * "If o [offset] is not present, the sub-range begins at the next byte
1430                     * following the sub-range of the previous media segment."
1431                     */
1432                    entry.offset = lastByterangeEnd;
1433                  }
1434                }
1435
1436                if ('offset' in entry) {
1437                  currentUri.byterange = byterange;
1438                  byterange.offset = entry.offset;
1439                }
1440
1441                lastByterangeEnd = byterange.offset + byterange.length;
1442              },
1443
1444              endlist() {
1445                this.manifest.endList = true;
1446              },
1447
1448              inf() {
1449                if (!('mediaSequence' in this.manifest)) {
1450                  this.manifest.mediaSequence = 0;
1451                  this.trigger('info', {
1452                    message: 'defaulting media sequence to zero'
1453                  });
1454                }
1455
1456                if (!('discontinuitySequence' in this.manifest)) {
1457                  this.manifest.discontinuitySequence = 0;
1458                  this.trigger('info', {
1459                    message: 'defaulting discontinuity sequence to zero'
1460                  });
1461                }
1462
1463                if (entry.title) {
1464                  currentUri.title = entry.title;
1465                }
1466
1467                if (entry.duration > 0) {
1468                  currentUri.duration = entry.duration;
1469                }
1470
1471                if (entry.duration === 0) {
1472                  currentUri.duration = 0.01;
1473                  this.trigger('info', {
1474                    message: 'updating zero segment duration to a small value'
1475                  });
1476                }
1477
1478                this.manifest.segments = uris;
1479              },
1480
1481              key() {
1482                if (!entry.attributes) {
1483                  this.trigger('warn', {
1484                    message: 'ignoring key declaration without attribute list'
1485                  });
1486                  return;
1487                } // clear the active encryption key
1488
1489
1490                if (entry.attributes.METHOD === 'NONE') {
1491                  key = null;
1492                  return;
1493                }
1494
1495                if (!entry.attributes.URI) {
1496                  this.trigger('warn', {
1497                    message: 'ignoring key declaration without URI'
1498                  });
1499                  return;
1500                }
1501
1502                if (entry.attributes.KEYFORMAT === 'com.apple.streamingkeydelivery') {
1503                  this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.
1504
1505                  this.manifest.contentProtection['com.apple.fps.1_0'] = {
1506                    attributes: entry.attributes
1507                  };
1508                  return;
1509                }
1510
1511                if (entry.attributes.KEYFORMAT === 'com.microsoft.playready') {
1512                  this.manifest.contentProtection = this.manifest.contentProtection || {}; // TODO: add full support for this.
1513
1514                  this.manifest.contentProtection['com.microsoft.playready'] = {
1515                    uri: entry.attributes.URI
1516                  };
1517                  return;
1518                } // check if the content is encrypted for Widevine
1519                // Widevine/HLS spec: https://storage.googleapis.com/wvdocs/Widevine_DRM_HLS.pdf
1520
1521
1522                if (entry.attributes.KEYFORMAT === widevineUuid) {
1523                  const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];
1524
1525                  if (VALID_METHODS.indexOf(entry.attributes.METHOD) === -1) {
1526                    this.trigger('warn', {
1527                      message: 'invalid key method provided for Widevine'
1528                    });
1529                    return;
1530                  }
1531
1532                  if (entry.attributes.METHOD === 'SAMPLE-AES-CENC') {
1533                    this.trigger('warn', {
1534                      message: 'SAMPLE-AES-CENC is deprecated, please use SAMPLE-AES-CTR instead'
1535                    });
1536                  }
1537
1538                  if (entry.attributes.URI.substring(0, 23) !== 'data:text/plain;base64,') {
1539                    this.trigger('warn', {
1540                      message: 'invalid key URI provided for Widevine'
1541                    });
1542                    return;
1543                  }
1544
1545                  if (!(entry.attributes.KEYID && entry.attributes.KEYID.substring(0, 2) === '0x')) {
1546                    this.trigger('warn', {
1547                      message: 'invalid key ID provided for Widevine'
1548                    });
1549                    return;
1550                  } // if Widevine key attributes are valid, store them as `contentProtection`
1551                  // on the manifest to emulate Widevine tag structure in a DASH mpd
1552
1553
1554                  this.manifest.contentProtection = this.manifest.contentProtection || {};
1555                  this.manifest.contentProtection['com.widevine.alpha'] = {
1556                    attributes: {
1557                      schemeIdUri: entry.attributes.KEYFORMAT,
1558                      // remove '0x' from the key id string
1559                      keyId: entry.attributes.KEYID.substring(2)
1560                    },
1561                    // decode the base64-encoded PSSH box
1562                    pssh: decodeB64ToUint8Array(entry.attributes.URI.split(',')[1])
1563                  };
1564                  return;
1565                }
1566
1567                if (!entry.attributes.METHOD) {
1568                  this.trigger('warn', {
1569                    message: 'defaulting key method to AES-128'
1570                  });
1571                } // setup an encryption key for upcoming segments
1572
1573
1574                key = {
1575                  method: entry.attributes.METHOD || 'AES-128',
1576                  uri: entry.attributes.URI
1577                };
1578
1579                if (typeof entry.attributes.IV !== 'undefined') {
1580                  key.iv = entry.attributes.IV;
1581                }
1582              },
1583
1584              'media-sequence'() {
1585                if (!isFinite(entry.number)) {
1586                  this.trigger('warn', {
1587                    message: 'ignoring invalid media sequence: ' + entry.number
1588                  });
1589                  return;
1590                }
1591
1592                this.manifest.mediaSequence = entry.number;
1593              },
1594
1595              'discontinuity-sequence'() {
1596                if (!isFinite(entry.number)) {
1597                  this.trigger('warn', {
1598                    message: 'ignoring invalid discontinuity sequence: ' + entry.number
1599                  });
1600                  return;
1601                }
1602
1603                this.manifest.discontinuitySequence = entry.number;
1604                currentTimeline = entry.number;
1605              },
1606
1607              'playlist-type'() {
1608                if (!/VOD|EVENT/.test(entry.playlistType)) {
1609                  this.trigger('warn', {
1610                    message: 'ignoring unknown playlist type: ' + entry.playlist
1611                  });
1612                  return;
1613                }
1614
1615                this.manifest.playlistType = entry.playlistType;
1616              },
1617
1618              map() {
1619                currentMap = {};
1620
1621                if (entry.uri) {
1622                  currentMap.uri = entry.uri;
1623                }
1624
1625                if (entry.byterange) {
1626                  currentMap.byterange = entry.byterange;
1627                }
1628
1629                if (key) {
1630                  currentMap.key = key;
1631                }
1632              },
1633
1634              'stream-inf'() {
1635                this.manifest.playlists = uris;
1636                this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
1637
1638                if (!entry.attributes) {
1639                  this.trigger('warn', {
1640                    message: 'ignoring empty stream-inf attributes'
1641                  });
1642                  return;
1643                }
1644
1645                if (!currentUri.attributes) {
1646                  currentUri.attributes = {};
1647                }
1648
1649                _extends(currentUri.attributes, entry.attributes);
1650              },
1651
1652              media() {
1653                this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
1654
1655                if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
1656                  this.trigger('warn', {
1657                    message: 'ignoring incomplete or missing media group'
1658                  });
1659                  return;
1660                } // find the media group, creating defaults as necessary
1661
1662
1663                const mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
1664                mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};
1665                mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']]; // collect the rendition metadata
1666
1667                rendition = {
1668                  default: /yes/i.test(entry.attributes.DEFAULT)
1669                };
1670
1671                if (rendition.default) {
1672                  rendition.autoselect = true;
1673                } else {
1674                  rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);
1675                }
1676
1677                if (entry.attributes.LANGUAGE) {
1678                  rendition.language = entry.attributes.LANGUAGE;
1679                }
1680
1681                if (entry.attributes.URI) {
1682                  rendition.uri = entry.attributes.URI;
1683                }
1684
1685                if (entry.attributes['INSTREAM-ID']) {
1686                  rendition.instreamId = entry.attributes['INSTREAM-ID'];
1687                }
1688
1689                if (entry.attributes.CHARACTERISTICS) {
1690                  rendition.characteristics = entry.attributes.CHARACTERISTICS;
1691                }
1692
1693                if (entry.attributes.FORCED) {
1694                  rendition.forced = /yes/i.test(entry.attributes.FORCED);
1695                } // insert the new rendition
1696
1697
1698                mediaGroup[entry.attributes.NAME] = rendition;
1699              },
1700
1701              discontinuity() {
1702                currentTimeline += 1;
1703                currentUri.discontinuity = true;
1704                this.manifest.discontinuityStarts.push(uris.length);
1705              },
1706
1707              'program-date-time'() {
1708                if (typeof this.manifest.dateTimeString === 'undefined') {
1709                  // PROGRAM-DATE-TIME is a media-segment tag, but for backwards
1710                  // compatibility, we add the first occurence of the PROGRAM-DATE-TIME tag
1711                  // to the manifest object
1712                  // TODO: Consider removing this in future major version
1713                  this.manifest.dateTimeString = entry.dateTimeString;
1714                  this.manifest.dateTimeObject = entry.dateTimeObject;
1715                }
1716
1717                currentUri.dateTimeString = entry.dateTimeString;
1718                currentUri.dateTimeObject = entry.dateTimeObject;
1719                const {
1720                  lastProgramDateTime
1721                } = this;
1722                this.lastProgramDateTime = new Date(entry.dateTimeString).getTime(); // We should extrapolate Program Date Time backward only during first program date time occurrence.
1723                // Once we have at least one program date time point, we can always extrapolate it forward using lastProgramDateTime reference.
1724
1725                if (lastProgramDateTime === null) {
1726                  // Extrapolate Program Date Time backward
1727                  // Since it is first program date time occurrence we're assuming that
1728                  // all this.manifest.segments have no program date time info
1729                  this.manifest.segments.reduceRight((programDateTime, segment) => {
1730                    segment.programDateTime = programDateTime - segment.duration * 1000;
1731                    return segment.programDateTime;
1732                  }, this.lastProgramDateTime);
1733                }
1734              },
1735
1736              targetduration() {
1737                if (!isFinite(entry.duration) || entry.duration < 0) {
1738                  this.trigger('warn', {
1739                    message: 'ignoring invalid target duration: ' + entry.duration
1740                  });
1741                  return;
1742                }
1743
1744                this.manifest.targetDuration = entry.duration;
1745                setHoldBack.call(this, this.manifest);
1746              },
1747
1748              start() {
1749                if (!entry.attributes || isNaN(entry.attributes['TIME-OFFSET'])) {
1750                  this.trigger('warn', {
1751                    message: 'ignoring start declaration without appropriate attribute list'
1752                  });
1753                  return;
1754                }
1755
1756                this.manifest.start = {
1757                  timeOffset: entry.attributes['TIME-OFFSET'],
1758                  precise: entry.attributes.PRECISE
1759                };
1760              },
1761
1762              'cue-out'() {
1763                currentUri.cueOut = entry.data;
1764              },
1765
1766              'cue-out-cont'() {
1767                currentUri.cueOutCont = entry.data;
1768              },
1769
1770              'cue-in'() {
1771                currentUri.cueIn = entry.data;
1772              },
1773
1774              'skip'() {
1775                this.manifest.skip = camelCaseKeys(entry.attributes);
1776                this.warnOnMissingAttributes_('#EXT-X-SKIP', entry.attributes, ['SKIPPED-SEGMENTS']);
1777              },
1778
1779              'part'() {
1780                hasParts = true; // parts are always specifed before a segment
1781
1782                const segmentIndex = this.manifest.segments.length;
1783                const part = camelCaseKeys(entry.attributes);
1784                currentUri.parts = currentUri.parts || [];
1785                currentUri.parts.push(part);
1786
1787                if (part.byterange) {
1788                  if (!part.byterange.hasOwnProperty('offset')) {
1789                    part.byterange.offset = lastPartByterangeEnd;
1790                  }
1791
1792                  lastPartByterangeEnd = part.byterange.offset + part.byterange.length;
1793                }
1794
1795                const partIndex = currentUri.parts.length - 1;
1796                this.warnOnMissingAttributes_(`#EXT-X-PART #${partIndex} for segment #${segmentIndex}`, entry.attributes, ['URI', 'DURATION']);
1797
1798                if (this.manifest.renditionReports) {
1799                  this.manifest.renditionReports.forEach((r, i) => {
1800                    if (!r.hasOwnProperty('lastPart')) {
1801                      this.trigger('warn', {
1802                        message: `#EXT-X-RENDITION-REPORT #${i} lacks required attribute(s): LAST-PART`
1803                      });
1804                    }
1805                  });
1806                }
1807              },
1808
1809              'server-control'() {
1810                const attrs = this.manifest.serverControl = camelCaseKeys(entry.attributes);
1811
1812                if (!attrs.hasOwnProperty('canBlockReload')) {
1813                  attrs.canBlockReload = false;
1814                  this.trigger('info', {
1815                    message: '#EXT-X-SERVER-CONTROL defaulting CAN-BLOCK-RELOAD to false'
1816                  });
1817                }
1818
1819                setHoldBack.call(this, this.manifest);
1820
1821                if (attrs.canSkipDateranges && !attrs.hasOwnProperty('canSkipUntil')) {
1822                  this.trigger('warn', {
1823                    message: '#EXT-X-SERVER-CONTROL lacks required attribute CAN-SKIP-UNTIL which is required when CAN-SKIP-DATERANGES is set'
1824                  });
1825                }
1826              },
1827
1828              'preload-hint'() {
1829                // parts are always specifed before a segment
1830                const segmentIndex = this.manifest.segments.length;
1831                const hint = camelCaseKeys(entry.attributes);
1832                const isPart = hint.type && hint.type === 'PART';
1833                currentUri.preloadHints = currentUri.preloadHints || [];
1834                currentUri.preloadHints.push(hint);
1835
1836                if (hint.byterange) {
1837                  if (!hint.byterange.hasOwnProperty('offset')) {
1838                    // use last part byterange end or zero if not a part.
1839                    hint.byterange.offset = isPart ? lastPartByterangeEnd : 0;
1840
1841                    if (isPart) {
1842                      lastPartByterangeEnd = hint.byterange.offset + hint.byterange.length;
1843                    }
1844                  }
1845                }
1846
1847                const index = currentUri.preloadHints.length - 1;
1848                this.warnOnMissingAttributes_(`#EXT-X-PRELOAD-HINT #${index} for segment #${segmentIndex}`, entry.attributes, ['TYPE', 'URI']);
1849
1850                if (!hint.type) {
1851                  return;
1852                } // search through all preload hints except for the current one for
1853                // a duplicate type.
1854
1855
1856                for (let i = 0; i < currentUri.preloadHints.length - 1; i++) {
1857                  const otherHint = currentUri.preloadHints[i];
1858
1859                  if (!otherHint.type) {
1860                    continue;
1861                  }
1862
1863                  if (otherHint.type === hint.type) {
1864                    this.trigger('warn', {
1865                      message: `#EXT-X-PRELOAD-HINT #${index} for segment #${segmentIndex} has the same TYPE ${hint.type} as preload hint #${i}`
1866                    });
1867                  }
1868                }
1869              },
1870
1871              'rendition-report'() {
1872                const report = camelCaseKeys(entry.attributes);
1873                this.manifest.renditionReports = this.manifest.renditionReports || [];
1874                this.manifest.renditionReports.push(report);
1875                const index = this.manifest.renditionReports.length - 1;
1876                const required = ['LAST-MSN', 'URI'];
1877
1878                if (hasParts) {
1879                  required.push('LAST-PART');
1880                }
1881
1882                this.warnOnMissingAttributes_(`#EXT-X-RENDITION-REPORT #${index}`, entry.attributes, required);
1883              },
1884
1885              'part-inf'() {
1886                this.manifest.partInf = camelCaseKeys(entry.attributes);
1887                this.warnOnMissingAttributes_('#EXT-X-PART-INF', entry.attributes, ['PART-TARGET']);
1888
1889                if (this.manifest.partInf.partTarget) {
1890                  this.manifest.partTargetDuration = this.manifest.partInf.partTarget;
1891                }
1892
1893                setHoldBack.call(this, this.manifest);
1894              },
1895
1896              'daterange'() {
1897                this.manifest.dateRanges.push(camelCaseKeys(entry.attributes));
1898                const index = this.manifest.dateRanges.length - 1;
1899                this.warnOnMissingAttributes_(`#EXT-X-DATERANGE #${index}`, entry.attributes, ['ID', 'START-DATE']);
1900                const dateRange = this.manifest.dateRanges[index];
1901
1902                if (dateRange.endDate && dateRange.startDate && new Date(dateRange.endDate) < new Date(dateRange.startDate)) {
1903                  this.trigger('warn', {
1904                    message: 'EXT-X-DATERANGE END-DATE must be equal to or later than the value of the START-DATE'
1905                  });
1906                }
1907
1908                if (dateRange.duration && dateRange.duration < 0) {
1909                  this.trigger('warn', {
1910                    message: 'EXT-X-DATERANGE DURATION must not be negative'
1911                  });
1912                }
1913
1914                if (dateRange.plannedDuration && dateRange.plannedDuration < 0) {
1915                  this.trigger('warn', {
1916                    message: 'EXT-X-DATERANGE PLANNED-DURATION must not be negative'
1917                  });
1918                }
1919
1920                const endOnNextYes = !!dateRange.endOnNext;
1921
1922                if (endOnNextYes && !dateRange.class) {
1923                  this.trigger('warn', {
1924                    message: 'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must have a CLASS attribute'
1925                  });
1926                }
1927
1928                if (endOnNextYes && (dateRange.duration || dateRange.endDate)) {
1929                  this.trigger('warn', {
1930                    message: 'EXT-X-DATERANGE with an END-ON-NEXT=YES attribute must not contain DURATION or END-DATE attributes'
1931                  });
1932                }
1933
1934                if (dateRange.duration && dateRange.endDate) {
1935                  const startDate = dateRange.startDate;
1936                  const newDateInSeconds = startDate.getTime() + dateRange.duration * 1000;
1937                  this.manifest.dateRanges[index].endDate = new Date(newDateInSeconds);
1938                }
1939
1940                if (!dateRangeTags[dateRange.id]) {
1941                  dateRangeTags[dateRange.id] = dateRange;
1942                } else {
1943                  for (const attribute in dateRangeTags[dateRange.id]) {
1944                    if (!!dateRange[attribute] && JSON.stringify(dateRangeTags[dateRange.id][attribute]) !== JSON.stringify(dateRange[attribute])) {
1945                      this.trigger('warn', {
1946                        message: 'EXT-X-DATERANGE tags with the same ID in a playlist must have the same attributes values'
1947                      });
1948                      break;
1949                    }
1950                  } // if tags with the same ID do not have conflicting attributes, merge them
1951
1952
1953                  const dateRangeWithSameId = this.manifest.dateRanges.findIndex(dateRangeToFind => dateRangeToFind.id === dateRange.id);
1954                  this.manifest.dateRanges[dateRangeWithSameId] = _extends(this.manifest.dateRanges[dateRangeWithSameId], dateRange);
1955                  dateRangeTags[dateRange.id] = _extends(dateRangeTags[dateRange.id], dateRange); // after merging, delete the duplicate dateRange that was added last
1956
1957                  this.manifest.dateRanges.pop();
1958                }
1959              },
1960
1961              'independent-segments'() {
1962                this.manifest.independentSegments = true;
1963              },
1964
1965              '

1965content-steering'() {
1966                this.manifest.contentSteering = camelCaseKeys(entry.attributes);
1967                this.warnOnMissingAttributes_('#EXT-X-CONTENT-STEERING', entry.attributes, ['SERVER-URI']);
1968              }
1969
1970            })[entry.tagType] || noop).call(self);
1971          },
1972
1973          uri() {
1974            currentUri.uri = entry.uri;
1975            uris.push(currentUri); // if no explicit duration was declared, use the target duration
1976
1977            if (this.manifest.targetDuration && !('duration' in currentUri)) {
1978              this.trigger('warn', {
1979                message: 'defaulting segment duration to the target duration'
1980              });
1981              currentUri.duration = this.manifest.targetDuration;
1982            } // annotate with encryption information, if necessary
1983
1984
1985            if (key) {
1986              currentUri.key = key;
1987            }
1988
1989            currentUri.timeline = currentTimeline; // annotate with initialization segment information, if necessary
1990
1991            if (currentMap) {
1992              currentUri.map = currentMap;
1993            } // reset the last byterange end as it needs to be 0 between parts
1994
1995
1996            lastPartByterangeEnd = 0; // Once we have at least one program date time we can always extrapolate it forward
1997
1998            if (this.lastProgramDateTime !== null) {
1999              currentUri.programDateTime = this.lastProgramDateTime;
2000              this.lastProgramDateTime += currentUri.duration * 1000;
2001            } // prepare for the next URI
2002
2003
2004            currentUri = {};
2005          },
2006
2007          comment() {// comments are not important for playback
2008          },
2009
2010          custom() {
2011            // if this is segment-level data attach the output to the segment
2012            if (entry.segment) {
2013              currentUri.custom = currentUri.custom || {};
2014              currentUri.custom[entry.customType] = entry.data; // if this is manifest-level data attach to the top level manifest object
2015            } else {
2016              this.manifest.custom = this.manifest.custom || {};
2017              this.manifest.custom[entry.customType] = entry.data;
2018            }
2019          }
2020
2021        })[entry.type].call(self);
2022      });
2023    }
2024
2025    warnOnMissingAttributes_(identifier, attributes, required) {
2026      const missing = [];
2027      required.forEach(function (key) {
2028        if (!attributes.hasOwnProperty(key)) {
2029          missing.push(key);
2030        }
2031      });
2032
2033      if (missing.length) {
2034        this.trigger('warn', {
2035          message: `${identifier} lacks required attribute(s): ${missing.join(', ')}`
2036        });
2037      }
2038    }
2039    /**
2040     * Parse the input string and update the manifest object.
2041     *
2042     * @param {string} chunk a potentially incomplete portion of the manifest
2043     */
2044
2045
2046    push(chunk) {
2047      this.lineStream.push(chunk);
2048    }
2049    /**
2050     * Flush any remaining input. This can be handy if the last line of an M3U8
2051     * manifest did not contain a trailing newline but the file has been
2052     * completely received.
2053     */
2054
2055
2056    end() {
2057      // flush any buffered input
2058      this.lineStream.push('\n');
2059
2060      if (this.manifest.dateRanges.length && this.lastProgramDateTime === null) {
2061        this.trigger('warn', {
2062          message: 'A playlist with EXT-X-DATERANGE tag must contain atleast one EXT-X-PROGRAM-DATE-TIME tag'
2063        });
2064      }
2065
2066      this.lastProgramDateTime = null;
2067      this.trigger('end');
2068    }
2069    /**
2070     * Add an additional parser for non-standard tags
2071     *
2072     * @param {Object}   options              a map of options for the added parser
2073     * @param {RegExp}   options.expression   a regular expression to match the custom header
2074     * @param {string}   options.customType   the custom type to register to the output
2075     * @param {Function} [options.dataParser] function to parse the line into an object
2076     * @param {boolean}  [options.segment]    should tag data be attached to the segment object
2077     */
2078
2079
2080    addParser(options) {
2081      this.parseStream.addParser(options);
2082    }
2083    /**
2084     * Add a custom header mapper
2085     *
2086     * @param {Object}   options
2087     * @param {RegExp}   options.expression   a regular expression to match the custom header
2088     * @param {Function} options.map          function to translate tag into a different tag
2089     */
2090
2091
2092    addTagMapper(options) {
2093      this.parseStream.addTagMapper(options);
2094    }
2095
2096  }
2097
2098  var regexs = {
2099    // to determine mime types
2100    mp4: /^(av0?1|avc0?[1234]|vp0?9|flac|opus|mp3|mp4a|mp4v|stpp.ttml.im1t)/,
2101    webm: /^(vp0?[89]|av0?1|opus|vorbis)/,
2102    ogg: /^(vp0?[89]|theora|flac|opus|vorbis)/,
2103    // to determine if a codec is audio or video
2104    video: /^(av0?1|avc0?[1234]|vp0?[89]|hvc1|hev1|theora|mp4v)/,
2105    audio: /^(mp4a|flac|vorbis|opus|ac-[34]|ec-3|alac|mp3|speex|aac)/,
2106    text: /^(stpp.ttml.im1t)/,
2107    // mux.js support regex
2108    muxerVideo: /^(avc0?1)/,
2109    muxerAudio: /^(mp4a)/,
2110    // match nothing as muxer does not support text right now.
2111    // there cannot never be a character before the start of a string
2112    // so this matches nothing.
2113    muxerText: /a^/
2114  };
2115  var mediaTypes = ['video', 'audio', 'text'];
2116  var upperMediaTypes = ['Video', 'Audio', 'Text'];
2117  /**
2118   * Replace the old apple-style `avc1.<dd>.<dd>` codec string with the standard
2119   * `avc1.<hhhhhh>`
2120   *
2121   * @param {string} codec
2122   *        Codec string to translate
2123   * @return {string}
2124   *         The translated codec string
2125   */
2126
2127  var translateLegacyCodec = function translateLegacyCodec(codec) {
2128    if (!codec) {
2129      return codec;
2130    }
2131
2132    return codec.replace(/avc1\.(\d+)\.(\d+)/i, function (orig, profile, avcLevel) {
2133      var profileHex = ('00' + Number(profile).toString(16)).slice(-2);
2134      var avcLevelHex = ('00' + Number(avcLevel).toString(16)).slice(-2);
2135      return 'avc1.' + profileHex + '00' + avcLevelHex;
2136    });
2137  };
2138  /**
2139   * @typedef {Object} ParsedCodecInfo
2140   * @property {number} codecCount
2141   *           Number of codecs parsed
2142   * @property {string} [videoCodec]
2143   *           Parsed video codec (if found)
2144   * @property {string} [videoObjectTypeIndicator]
2145   *           Video object type indicator (if found)
2146   * @property {string|null} audioProfile
2147   *           Audio profile
2148   */
2149
2150  /**
2151   * Parses a codec string to retrieve the number of codecs specified, the video codec and
2152   * object type indicator, and the audio profile.
2153   *
2154   * @param {string} [codecString]
2155   *        The codec string to parse
2156   * @return {ParsedCodecInfo}
2157   *         Parsed codec info
2158   */
2159
2160  var parseCodecs = function parseCodecs(codecString) {
2161    if (codecString === void 0) {
2162      codecString = '';
2163    }
2164
2165    var codecs = codecString.split(',');
2166    var result = [];
2167    codecs.forEach(function (codec) {
2168      codec = codec.trim();
2169      var codecType;

2170      mediaTypes.forEach(function (name) {
2171        var match = regexs[name].exec(codec.toLowerCase());
2172
2173        if (!match || match.length <= 1) {
2174          return;
2175        }
2176
2177        codecType = name; // maintain codec case
2178
2179        var type = codec.substring(0, match[1].length);
2180        var details = codec.replace(type, '');
2181        result.push({
2182          type: type,
2183          details: details,
2184          mediaType: name
2185        });
2186      });
2187
2188      if (!codecType) {
2189        result.push({
2190          type: codec,
2191          details: '',
2192          mediaType: 'unknown'
2193        });
2194      }
2195    });
2196    return result;
2197  };
2198  /**
2199   * Returns a ParsedCodecInfo object for the default alternate audio playlist if there is
2200   * a default alternate audio playlist for the provided audio group.
2201   *
2202   * @param {Object} master
2203   *        The master playlist
2204   * @param {string} audioGroupId
2205   *        ID of the audio group for which to find the default codec info
2206   * @return {ParsedCodecInfo}
2207   *         Parsed codec info
2208   */
2209
2210  var codecsFromDefault = function codecsFromDefault(master, audioGroupId) {
2211    if (!master.mediaGroups.AUDIO || !audioGroupId) {
2212      return null;
2213    }
2214
2215    var audioGroup = master.mediaGroups.AUDIO[audioGroupId];
2216
2217    if (!audioGroup) {
2218      return null;
2219    }
2220
2221    for (var name in audioGroup) {
2222      var audioType = audioGroup[name];
2223
2224      if (audioType.default && audioType.playlists) {
2225        // codec should be the same for all playlists within the audio type
2226        return parseCodecs(audioType.playlists[0].attributes.CODECS);
2227      }
2228    }
2229
2230    return null;
2231  };
2232  var isAudioCodec = function isAudioCodec(codec) {
2233    if (codec === void 0) {
2234      codec = '';
2235    }
2236
2237    return regexs.audio.test(codec.trim().toLowerCase());
2238  };
2239  var isTextCodec = function isTextCodec(codec) {
2240    if (codec === void 0) {
2241      codec = '';
2242    }
2243
2244    return regexs.text.test(codec.trim().toLowerCase());
2245  };
2246  var getMimeForCodec = function getMimeForCodec(codecString) {
2247    if (!codecString || typeof codecString !== 'string') {
2248      return;
2249    }
2250
2251    var codecs = codecString.toLowerCase().split(',').map(function (c) {
2252      return translateLegacyCodec(c.trim());
2253    }); // default to video type
2254
2255    var type = 'video'; // only change to audio type if the only codec we have is
2256    // audio
2257
2258    if (codecs.length === 1 && isAudioCodec(codecs[0])) {
2259      type = 'audio';
2260    } else if (codecs.length === 1 && isTextCodec(codecs[0])) {
2261      // text uses application/<container> for now
2262      type = 'application';
2263    } // default the container to mp4
2264
2265
2266    var container = 'mp4'; // every codec must be able to go into the container
2267    // for that container to be the correct one
2268
2269    if (codecs.every(function (c) {
2270      return regexs.mp4.test(c);
2271    })) {
2272      container = 'mp4';
2273    } else if (codecs.every(function (c) {
2274      return regexs.webm.test(c);
2275    })) {
2276      container = 'webm';
2277    } else if (codecs.every(function (c) {
2278      return regexs.ogg.test(c);
2279    })) {
2280      container = 'ogg';
2281    }
2282
2283    return type + "/" + container + ";codecs=\"" + codecString + "\"";
2284  };
2285  var browserSupportsCodec = function browserSupportsCodec(codecString) {
2286    if (codecString === void 0) {
2287      codecString = '';
2288    }
2289
2290    return window.MediaSource && window.MediaSource.isTypeSupported && window.MediaSource.isTypeSupported(getMimeForCodec(codecString)) || false;
2291  };
2292  var muxerSupportsCodec = function muxerSupportsCodec(codecString) {
2293    if (codecString === void 0) {
2294      codecString = '';
2295    }
2296
2297    return codecString.toLowerCase().split(',').every(function (codec) {
2298      codec = codec.trim(); // any match is supported.
2299
2300      for (var i = 0; i < upperMediaTypes.length; i++) {
2301        var type = upperMediaTypes[i];
2302
2303        if (regexs["muxer" + type].test(codec)) {
2304          return true;
2305        }
2306      }
2307
2308      return false;
2309    });
2310  };
2311  var DEFAULT_AUDIO_CODEC = 'mp4a.40.2';
2312  var DEFAULT_VIDEO_CODEC = 'avc1.4d400d';
2313
2314  /**
2315   * Provides a compatibility layer between Video.js 7 and 8 API changes for VHS.
2316   */
2317  /**
2318   * Delegates to videojs.obj.merge (Video.js 8) or
2319   * videojs.mergeOptions (Video.js 7).
2320   */
2321
2322  function merge$1(...args) {
2323    const context = videojs__default["default"].obj || videojs__default["default"];
2324    const fn = context.merge || context.mergeOptions;

2335;
2336  }
2337
2338  /**
2339   * ranges
2340   *
2341   * Utilities for working with TimeRanges.
2342   *
2343   */
2344
2345  const TIME_FUDGE_FACTOR = 1 / 30; // Comparisons between time values such as current time and the end of the buffered range
2346  // can be misleading because of precision differences or when the current media has poorly
2347  // aligned audio and video, which can cause values to be slightly off from what you would
2348  // expect. This value is what we consider to be safe to use in such comparisons to account
2349  // for these scenarios.
2350
2351  const SAFE_TIME_DELTA = TIME_FUDGE_FACTOR * 3;
2352
2353  const filterRanges = function (timeRanges, predicate) {
2354    const results = [];
2355    let i;
2356
2357    if (timeRanges && timeRanges.length) {
2358      // Search for ranges that match the predicate
2359      for (i = 0; i < timeRanges.length; i++) {
2360        if (predicate(timeRanges.start(i), timeRanges.end(i))) {
2361          results.push([timeRanges.start(i), timeRanges.end(i)]);
2362        }
2363      }
2364    }
2365
2366    return createTimeRanges(results);
2367  };
2368  /**
2369   * Attempts to find the buffered TimeRange that contains the specified
2370   * time.
2371   *
2372   * @param {TimeRanges} buffered - the TimeRanges object to query
2373   * @param {number} time  - the time to filter on.
2374   * @return {TimeRanges} a new TimeRanges object
2375   */
2376
2377
2378  const findRange = function (buffered, time) {
2379    return filterRanges(buffered, function (start, end) {
2380      return start - SAFE_TIME_DELTA <= time && end + SAFE_TIME_DELTA >= time;
2381    });
2382  };
2383  /**
2384   * Returns the TimeRanges that begin later than the specified time.
2385   *
2386   * @param {TimeRanges} timeRanges - the TimeRanges object to query
2387   * @param {number} time - the time to filter on.
2388   * @return {TimeRanges} a new TimeRanges object.
2389   */
2390
2391  const findNextRange = function (timeRanges, time) {
2392    return filterRanges(timeRanges, function (start) {
2393      return start - TIME_FUDGE_FACTOR >= time;
2394    });
2395  };
2396  /**
2397   * Returns gaps within a list of TimeRanges
2398   *
2399   * @param {TimeRanges} buffered - the TimeRanges object
2400   * @return {TimeRanges} a TimeRanges object of gaps
2401   */
2402
2403  const findGaps = function (buffered) {
2404    if (buffered.length < 2) {
2405      return createTimeRanges();
2406    }
2407
2408    const ranges = [];
2409
2410    for (let i = 1; i < buffered.length; i++) {
2411      const start = buffered.end(i - 1);
2412      const end = buffered.start(i);
2413      ranges.push([start, end]);
2414    }
2415
2416    return createTimeRanges(ranges);
2417  };
2418  /**
2419   * Calculate the intersection of two TimeRanges
2420   *
2421   * @param {TimeRanges} bufferA
2422   * @param {TimeRanges} bufferB
2423   * @return {TimeRanges} The interesection of `bufferA` with `bufferB`
2424   */
2425
2426  const bufferIntersection = function (bufferA, bufferB) {
2427    let start = null;
2428    let end = null;
2429    let arity = 0;
2430    const extents = [];
2431    const ranges = [];
2432
2433    if (!bufferA || !bufferA.length || !bufferB || !bufferB.length) {
2434      return createTimeRanges();
2435    } // Handle the case where we have both buffers and create an
2436    // intersection of the two
2437
2438
2439    let count = bufferA.length; // A) Gather up all start and end times
2440
2441    while (count--) {
2442      extents.push({
2443        time: bufferA.start(count),
2444        type: 'start'
2445      });
2446      extents.push({
2447        time: bufferA.end(count),
2448        type: 'end'
2449      });
2450    }
2451
2452    count = bufferB.length;
2453
2454    while (count--) {
2455      extents.push({
2456        time: bufferB.start(count),
2457        type: 'start'
2458      });
2459      extents.push({
2460        time: bufferB.end(count),
2461        type: 'end'
2462      });
2463    } // B) Sort them by time
2464
2465
2466    extents.sort(function (a, b) {
2467      return a.time - b.time;
2468    }); // C) Go along one by one incrementing arity for start and decrementing
2469    //    arity for ends
2470
2471    for (count = 0; count < extents.length; count++) {
2472      if (extents[count].type === 'start') {
2473        arity++; // D) If arity is ever incremented to 2 we are entering an
2474        //    overlapping range
2475
2476        if (arity === 2) {
2477          start = extents[count].time;
2478        }
2479      } else if (extents[count].type === 'end') {
2480        arity--; // E) If arity is ever decremented to 1 we leaving an
2481        //    overlapping range
2482
2483        if (arity === 1) {
2484          end = extents[count].time;
2485        }
2486      } // F) Record overlapping ranges
2487
2488
2489      if (start !== null && end !== null) {
2490        ranges.push([start, end]);
2491        start = null;
2492        end = null;
2493      }
2494    }
2495
2496    return createTimeRanges(ranges);
2497  };
2498  /**
2499   * Gets a human readable string for a TimeRange
2500   *
2501   * @param {TimeRange} range
2502   * @return {string} a human readable string
2503   */
2504
2505  const printableRange = range => {
2506    const strArr = [];
2507
2508    if (!range || !range.length) {
2509      return '';
2510    }
2511
2512    for (let i = 0; i < range.length; i++) {
2513      strArr.push(range.start(i) + ' => ' + range.end(i));
2514    }
2515
2516    return strArr.join(', ');
2517  };
2518  /**
2519   * Calculates the amount of time left in seconds until the player hits the end of the
2520   * buffer and causes a rebuffer
2521   *
2522   * @param {TimeRange} buffered
2523   *        The state of the buffer
2524   * @param {Numnber} currentTime
2525   *        The current time of the player
2526   * @param {number} playbackRate
2527   *        The current playback rate of the player. Defaults to 1.
2528   * @return {number}
2529   *         Time until the player has to start rebuffering in seconds.
2530   * @function timeUntilRebuffer
2531   */
2532
2533  const timeUntilRebuffer = function (buffered, currentTime, playbackRate = 1) {
2534    const bufferedEnd = buffered.length ? buffered.end(buffered.length - 1) : 0;
2535    return (bufferedEnd - currentTime) / playbackRate;
2536  };
2537  /**
2538   * Converts a TimeRanges object into an array representation
2539   *
2540   * @param {TimeRanges} timeRanges
2541   * @return {Array}
2542   */
2543
2544  const timeRangesToArray = timeRanges => {
2545    const timeRangesList = [];
2546
2547    for (let i = 0; i < timeRanges.length; i++) {
2548      timeRangesList.push({
2549        start: timeRanges.start(i),
2550        end: timeRanges.end(i)
2551      });
2552    }
2553
2554    return timeRangesList;
2555  };
2556  /**
2557   * Determines if two time range objects are different.
2558   *
2559   * @param {TimeRange} a
2560   *        the first time range object to check
2561   *
2562   * @param {TimeRange} b
2563   *        the second time range object to check
2564   *
2565   * @return {Boolean}
2566   *         Whether the time range objects differ
2567   */
2568
2569  const isRangeDifferent = function (a, b) {
2570    // same object
2571    if (a === b) {
2572      return false;
2573    } // one or the other is undefined
2574
2575
2576    if (!a && b || !b && a) {
2577      return true;
2578    } // length is different
2579
2580
2581    if (a.length !== b.length) {
2582      return true;
2583    } // see if any start/end pair is different
2584
2585
2586    for (let i = 0; i < a.length; i++) {
2587      if (a.start(i) !== b.start(i) || a.end(i) !== b.end(i)) {
2588        return true;
2589      }
2590    } // if the length and every pair is the same
2591    // this is the same time range
2592
2593
2594    return false;
2595  };
2596  const lastBufferedEnd = function (a) {
2597    if (!a || !a.length || !a.end) {
2598      return;
2599    }
2600
2601    return a.end(a.length - 1);
2602  };
2603  /**
2604   * A utility function to add up the amount of time in a timeRange
2605   * after a specified startTime.
2606   * ie:[[0, 10], [20, 40], [50, 60]] with a startTime 0
2607   *     would return 40 as there are 40s seconds after 0 in the timeRange
2608   *
2609   * @param {TimeRange} range
2610   *        The range to check against
2611   * @param {number} startTime
2612   *        The time in the time range that you should start counting from
2613   *
2614   * @return {number}
2615   *          The number of seconds in the buffer passed the specified time.
2616   */
2617
2618  const timeAheadOf = function (range, startTime) {
2619    let time = 0;
2620
2621    if (!range || !range.length) {
2622      return time;
2623    }
2624
2625    for (let i = 0; i < range.length; i++) {
2626      const start = range.start(i);
2627      const end = range.end(i); // startTime is after this range entirely
2628
2629      if (startTime > end) {
2630        continue;
2631      } // startTime is within this range
2632
2633
2634      if (startTime > start && startTime <= end) {
2635        time += end - startTime;
2636        continue;
2637      } // startTime is before this range.
2638
2639
2640      time += end - start;
2641    }
2642
2643    return time;
2644  };
2645
2646  /**
2647   * @file playlist.js
2648   *
2649   * Playlist related utilities.
2650   */
2651  /**
2652   * Get the duration of a segment, with special cases for
2653   * llhls segments that do not have a duration yet.
2654   *
2655   * @param {Object} playlist
2656   *        the playlist that the segment belongs to.
2657   * @param {Object} segment
2658   *        the segment to get a duration for.
2659   *
2660   * @return {number}
2661   *          the segment duration
2662   */
2663
2664  const segmentDurationWithParts = (playlist, segment) => {
2665    // if this isn't a preload segment
2666    // then we will have a segment duration that is accurate.
2667    if (!segment.preload) {
2668      return segment.duration;
2669    } // otherwise we have to add up parts and preload hints
2670    // to get an up to date duration.
2671
2672
2673    let result = 0;
2674    (segment.parts || []).forEach(function (p) {
2675      result += p.duration;
2676    }); // for preload hints we have to use partTargetDuration
2677    // as they won't even have a duration yet.
2678
2679    (segment.preloadHints || []).forEach(function (p) {
2680      if (p.type === 'PART') {
2681        result += playlist.partTargetDuration;
2682      }
2683    });
2684    return result;
2685  };
2686  /**
2687   * A function to get a combined list of parts and segments with durations
2688   * and indexes.
2689   *
2690   * @param {Playlist} playlist the playlist to get the list for.
2691   *
2692   * @return {Array} The part/segment list.
2693   */
2694
2695  const getPartsAndSegments = playlist => (playlist.segments || []).reduce((acc, segment, si) => {
2696    if (segment.parts) {
2697      segment.parts.forEach(function (part, pi) {
2698        acc.push({
2699          duration: part.duration,
2700          segmentIndex: si,
2701          partIndex: pi,
2702          part,
2703          segment
2704        });
2705      });
2706    } else {
2707      acc.push({
2708        duration: segment.duration,
2709        segmentIndex: si,
2710        partIndex: null,
2711        segment,
2712        part: null
2713      });
2714    }
2715
2716    return acc;
2717  }, []);
2718  const getLastParts = media => {
2719    const lastSegment = media.segments && media.segments.length && media.segments[media.segments.length - 1];
2720    return lastSegment && lastSegment.parts || [];
2721  };
2722  const getKnownPartCount = ({
2723    preloadSegment
2724  }) => {
2725    if (!preloadSegment) {
2726      return;
2727    }
2728
2729    const {
2730      parts,
2731      preloadHints
2732    } = preloadSegment;
2733    let partCount = (preloadHints || []).reduce((count, hint) => count + (hint.type === 'PART' ? 1 : 0), 0);
2734    partCount += parts && parts.length ? parts.length : 0;
2735    return partCount;
2736  };
2737  /**
2738   * Get the number of seconds to delay from the end of a
2739   * live playlist.
2740   *
2741   * @param {Playlist} main the main playlist
2742   * @param {Playlist} media the media playlist
2743   * @return {number} the hold back in seconds.
2744   */
2745
2746  const liveEdgeDelay = (main, media) => {
2747    if (media.endList) {
2748      return 0;
2749    } // dash suggestedPresentationDelay trumps everything
2750
2751
2752    if (main && main.suggestedPresentationDelay) {
2753      return main.suggestedPresentationDelay;
2754    }
2755
2756    const hasParts = getLastParts(media).length > 0; // look for "part" delays from ll-hls first
2757
2758    if (hasParts && media.serverControl && media.serverControl.partHoldBack) {
2759      return media.serverControl.partHoldBack;
2760    } else if (hasParts && media.partTargetDuration) {
2761      return media.partTargetDuration * 3; // finally look for full segment delays
2762    } else if (media.serverControl && media.serverControl.holdBack) {
2763      return media.serverControl.holdBack;
2764    } else if (media.targetDuration) {
2765      return media.targetDuration * 3;
2766    }
2767
2768    return 0;
2769  };
2770  /**
2771   * walk backward until we find a duration we can use
2772   * or return a failure
2773   *
2774   * @param {Playlist} playlist the playlist to walk through
2775   * @param {Number} endSequence the mediaSequence to stop walking on
2776   */
2777
2778  const backwardDuration = function (playlist, endSequence) {
2779    let result = 0;
2780    let i = endSequence - playlist.mediaSequence; // if a start time is available for segment immediately following
2781    // the interval, use it
2782
2783    let segment = playlist.segments[i]; // Walk backward until we find the latest segment with timeline
2784    // information that is earlier than endSequence
2785
2786    if (segment) {
2787      if (typeof segment.start !== 'undefined') {
2788        return {
2789          result: segment.start,
2790          precise: true
2791        };
2792      }
2793
2794      if (typeof segment.end !== 'undefined') {
2795        return {
2796          result: segment.end - segment.duration,
2797          precise: true
2798        };
2799      }
2800    }
2801
2802    while (i--) {
2803      segment = playlist.segments[i];
2804
2805      if (typeof segment.end !== 'undefined') {
2806        return {
2807          result: result + segment.end,
2808          precise: true
2809        };
2810      }
2811
2812      result += segmentDurationWithParts(playlist, segment);
2813
2814      if (typeof segment.start !== 'undefined') {
2815        return {
2816          result: result + segment.start,
2817          precise: true
2818        };
2819      }
2820    }
2821
2822    return {
2823      result,
2824      precise: false
2825    };
2826  };
2827  /**
2828   * walk forward until we find a duration we can use
2829   * or return a failure
2830   *
2831   * @param {Playlist} playlist the playlist to walk through
2832   * @param {number} endSequence the mediaSequence to stop walking on
2833   */
2834
2835
2836  const forwardDuration = function (playlist, endSequence) {
2837    let result = 0;
2838    let segment;
2839    let i = endSequence - playlist.mediaSequence; // Walk forward until we find the earliest segment with timeline
2840    // information
2841
2842    for (; i < playlist.segments.length; i++) {
2843      segment = playlist.segments[i];
2844
2845      if (typeof segment.start !== 'undefined') {
2846        return {
2847          result: segment.start - result,
2848          precise: true
2849        };
2850      }
2851
2852      result += segmentDurationWithParts(playlist, segment);
2853
2854      if (typeof segment.end !== 'undefined') {
2855        return {
2856          result: segment.end - result,
2857          precise: true
2858        };
2859      }
2860    } // indicate we didn't find a useful duration estimate
2861
2862
2863    return {
2864      result: -1,
2865      precise: false
2866    };
2867  };
2868  /**
2869    * Calculate the media duration from the segments associated with a
2870    * playlist. The duration of a subinterval of the available segments
2871    * may be calculated by specifying an end index.
2872    *
2873    * @param {Object} playlist a media playlist object
2874    * @param {number=} endSequence an exclusive upper boundary
2875    * for the playlist.  Defaults to playlist length.
2876    * @param {number} expired the amount of time that has dropped
2877    * off the front of the playlist in a live scenario
2878    * @return {number} the duration between the first available segment
2879    * and end index.
2880    */
2881
2882
2883  const intervalDuration = function (playlist, endSequence, expired) {
2884    if (typeof endSequence === 'undefined') {
2885      endSequence = playlist.mediaSequence + playlist.segments.length;
2886    }
2887
2888    if (endSequence < playlist.mediaSequence) {
2889      return 0;
2890    } // do a backward walk to estimate the duration
2891
2892
2893    const backward = backwardDuration(playlist, endSequence);
2894
2895    if (backward.precise) {
2896      // if we were able to base our duration estimate on timing
2897      // information provided directly from the Media Source, return
2898      // it
2899      return backward.result;
2900    } // walk forward to see if a precise duration estimate can be made
2901    // that way
2902
2903
2904    const forward = forwardDuration(playlist, endSequence);
2905
2906    if (forward.precise) {
2907      // we found a segment that has been buffered and so it's
2908      // position is known precisely
2909      return forward.result;
2910    } // return the less-precise, playlist-based duration estimate
2911
2912
2913    return backward.result + expired;
2914  };
2915  /**
2916    * Calculates the duration of a playlist. If a start and end index
2917    * are specified, the duration will be for the subset of the media
2918    * timeline between those two indices. The total duration for live
2919    * playlists is always Infinity.
2920    *
2921    * @param {Object} playlist a media playlist object
2922    * @param {number=} endSequence an exclusive upper
2923    * boundary for the playlist. Defaults to the playlist media
2924    * sequence number plus its length.
2925    * @param {number=} expired the amount of time that has
2926    * dropped off the front of the playlist in a live scenario
2927    * @return {number} the duration between the start index and end
2928    * index.
2929    */
2930
2931
2932  const duration = function (playlist, endSequence, expired) {
2933    if (!playlist) {
2934      return 0;
2935    }
2936
2937    if (typeof expired !== 'number') {
2938      expired = 0;
2939    } // if a slice of the total duration is not requested, use
2940    // playlist-level duration indicators when they're present
2941
2942
2943    if (typeof endSequence === 'undefined') {
2944      // if present, use the duration specified in the playlist
2945      if (playlist.totalDuration) {
2946        return playlist.totalDuration;
2947      } // duration should be Infinity for live playlists
2948
2949
2950      if (!playlist.endList) {
2951        return window.Infinity;
2952      }
2953    } // calculate the total duration based on the segment durations
2954
2955
2956    return intervalDuration(playlist, endSequence, expired);
2957  };
2958  /**
2959    * Calculate the time between two indexes in the current playlist
2960    * neight the start- nor the end-index need to be within the current
2961    * playlist in which case, the targetDuration of the playlist is used
2962    * to approximate the durations of the segments
2963    *
2964    * @param {Array} options.durationList list to iterate over for durations.
2965    * @param {number} options.defaultDuration duration to use for elements before or after the durationList
2966    * @param {number} options.startIndex partsAndSegments index to start
2967    * @param {number} options.endIndex partsAndSegments index to end.
2968    * @return {number} the number of seconds between startIndex and endIndex
2969    */
2970
2971  const sumDurations = function ({
2972    defaultDuration,
2973    durationList,
2974    startIndex,
2975    endIndex
2976  }) {
2977    let durations = 0;
2978
2979    if (startIndex > endIndex) {
2980      [startIndex, endIndex] = [endIndex, startIndex];
2981    }
2982
2983    if (startIndex < 0) {
2984      for (let i = startIndex; i < Math.min(0, endIndex); i++) {
2985        durations += defaultDuration;
2986      }
2987
2988      startIndex = 0;
2989    }
2990
2991    for (let i = startIndex; i < endIndex; i++) {
2992      durations += durationList[i].duration;
2993    }
2994
2995    return durations;
2996  };
2997  /**
2998   * Calculates the playlist end time
2999   *
3000   * @param {Object} playlist a media playlist object
3001   * @param {number=} expired the amount of time that has
3002   *                  dropped off the front of the playlist in a live scenario
3003   * @param {boolean|false} useSafeLiveEnd a boolean value indicating whether or not the
3004   *                        playlist end calculation should consider the safe live end
3005   *                        (truncate the playlist end by three segments). This is normally
3006   *                        used for calculating the end of the playlist's seekable range.
3007   *                        This takes into account the value of liveEdgePadding.
3008   *                        Setting liveEdgePadding to 0 is equivalent to setting this to false.
3009   * @param {number} liveEdgePadding a number indicating how far from the end of the playlist we should be in seconds.
3010   *                 If this is provided, it is used in the safe live end calculation.
3011   *                 Setting useSafeLiveEnd=false or liveEdgePadding=0 are equivalent.
3012   *                 Corresponds to suggestedPresentationDelay in DASH manifests.
3013   * @return {number} the end time of playlist
3014   * @function playlistEnd
3015   */
3016
3017  const playlistEnd = function (playlist, expired, useSafeLiveEnd, liveEdgePadding) {
3018    if (!playlist || !playlist.segments) {
3019      return null;
3020    }
3021
3022    if (playlist.endList) {
3023      return duration(playlist);
3024    }
3025
3026    if (expired === null) {
3027      return null;
3028    }
3029
3030    expired = expired || 0;
3031    let lastSegmentEndTime = intervalDuration(playlist, playlist.mediaSequence + playlist.segments.length, expired);
3032
3033    if (useSafeLiveEnd) {
3034      liveEdgePadding = typeof liveEdgePadding === 'number' ? liveEdgePadding : liveEdgeDelay(null, playlist);
3035      lastSegmentEndTime -= liveEdgePadding;
3036    } // don't return a time less than zero
3037
3038
3039    return Math.max(0, lastSegmentEndTime);
3040  };
3041  /**
3042    * Calculates the interval of time that is currently seekable in a
3043    * playlist. The returned time ranges are relative to the earliest
3044    * moment in the specified playlist that is still available. A full
3045    * seekable implementation for live streams would need to offset
3046    * these values by the duration of content that has expired from the
3047    * stream.
3048    *
3049    * @param {Object} playlist a media playlist object
3050    * dropped off the front of the playlist in a live scenario
3051    * @param {number=} expired the amount of time that has
3052    * dropped off the front of the playlist in a live scenario
3053    * @param {number} liveEdgePadding how far from the end of the playlist we should be in seconds.
3054    *        Corresponds to suggestedPresentationDelay in DASH manifests.
3055    * @return {TimeRanges} the periods of time that are valid targets
3056    * for seeking
3057    */
3058
3059  const seekable = function (playlist, expired, liveEdgePadding) {
3060    const useSafeLiveEnd = true;
3061    const seekableStart = expired || 0;
3062    let seekableEnd = playlistEnd(playlist, expired, useSafeLiveEnd, liveEdgePadding);
3063
3064    if (seekableEnd === null) {
3065      return createTimeRanges();
3066    } // Clamp seekable end since it can not be less than the seekable start
3067
3068
3069    if (seekableEnd < seekableStart) {
3070      seekableEnd = seekableStart;
3071    }
3072
3073    return createTimeRanges(seekableStart, seekableEnd);
3074  };
3075  /**
3076   * Determine the index and estimated starting time of the segment that
3077   * contains a specified playback position in a media playlist.
3078   *
3079   * @param {Object} options.playlist the media playlist to query
3080   * @param {number} options.currentTime The number of seconds since the earliest
3081   * possible position to determine the containing segment for
3082   * @param {number} options.startTime the time when the segment/part starts
3083   * @param {number} options.startingSegmentIndex the segment index to start looking at.
3084   * @param {number?} [options.startingPartIndex] the part index to look at within the segment.
3085   *
3086   * @return {Object} an object with partIndex, segmentIndex, and startTime.
3087   */
3088
3089  const getMediaInfoForTime = function ({
3090    playlist,
3091    currentTime,
3092    startingSegmentIndex,
3093    startingPartIndex,
3094    startTime,
3095    exactManifestTimings
3096  }) {
3097    let time = currentTime - startTime;
3098    const partsAndSegments = getPartsAndSegments(playlist);
3099    let startIndex = 0;
3100
3101    for (let i = 0; i < partsAndSegments.length; i++) {
3102      const partAndSegment = partsAndSegments[i];
3103
3104      if (startingSegmentIndex !== partAndSegment.segmentIndex) {
3105        continue;
3106      } // skip this if part index does not match.
3107
3108
3109      if (typeof startingPartIndex === 'number' && typeof partAndSegment.partIndex === 'number' && startingPartIndex !== partAndSegment.partIndex) {
3110        continue;
3111      }
3112
3113      startIndex = i;
3114      break;
3115    }
3116
3117    if (time < 0) {
3118      // Walk backward from startIndex in the playlist, adding durations
3119      // until we find a segment that contains `time` and return it
3120      if (startIndex > 0) {
3121        for (let i = startIndex - 1; i >= 0; i--) {
3122          const partAndSegment = partsAndSegments[i];
3123          time += partAndSegment.duration;
3124
3125          if (exactManifestTimings) {
3126            if (time < 0) {
3127              continue;
3128            }
3129          } else if (time + TIME_FUDGE_FACTOR <= 0) {
3130            continue;
3131          }
3132
3133          return {
3134            partIndex: partAndSegment.partIndex,
3135            segmentIndex: partAndSegment.segmentIndex,
3136            startTime: startTime - sumDurations({
3137              defaultDuration: playlist.targetDuration,
3138              durationList: partsAndSegments,
3139              startIndex,
3140              endIndex: i
3141            })
3142          };
3143        }
3144      } // We were unable to find a good segment within the playlist
3145      // so select the first segment
3146
3147
3148      return {
3149        partIndex: partsAndSegments[0] && partsAndSegments[0].partIndex || null,
3150        segmentIndex: partsAndSegments[0] && partsAndSegments[0].segmentIndex || 0,
3151        startTime: currentTime
3152      };
3153    } // When startIndex is negative, we first walk forward to first segment
3154    // adding target durations. If we "run out of time" before getting to
3155    // the first segment, return the first segment
3156
3157
3158    if (startIndex < 0) {
3159      for (let i = startIndex; i < 0; i++) {
3160        time -= playlist.targetDuration;
3161
3162        if (time < 0) {
3163          return {
3164            partIndex: partsAndSegments[0] && partsAndSegments[0].partIndex || null,
3165            segmentIndex: partsAndSegments[0] && partsAndSegments[0].segmentIndex || 0,
3166            startTime: currentTime
3167          };
3168        }
3169      }
3170
3171      startIndex = 0;
3172    } // Walk forward from startIndex in the playlist, subtracting durations
3173    // until we find a segment that contains `time` and return it
3174
3175
3176    for (let i = startIndex; i < partsAndSegments.length; i++) {
3177      const partAndSegment = partsAndSegments[i];
3178      time -= partAndSegment.duration;
3179      const canUseFudgeFactor = partAndSegment.duration > TIME_FUDGE_FACTOR;
3180      const isExactlyAtTheEnd = time === 0;
3181      const isExtremelyCloseToTheEnd = canUseFudgeFactor && time + TIME_FUDGE_FACTOR >= 0;
3182
3183      if (isExactlyAtTheEnd || isExtremelyCloseToTheEnd) {
3184        // 1) We are exactly at the end of the current segment.
3185        // 2) We are extremely close to the end of the current segment (The difference is less than  1 / 30).
3186        //    We may encounter this situation when
3187        //    we don't have exact match between segment duration info in the manifest and the actual duration of the segment
3188        //    For example:
3189        //    We appended 3 segments 10 seconds each, meaning we should have 30 sec buffered,
3190        //    but we the actual buffered is 29.99999
3191        //
3192        // In both cases:
3193        // if we passed current time -> it means that we already played current segment
3194        // if we passed buffered.end -> it means that this segment is already loaded and buffered
3195        // we should select the next segment if we have one:
3196        if (i !== partsAndSegments.length - 1) {
3197          continue;
3198        }
3199      }
3200
3201      if (exactManifestTimings) {
3202        if (time > 0) {
3203          continue;
3204        }
3205      } else if (time - TIME_FUDGE_FACTOR >= 0) {
3206        continue;
3207      }
3208
3209      return {
3210        partIndex: partAndSegment.partIndex,
3211        segmentIndex: partAndSegment.segmentIndex,
3212        startTime: startTime + sumDurations({
3213          defaultDuration: playlist.targetDuration,
3214          durationList: partsAndSegments,
3215          startIndex,
3216          endIndex: i
3217        })
3218      };
3219    } // We are out of possible candidates so load the last one...
3220
3221
3222    return {
3223      segmentIndex: partsAndSegments[partsAndSegments.length - 1].segmentIndex,
3224      partIndex: partsAndSegments[partsAndSegments.length - 1].partIndex,
3225      startTime: currentTime
3226    };
3227  };
3228  /**
3229   * Check whether the playlist is excluded or not.
3230   *
3231   * @param {Object} playlist the media playlist object
3232   * @return {boolean} whether the playlist is excluded or not
3233   * @function isExcluded
3234   */
3235
3236  const isExcluded = function (playlist) {
3237    return playlist.excludeUntil && playlist.excludeUntil > Date.now();
3238  };
3239  /**
3240   * Check whether the playlist is compatible with current playback configuration or has
3241   * been excluded permanently for being incompatible.
3242   *
3243   * @param {Object} playlist the media playlist object
3244   * @return {boolean} whether the playlist is incompatible or not
3245   * @function isIncompatible
3246   */
3247
3248  const isIncompatible = function (playlist) {
3249    return playlist.excludeUntil && playlist.excludeUntil === Infinity;
3250  };
3251  /**
3252   * Check whether the playlist is enabled or not.
3253   *
3254   * @param {Object} playlist the media playlist object
3255   * @return {boolean} whether the playlist is enabled or not
3256   * @function isEnabled
3257   */
3258
3259  const isEnabled = function (playlist) {
3260    const excluded = isExcluded(playlist);
3261    return !playlist.disabled && !excluded;
3262  };
3263  /**
3264   * Check whether the playlist has been manually disabled through the representations api.
3265   *
3266   * @param {Object} playlist the media playlist object
3267   * @return {boolean} whether the playlist is disabled manually or not
3268   * @function isDisabled
3269   */
3270
3271  const isDisabled = function (playlist) {
3272    return playlist.disabled;
3273  };
3274  /**
3275   * Returns whether the current playlist is an AES encrypted HLS stream
3276   *
3277   * @return {boolean} true if it's an AES encrypted HLS stream
3278   */
3279
3280  const isAes = function (media) {
3281    for (let i = 0; i < media.segments.length; i++) {
3282      if (media.segments[i].key) {
3283        return true;
3284      }
3285    }
3286
3287    return false;
3288  };
3289  /**
3290   * Checks if the playlist has a value for the specified attribute
3291   *
3292   * @param {string} attr
3293   *        Attribute to check for
3294   * @param {Object} playlist
3295   *        The media playlist object
3296   * @return {boolean}
3297   *         Whether the playlist contains a value for the attribute or not
3298   * @function hasAttribute
3299   */
3300
3301  const hasAttribute = function (attr, playlist) {
3302    return playlist.attributes && playlist.attributes[attr];
3303  };
3304  /**
3305   * Estimates the time required to complete a segment download from the specified playlist
3306   *
3307   * @param {number} segmentDuration
3308   *        Duration of requested segment
3309   * @param {number} bandwidth
3310   *        Current measured bandwidth of the player
3311   * @param {Object} playlist
3312   *        The media playlist object
3313   * @param {number=} bytesReceived
3314   *        Number of bytes already received for the request. Defaults to 0
3315   * @return {number|NaN}
3316   *         The estimated time to request the segment. NaN if bandwidth information for
3317   *         the given playlist is unavailable
3318   * @function estimateSegmentRequestTime
3319   */
3320
3321  const estimateSegmentRequestTime = function (segmentDuration, bandwidth, playlist, bytesReceived = 0) {
3322    if (!hasAttribute('BANDWIDTH', playlist)) {
3323      return NaN;
3324    }
3325
3326    const size = segmentDuration * playlist.attributes.BANDWIDTH;
3327    return (size - bytesReceived * 8) / bandwidth;
3328  };
3329  /*
3330   * Returns whether the current playlist is the lowest rendition
3331   *
3332   * @return {Boolean} true if on lowest rendition
3333   */
3334
3335  const isLowestEnabledRendition = (main, media) => {
3336    if (main.playlists.length === 1) {
3337      return true;
3338    }
3339
3340    const currentBandwidth = media.attributes.BANDWIDTH || Number.MAX_VALUE;
3341    return main.playlists.filter(playlist => {
3342      if (!isEnabled(playlist)) {
3343        return false;
3344      }
3345
3346      return (playlist.attributes.BANDWIDTH || 0) < currentBandwidth;
3347    }).length === 0;
3348  };
3349  const playlistMatch = (a, b) => {
3350    // both playlits are null
3351    // or only one playlist is non-null
3352    // no match
3353    if (!a && !b || !a && b || a && !b) {
3354      return false;
3355    } // playlist objects are the same, match
3356
3357
3358    if (a === b) {
3359      return true;
3360    } // first try to use id as it should be the most
3361    // accurate
3362
3363
3364    if (a.id && b.id && a.id === b.id) {
3365      return true;
3366    } // next try to use reslovedUri as it should be the
3367    // second most accurate.
3368
3369
3370    if (a.resolvedUri && b.resolvedUri && a.resolvedUri === b.resolvedUri) {
3371      return true;
3372    } // finally try to use uri as it should be accurate
3373    // but might miss a few cases for relative uris
3374
3375
3376    if (a.uri && b.uri && a.uri === b.uri) {
3377      return true;
3378    }
3379
3380    return false;
3381  };
3382
3383  const someAudioVariant = function (main, callback) {
3384    const AUDIO = main && main.mediaGroups && main.mediaGroups.AUDIO || {};
3385    let found = false;
3386
3387    for (const groupName in AUDIO) {
3388      for (const label in AUDIO[groupName]) {
3389        found = callback(AUDIO[groupName][label]);
3390
3391        if (found) {
3392          break;
3393        }
3394      }
3395
3396      if (found) {
3397        break;
3398      }
3399    }
3400
3401    return !!found;
3402  };
3403
3404  const isAudioOnly = main => {
3405    // we are audio only if we have no main playlists but do
3406    // have media group playlists.
3407    if (!main || !main.playlists || !main.playlists.length) {
3408      // without audio variants or playlists this
3409      // is not an audio only main.
3410      const found = someAudioVariant(main, variant => variant.playlists && variant.playlists.length || variant.uri);
3411      return found;
3412    } // if every playlist has only an audio codec it is audio only
3413
3414
3415    for (let i = 0; i < main.playlists.length; i++) {
3416      const playlist = main.playlists[i];
3417      const CODECS = playlist.attributes && playlist.attributes.CODECS; // all codecs are audio, this is an audio playlist.
3418
3419      if (CODECS && CODECS.split(',').every(c => isAudioCodec(c))) {
3420        continue;
3421      } // playlist is in an audio group it is audio only
3422
3423
3424      const found = someAudioVariant(main, variant => playlistMatch(playlist, variant));
3425
3426      if (found) {
3427        continue;
3428      } // if we make it here this playlist isn't audio and we
3429      // are not audio only
3430
3431
3432      return false;
3433    } // if we make it past every playlist without returning, then
3434    // this is an audio only playlist.
3435
3436
3437    return true;
3438  }; // exports
3439
3440  var Playlist = {
3441    liveEdgeDelay,
3442    duration,
3443    seekable,
3444    getMediaInfoForTime,
3445    isEnabled,
3446    isDisabled,
3447    isExcluded,
3448    isIncompatible,
3449    playlistEnd,
3450    isAes,
3451    hasAttribute,
3452    estimateSegmentRequestTime,
3453    isLowestEnabledRendition,
3454    isAudioOnly,
3455    playlistMatch,
3456    segmentDurationWithParts
3457  };
3458
3459  const {
3460    log
3461  } = videojs__default["default"];
3462  const createPlaylistID = (index, uri) => {
3463    return `${index}-${uri}`;
3464  }; // default function for creating a group id
3465
3466  const groupID = (type, group, label) => {
3467    return `placeholder-uri-${type}-${group}-${label}`;
3468  };
3469  /**
3470   * Parses a given m3u8 playlist
3471   *
3472   * @param {Function} [onwarn]
3473   *        a function to call when the parser triggers a warning event.
3474   * @param {Function} [oninfo]
3475   *        a function to call when the parser triggers an info event.
3476   * @param {string} manifestString
3477   *        The downloaded manifest string
3478   * @param {Object[]} [customTagParsers]
3479   *        An array of custom tag parsers for the m3u8-parser instance
3480   * @param {Object[]} [customTagMappers]
3481   *        An array of custom tag mappers for the m3u8-parser instance
3482   * @param {boolean} [llhls]
3483   *        Whether to keep ll-hls features in the manifest after parsing.
3484   * @return {Object}
3485   *         The manifest object
3486   */
3487
3488  const parseManifest = ({
3489    onwarn,
3490    oninfo,
3491    manifestString,
3492    customTagParsers = [],
3493    customTagMappers = [],
3494    llhls
3495  }) => {
3496    const parser = new Parser();
3497
3498    if (onwarn) {
3499      parser.on('warn', onwarn);
3500    }
3501
3502    if (oninfo) {
3503      parser.on('info', oninfo);
3504    }
3505
3506    customTagParsers.forEach(customParser => parser.addParser(customParser));
3507    customTagMappers.forEach(mapper => parser.addTagMapper(mapper));
3508    parser.push(manifestString);
3509    parser.end();
3510    const manifest = parser.manifest; // remove llhls features from the parsed manifest
3511    // if we don't want llhls support.
3512
3513    if (!llhls) {
3514      ['preloadSegment', 'skip', 'serverControl', 'renditionReports', 'partInf', 'partTargetDuration'].forEach(function (k) {
3515        if (manifest.hasOwnProperty(k)) {
3516          delete manifest[k];
3517        }
3518      });
3519
3520      if (manifest.segments) {
3521        manifest.segments.forEach(function (segment) {
3522          ['parts', 'preloadHints'].forEach(function (k) {
3523            if (segment.hasOwnProperty(k)) {
3524              delete segment[k];
3525            }
3526          });
3527        });
3528      }
3529    }
3530
3531    if (!manifest.targetDuration) {
3532      let targetDuration = 10;
3533
3534      if (manifest.segments && manifest.segments.length) {
3535        targetDuration = manifest.segments.reduce((acc, s) => Math.max(acc, s.duration), 0);
3536      }
3537
3538      if (onwarn) {
3539        onwarn({
3540          message: `manifest has no targetDuration defaulting to ${targetDuration}`
3541        });
3542      }
3543
3544      manifest.targetDuration = targetDuration;
3545    }
3546
3547    const parts = getLastParts(manifest);
3548
3549    if (parts.length && !manifest.partTargetDuration) {
3550      const partTargetDuration = parts.reduce((acc, p) => Math.max(acc, p.duration), 0);
3551
3552      if (onwarn) {
3553        onwarn({
3554          message: `manifest has no partTargetDuration defaulting to ${partTargetDuration}`
3555        });
3556        log.error('LL-HLS manifest has parts but lacks required #EXT-X-PART-INF:PART-TARGET value. See https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-09#section-4.4.3.7. Playback is not guaranteed.');
3557      }
3558
3559      manifest.partTargetDuration = partTargetDuration;
3560    }
3561
3562    return manifest;
3563  };
3564  /**
3565   * Loops through all supported media groups in main and calls the provided
3566   * callback for each group
3567   *
3568   * @param {Object} main
3569   *        The parsed main manifest object
3570   * @param {Function} callback
3571   *        Callback to call for each media group
3572   */
3573
3574  const forEachMediaGroup$1 = (main, callback) => {
3575    if (!main.mediaGroups) {
3576      return;
3577    }
3578
3579    ['AUDIO', 'SUBTITLES'].forEach(mediaType => {
3580      if (!main.mediaGroups[mediaType]) {
3581        return;
3582      }
3583
3584      for (const groupKey in main.mediaGroups[mediaType]) {
3585        for (const labelKey in main.mediaGroups[mediaType][groupKey]) {
3586          const mediaProperties = main.mediaGroups[mediaType][groupKey][labelKey];
3587          callback(mediaProperties, mediaType, groupKey, labelKey);
3588        }
3589      }
3590    });
3591  };
3592  /**
3593   * Adds properties and attributes to the playlist to keep consistent functionality for
3594   * playlists throughout VHS.
3595   *
3596   * @param {Object} config
3597   *        Arguments object
3598   * @param {Object} config.playlist
3599   *        The media playlist
3600   * @param {string} [config.uri]
3601   *        The uri to the media playlist (if media playlist is not from within a main
3602   *        playlist)
3603   * @param {string} id
3604   *        ID to use for the playlist
3605   */
3606
3607  const setupMediaPlaylist = ({
3608    playlist,
3609    uri,
3610    id
3611  }) => {
3612    playlist.id = id;
3613    playlist.playlistErrors_ = 0;
3614
3615    if (uri) {
3616      // For media playlists, m3u8-parser does not have access to a URI, as HLS media
3617      // playlists do not contain their own source URI, but one is needed for consistency in
3618      // VHS.
3619      playlist.uri = uri;
3620    } // For HLS main playlists, even though certain attributes MUST be defined, the
3621    // stream may still be played without them.
3622    // For HLS media playlists, m3u8-parser does not attach an attributes object to the
3623    // manifest.
3624    //
3625    // To avoid undefined reference errors through the project, and make the code easier
3626    // to write/read, add an empty attributes object for these cases.
3627
3628
3629    playlist.attributes = playlist.attributes || {};
3630  };
3631  /**
3632   * Adds ID, resolvedUri, and attributes properties to each playlist of the main, where
3633   * necessary. In addition, creates playlist IDs for each playlist and adds playlist ID to
3634   * playlist references to the playlists array.
3635   *
3636   * @param {Object} main
3637   *        The main playlist
3638   */
3639
3640  const setupMediaPlaylists = main => {
3641    let i = main.playlists.length;
3642
3643    while (i--) {
3644      const playlist = main.playlists[i];
3645      setupMediaPlaylist({
3646        playlist,
3647        id: createPlaylistID(i, playlist.uri)
3648      });
3649      playlist.resolvedUri = resolveUrl(main.uri, playlist.uri);
3650      main.playlists[playlist.id] = playlist; // URI reference added for backwards compatibility
3651
3652      main.playlists[playlist.uri] = playlist; // Although the spec states an #EXT-X-STREAM-INF tag MUST have a BANDWIDTH attribute,
3653      // the stream can be played without it. Although an attributes property may have been
3654      // added to the playlist to prevent undefined references, issue a warning to fix the
3655      // manifest.
3656
3657      if (!playlist.attributes.BANDWIDTH) {
3658        log.warn('Invalid playlist STREAM-INF detected. Missing BANDWIDTH attribute.');
3659      }
3660    }
3661  };
3662  /**
3663   * Adds resolvedUri properties to each media group.
3664   *
3665   * @param {Object} main
3666   *        The main playlist
3667   */
3668
3669  const resolveMediaGroupUris = main => {
3670    forEachMediaGroup$1(main, properties => {
3671      if (properties.uri) {
3672        properties.resolvedUri = resolveUrl(main.uri, properties.uri);
3673      }
3674    });
3675  };
3676  /**
3677   * Creates a main playlist wrapper to insert a sole media playlist into.
3678   *
3679   * @param {Object} media
3680   *        Media playlist
3681   * @param {string} uri
3682   *        The media URI
3683   *
3684   * @return {Object}
3685   *         main playlist
3686   */
3687
3688  const mainForMedia = (media, uri) => {
3689    const id = createPlaylistID(0, uri);
3690    const main = {
3691      mediaGroups: {
3692        'AUDIO': {},
3693        'VIDEO': {},
3694        'CLOSED-CAPTIONS': {},
3695        'SUBTITLES': {}
3696      },
3697      uri: window.location.href,
3698      resolvedUri: window.location.href,
3699      playlists: [{
3700        uri,
3701        id,
3702        resolvedUri: uri,
3703        // m3u8-parser does not attach an attributes property to media playlists so make
3704        // sure that the property is attached to avoid undefined reference errors
3705        attributes: {}
3706      }]
3707    }; // set up ID reference
3708
3709    main.playlists[id] = main.playlists[0]; // URI reference added for backwards compatibility
3710
3711    main.playlists[uri] = main.playlists[0];
3712    return main;
3713  };
3714  /**
3715   * Does an in-place update of the main manifest to add updated playlist URI references
3716   * as well as other properties needed by VHS that aren't included by the parser.
3717   *
3718   * @param {Object} main
3719   *        main manifest object
3720   * @param {string} uri
3721   *        The source URI
3722   * @param {function} createGroupID
3723   *        A function to determine how to create the groupID for mediaGroups
3724   */
3725
3726  const addPropertiesToMain = (main, uri, createGroupID = groupID) => {
3727    main.uri = uri;
3728
3729    for (let i = 0; i < main.playlists.length; i++) {
3730      if (!main.playlists[i].uri) {
3731        // Set up phony URIs for the playlists since playlists are referenced by their URIs
3732        // throughout VHS, but some formats (e.g., DASH) don't have external URIs
3733        // TODO: consider adding dummy URIs in mpd-parser
3734        const phonyUri = `placeholder-uri-${i}`;
3735        main.playlists[i].uri = phonyUri;
3736      }
3737    }
3738
3739    const audioOnlyMain = isAudioOnly(main);
3740    forEachMediaGroup$1(main, (properties, mediaType, groupKey, labelKey) => {
3741      // add a playlist array under properties
3742      if (!properties.playlists || !properties.playlists.length) {
3743        // If the manifest is audio only and this media group does not have a uri, check
3744        // if the media group is located in the main list of playlists. If it is, don't add
3745        // placeholder properties as it shouldn't be considered an alternate audio track.
3746        if (audioOnlyMain && mediaType === 'AUDIO' && !properties.uri) {
3747          for (let i = 0; i < main.playlists.length; i++) {
3748            const p = main.playlists[i];
3749
3750            if (p.attributes && p.attributes.AUDIO && p.attributes.AUDIO === groupKey) {
3751              return;
3752            }
3753          }
3754        }
3755
3756        properties.playlists = [_extends({}, properties)];
3757      }
3758
3759      properties.playlists.forEach(function (p, i) {
3760        const groupId = createGroupID(mediaType, groupKey, labelKey, p);
3761        const id = createPlaylistID(i, groupId);
3762
3763        if (p.uri) {
3764          p.resolvedUri = p.resolvedUri || resolveUrl(main.uri, p.uri);
3765        } else {
3766          // DEPRECATED, this has been added to prevent a breaking change.
3767          // previously we only ever had a single media group playlist, so
3768          // we mark the first playlist uri without prepending the index as we used to
3769          // ideally we would do all of the playlists the same way.
3770          p.uri = i === 0 ? groupId : id; // don't resolve a placeholder uri to an absolute url, just use
3771          // the placeholder again
3772
3773          p.resolvedUri = p.uri;
3774        }
3775
3776        p.id = p.id || id; // add an empty attributes object, all playlists are
3777        // expected to have this.
3778
3779        p.attributes = p.attributes || {}; // setup ID and URI references (URI for backwards compatibility)
3780
3781        main.playlists[p.id] = p;
3782        main.playlists[p.uri] = p;
3783      });
3784    });
3785    setupMediaPlaylists(main);
3786    resolveMediaGroupUris(main);
3787  };
3788
3789  class DateRangesStorage {
3790    constructor() {
3791      this.offset_ = null;
3792      this.pendingDateRanges_ = new Map();
3793      this.processedDateRanges_ = new Map();
3794    }
3795
3796    setOffset(segments = []) {
3797      // already set
3798      if (this.offset_ !== null) {
3799        return;
3800      } // no segment to process
3801
3802
3803      if (!segments.length) {
3804        return;
3805      }
3806
3807      const [firstSegment] = segments; // no program date time
3808
3809      if (firstSegment.programDateTime === undefined) {
3810        return;
3811      } // Set offset as ProgramDateTime for the very first segment of the very first playlist load:
3812
3813
3814      this.offset_ = firstSegment.programDateTime / 1000;
3815    }
3816
3817    setPendingDateRanges(dateRanges = []) {
3818      if (!dateRanges.length) {
3819        return;
3820      }
3821
3822      const [dateRange] = dateRanges;
3823      const startTime = dateRange.startDate.getTime();
3824      this.trimProcessedDateRanges_(startTime);
3825      this.pendingDateRanges_ = dateRanges.reduce((map, pendingDateRange) => {
3826        map.set(pendingDateRange.id, pendingDateRange);
3827        return map;
3828      }, new Map());
3829    }
3830
3831    processDateRange(dateRange) {
3832      this.pendingDateRanges_.delete(dateRange.id);
3833      this.processedDateRanges_.set(dateRange.id, dateRange);
3834    }
3835
3836    getDateRangesToProcess() {
3837      if (this.offset_ === null) {
3838        return [];
3839      }
3840
3841      const dateRangeClasses = {};
3842      const dateRangesToProcess = [];
3843      this.pendingDateRanges_.forEach((dateRange, id) => {
3844        if (this.processedDateRanges_.has(id)) {
3845          return;
3846        }
3847
3848        dateRange.startTime = dateRange.startDate.getTime() / 1000 - this.offset_;
3849
3850        dateRange.processDateRange = () => this.processDateRange(dateRange);
3851
3852        dateRangesToProcess.push(dateRange);
3853
3854        if (!dateRange.class) {
3855          return;
3856        }
3857
3858        if (dateRangeClasses[dateRange.class]) {
3859          const length = dateRangeClasses[dateRange.class].push(dateRange);
3860          dateRange.classListIndex = length - 1;
3861        } else {
3862          dateRangeClasses[dateRange.class] = [dateRange];
3863          dateRange.classListIndex = 0;
3864        }
3865      });
3866
3867      for (const dateRange of dateRangesToProcess) {
3868        const classList = dateRangeClasses[dateRange.class] || [];
3869
3870        if (dateRange.endDate) {
3871          dateRange.endTime = dateRange.endDate.getTime() / 1000 - this.offset_;
3872        } else if (dateRange.endOnNext && classList[dateRange.classListIndex + 1]) {
3873          dateRange.endTime = classList[dateRange.classListIndex + 1].startTime;
3874        } else if (dateRange.duration) {
3875          dateRange.endTime = dateRange.startTime + dateRange.duration;
3876        } else if (dateRange.plannedDuration) {
3877          dateRange.endTime = dateRange.startTime + dateRange.plannedDuration;
3878        } else {
3879          dateRange.endTime = dateRange.startTime;
3880        }
3881      }
3882
3883      return dateRangesToProcess;
3884    }
3885
3886    trimProcessedDateRanges_(startTime) {
3887      const copy = new Map(this.processedDateRanges_);
3888      copy.forEach((dateRange, id) => {
3889        if (dateRange.startDate.getTime() < startTime) {
3890          this.processedDateRanges_.delete(id);
3891        }
3892      });
3893    }
3894
3895  }
3896
3897  const