https://tv5.ir/assets/js/hls.js

1typeof window !== "undefined" &&
2(function webpackUniversalModuleDefinition(root, factory) {
3	if(typeof exports === 'object' && typeof module === 'object')
4		module.exports = factory();
5	else if(typeof define === 'function' && define.amd)
6		define([], factory);
7	else if(typeof exports === 'object')
8		exports["Hls"] = factory();
9	else
10		root["Hls"] = factory();
11})(this, function() {
12return /******/ (function(modules) { // webpackBootstrap
13/******/ 	// The module cache
14/******/ 	var installedModules = {};
15/******/
16/******/ 	// The require function
17/******/ 	function __webpack_require__(moduleId) {
18/******/
19/******/ 		// Check if module is in cache
20/******/ 		if(installedModules[moduleId]) {
21/******/ 			return installedModules[moduleId].exports;
22/******/ 		}
23/******/ 		// Create a new module (and put it into the cache)
24/******/ 		var module = installedModules[moduleId] = {
25/******/ 			i: moduleId,
26/******/ 			l: false,
27/******/ 			exports: {}
28/******/ 		};
29/******/
30/******/ 		// Execute the module function
31/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
32/******/
33/******/ 		// Flag the module as loaded
34/******/ 		module.l = true;
35/******/
36/******/ 		// Return the exports of the module
37/******/ 		return module.exports;
38/******/ 	}
39/******/
40/******/
41/******/ 	// expose the modules object (__webpack_modules__)
42/******/ 	__webpack_require__.m = modules;
43/******/
44/******/ 	// expose the module cache
45/******/ 	__webpack_require__.c = installedModules;
46/******/
47/******/ 	// define getter function for harmony exports
48/******/ 	__webpack_require__.d = function(exports, name, getter) {
49/******/ 		if(!__webpack_require__.o(exports, name)) {
50/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
51/******/ 		}
52/******/ 	};
53/******/
54/******/ 	// define __esModule on exports
55/******/ 	__webpack_require__.r = function(exports) {
56/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
57/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
58/******/ 		}
59/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
60/******/ 	};
61/******/
62/******/ 	// create a fake namespace object
63/******/ 	// mode & 1: value is a module id, require it
64/******/ 	// mode & 2: merge all properties of value into the ns
65/******/ 	// mode & 4: return value when already ns object
66/******/ 	// mode & 8|1: behave like require
67/******/ 	__webpack_require__.t = function(value, mode) {
68/******/ 		if(mode & 1) value = __webpack_require__(value);
69/******/ 		if(mode & 8) return value;
70/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
71/******/ 		var ns = Object.create(null);
72/******/ 		__webpack_require__.r(ns);
73/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
74/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
75/******/ 		return ns;
76/******/ 	};
77/******/
78/******/ 	// getDefaultExport function for compatibility with non-harmony modules
79/******/ 	__webpack_require__.n = function(module) {
80/******/ 		var getter = module && module.__esModule ?
81/******/ 			function getDefault() { return module['default']; } :
82/******/ 			function getModuleExports() { return module; };
83/******/ 		__webpack_require__.d(getter, 'a', getter);
84/******/ 		return getter;
85/******/ 	};
86/******/
87/******/ 	// Object.prototype.hasOwnProperty.call
88/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
89/******/
90/******/ 	// __webpack_public_path__
91/******/ 	__webpack_require__.p = "/dist/";
92/******/
93/******/
94/******/ 	// Load entry module and return exports
95/******/ 	return __webpack_require__(__webpack_require__.s = "./src/hls.js");
96/******/ })
97/************************************************************************/
98/******/ ({
99

100/***/ "./node_modules/eventemitter3/index.js":
101/*!*********************************************!*\
102  !*** ./node_modules/eventemitter3/index.js ***!
103  \*********************************************/
104/*! no static exports found */
105/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
106/***/ (function(module, exports, __webpack_require__) {
107
108"use strict";
109
110
111var has = Object.prototype.hasOwnProperty
112  , prefix = '~';
113
114/**
115 * Constructor to create a storage for our `EE` objects.
116 * An `Events` instance is a plain object whose properties are event names.
117 *
118 * @constructor
119 * @private
120 */
121function Events() {}
122
123//
124// We try to not inherit from `Object.prototype`. In some engines creating an
125// instance in this way is faster than calling `Object.create(null)` directly.
126// If `Object.create(null)` is not supported we prefix the event names with a
127// character to make sure that the built-in object properties are not
128// overridden or used as an attack vector.
129//
130if (Object.create) {
131  Events.prototype = Object.create(null);
132
133  //
134  // This hack is needed because the `__proto__` property is still inherited in
135  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
136  //
137  if (!new Events().__proto__) prefix = false;
138}
139
140/**
141 * Representation of a single event listener.
142 *
143 * @param {Function} fn The listener function.
144 * @param {*} context The context to invoke the listener with.
145 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
146 * @constructor
147 * @private
148 */
149function EE(fn, context, once) {
150  this.fn = fn;
151  this.context = context;
152  this.once = once || false;
153}
154
155/**
156 * Add a listener for a given event.
157 *
158 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
159 * @param {(String|Symbol)} event The event name.
160 * @param {Function} fn The listener function.
161 * @param {*} context The context to invoke the listener with.
162 * @param {Boolean} once Specify if the listener is a one-time listener.
163 * @returns {EventEmitter}
164 * @private
165 */
166function addListener(emitter, event, fn, context, once) {
167  if (typeof fn !== 'function') {
168    throw new TypeError('The listener must be a function');
169  }
170
171  var listener = new EE(fn, context || emitter, once)
172    , evt = prefix ? prefix + event : event;
173
174  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
175  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
176  else emitter._events[evt] = [emitter._events[evt], listener];
177
178  return emitter;
179}
180
181/**
182 * Clear event by name.
183 *
184 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
185 * @param {(String|Symbol)} evt The Event name.
186 * @private
187 */
188function clearEvent(emitter, evt) {
189  if (--emitter._eventsCount === 0) emitter._events = new Events();
190  else delete emitter._events[evt];
191}
192
193/**
194 * Minimal `EventEmitter` interface that is molded against the Node.js
195 * `EventEmitter` interface.
196 *
197 * @constructor
198 * @public
199 */
200function EventEmitter() {
201  this._events = new Events();
202  this._eventsCount = 0;
203}
204
205/**
206 * Return an array listing the events for which the emitter has registered
207 * listeners.
208 *
209 * @returns {Array}
210 * @public
211 */
212EventEmitter.prototype.eventNames = function eventNames() {
213  var names = []
214    , events
215    , name;
216
217  if (this._eventsCount === 0) return names;
218
219  for (name in (events = this._events)) {
220    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
221  }
222
223  if (Object.getOwnPropertySymbols) {
224    return names.concat(Object.getOwnPropertySymbols(events));
225  }
226
227  return names;
228};
229
230/**
231 * Return the listeners registered for a given event.
232 *
233 * @param {(String|Symbol)} event The event name.
234 * @returns {Array} The registered listeners.
235 * @public
236 */
237EventEmitter.prototype.listeners = function listeners(event) {
238  var evt = prefix ? prefix + event : event
239    , handlers = this._events[evt];
240
241  if (!handlers) return [];
242  if (handlers.fn) return [handlers.fn];
243
244  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
245    ee[i] = handlers[i].fn;
246  }
247
248  return ee;
249};
250
251/**
252 * Return the number of listeners listening to a given event.
253 *
254 * @param {(String|Symbol)} event The event name.
255 * @returns {Number} The number of listeners.
256 * @public
257 */
258EventEmitter.prototype.listenerCount = function listenerCount(event) {
259  var evt = prefix ? prefix + event : event
260    , listeners = this._events[evt];
261
262  if (!listeners) return 0;
263  if (listeners.fn) return 1;
264  return listeners.length;
265};
266
267/**
268 * Calls each of the listeners registered for a given event.
269 *
270 * @param {(String|Symbol)} event The event name.
271 * @returns {Boolean} `true` if the event had listeners, else `false`.
272 * @public
273 */
274EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
275  var evt = prefix ? prefix + event : event;
276
277  if (!this._events[evt]) return false;
278
279  var listeners = this._events[evt]
280    , len = arguments.length
281    , args
282    , i;
283
284  if (listeners.fn) {
285    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
286
287    switch (len) {
288      case 1: return listeners.fn.call(listeners.context), true;
289      case 2: return listeners.fn.call(listeners.context, a1), true;
290      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
291      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
292      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
293      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
294    }
295
296    for (i = 1, args = new Array(len -1); i < len; i++) {
297      args[i - 1] = arguments[i];
298    }
299
300    listeners.fn.apply(listeners.context, args);
301  } else {
302    var length = listeners.length
303      , j;
304
305    for (i = 0; i < length; i++) {
306      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
307
308      switch (len) {
309        case 1: listeners[i].fn.call(listeners[i].context); break;
310        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
311        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
312        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
313        default:
314          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
315            args[j - 1] = arguments[j];
316          }
317
318          listeners[i].fn.apply(listeners[i].context, args);
319      }
320    }
321  }
322
323  return true;
324};
325
326/**
327 * Add a listener for a given event.
328 *
329 * @param {(String|Symbol)} event The event name.
330 * @param {Function} fn The listener function.
331 * @param {*} [context=this] The context to invoke the listener with.
332 * @returns {EventEmitter} `this`.
333 * @public
334 */
335EventEmitter.prototype.on = function on(event, fn, context) {
336  return addListener(this, event, fn, context, false);
337};
338
339/**
340 * Add a one-time listener for a given event.
341 *
342 * @param {(String|Symbol)} event The event name.
343 * @param {Function} fn The listener function.
344 * @param {*} [context=this] The context to invoke the listener with.
345 * @returns {EventEmitter} `this`.
346 * @public
347 */
348EventEmitter.prototype.once = function once(event, fn, context) {
349  return addListener(this, event, fn, context, true);
350};
351
352/**
353 * Remove the listeners of a given event.
354 *
355 * @param {(String|Symbol)} event The event name.
356 * @param {Function} fn Only remove the listeners that match this function.
357 * @param {*} context Only remove the listeners that have this context.
358 * @param {Boolean} once Only remove one-time listeners.
359 * @returns {EventEmitter} `this`.
360 * @public
361 */
362EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
363  var evt = prefix ? prefix + event : event;
364
365  if (!this._events[evt]) return this;
366  if (!fn) {
367    clearEvent(this, evt);
368    return this;
369  }
370
371  var listeners = this._events[evt];
372
373  if (listeners.fn) {
374    if (
375      listeners.fn === fn &&
376      (!once || listeners.once) &&
377      (!context || listeners.context === context)
378    ) {
379      clearEvent(this, evt);
380    }
381  } else {
382    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
383      if (
384        listeners[i].fn !== fn ||
385        (once && !listeners[i].once) ||
386        (context && listeners[i].context !== context)
387      ) {
388        events.push(listeners[i]);
389      }
390    }
391
392    //
393    // Reset the array, or remove it completely if we have no more listeners.
394    //
395    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
396    else clearEvent(this, evt);
397  }
398
399  return this;
400};
401
402/**
403 * Remove all listeners, or those of the specified event.
404 *
405 * @param {(String|Symbol)} [event] The event name.
406 * @returns {EventEmitter} `this`.
407 * @public
408 */
409EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
410  var evt;
411
412  if (event) {
413    evt = prefix ? prefix + event : event;
414    if (this._events[evt]) clearEvent(this, evt);
415  } else {
416    this._events = new Events();
417    this._eventsCount = 0;
418  }
419
420  return this;
421};
422
423//
424// Alias methods names because people roll like that.
425//
426EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
427EventEmitter.prototype.addListener = EventEmitter.prototype.on;
428
429//
430// Expose the prefix.
431//
432EventEmitter.prefixed = prefix;
433
434//
435// Allow `EventEmitter` to be imported as module namespace.
436//
437EventEmitter.EventEmitter = EventEmitter;
438
439//
440// Expose the module.
441//
442if (true) {
443  module.exports = EventEmitter;
444}
445
446
447/***/ }),
448

449/***/ "./node_modules/node-libs-browser/node_modules/events/events.js":
450/*!**********************************************************************!*\
451  !*** ./node_modules/node-libs-browser/node_modules/events/events.js ***!
452  \**********************************************************************/
453/*! no static exports found */
454/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
455/***/ (function(module, exports) {
456
457// Copyright Joyent, Inc. and other Node contributors.
458//
459// Permission is hereby granted, free of charge, to any person obtaining a
460// copy of this software and associated documentation files (the
461// "Software"), to deal in the Software without restriction, including
462// without limitation the rights to use, copy, modify, merge, publish,
463// distribute, sublicense, and/or sell copies of the Software, and to permit
464// persons to whom the Software is furnished to do so, subject to the
465// following conditions:
466//
467// The above copyright notice and this permission notice shall be included
468// in all copies or substantial portions of the Software.
469//
470// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
471// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
472// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
473// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
474// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
475// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
476// USE OR OTHER DEALINGS IN THE SOFTWARE.
477
478function EventEmitter() {
479  this._events = this._events || {};
480  this._maxListeners = this._maxListeners || undefined;
481}
482module.exports = EventEmitter;
483
484// Backwards-compat with node 0.10.x
485EventEmitter.EventEmitter = EventEmitter;
486
487EventEmitter.prototype._events = undefined;
488EventEmitter.prototype._maxListeners = undefined;
489
490// By default EventEmitters will print a warning if more than 10 listeners are
491// added to it. This is a useful default which helps finding memory leaks.
492EventEmitter.defaultMaxListeners = 10;
493
494// Obviously not all Emitters should be limited to 10. This function allows
495// that to be increased. Set to zero for unlimited.
496EventEmitter.prototype.setMaxListeners = function(n) {
497  if (!isNumber(n) || n < 0 || isNaN(n))
498    throw TypeError('n must be a positive number');
499  this._maxListeners = n;
500  return this;
501};
502
503EventEmitter.prototype.emit = function(type) {
504  var er, handler, len, args, i, listeners;
505
506  if (!this._events)
507    this._events = {};
508
509  // If there is no 'error' event listener then throw.
510  if (type === 'error') {
511    if (!this._events.error ||
512        (isObject(this._events.error) && !this._events.error.length)) {
513      er = arguments[1];
514      if (er instanceof Error) {
515        throw er; // Unhandled 'error' event
516      } else {
517        // At least give some kind of context to the user
518        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
519        err.context = er;
520        throw err;
521      }
522    }
523  }
524
525  handler = this._events[type];
526
527  if (isUndefined(handler))
528    return false;
529
530  if (isFunction(handler)) {
531    switch (arguments.length) {
532      // fast cases
533      case 1:
534        handler.call(this);
535        break;
536      case 2:
537        handler.call(this, arguments[1]);
538        break;
539      case 3:
540        handler.call(this, arguments[1], arguments[2]);
541        break;
542      // slower
543      default:
544        args = Array.prototype.slice.call(arguments, 1);
545        handler.apply(this, args);
546    }
547  } else if (isObject(handler)) {
548    args = Array.prototype.slice.call(arguments, 1);
549    listeners = handler.slice();
550    len = listeners.length;
551    for (i = 0; i < len; i++)
552      listeners[i].apply(this, args);
553  }
554
555  return true;
556};
557
558EventEmitter.prototype.addListener = function(type, listener) {
559  var m;
560
561  if (!isFunction(listener))
562    throw TypeError('listener must be a function');
563
564  if (!this._events)
565    this._events = {};
566
567  // To avoid recursion in the case that type === "newListener"! Before
568  // adding it to the listeners, first emit "newListener".
569  if (this._events.newListener)
570    this.emit('newListener', type,
571              isFunction(listener.listener) ?
572              listener.listener : listener);
573
574  if (!this._events[type])
575    // Optimize the case of one listener. Don't need the extra array object.
576    this._events[type] = listener;
577  else if (isObject(this._events[type]))
578    // If we've already got an array, just append.
579    this._events[type].push(listener);
580  else
581    // Adding the second element, need to change to array.
582    this._events[type] = [this._events[type], listener];
583
584  // Check for listener leak
585  if (isObject(this._events[type]) && !this._events[type].warned) {
586    if (!isUndefined(this._maxListeners)) {
587      m = this._maxListeners;
588    } else {
589      m = EventEmitter.defaultMaxListeners;
590    }
591
592    if (m && m > 0 && this._events[type].length > m) {
593      this._events[type].warned = true;
594      console.error('(node) warning: possible EventEmitter memory ' +
595                    'leak detected. %d listeners added. ' +
596                    'Use emitter.setMaxListeners() to increase limit.',
597                    this._events[type].length);
598      if (typeof console.trace === 'function') {
599        // not supported in IE 10
600        console.trace();
601      }
602    }
603  }
604
605  return this;
606};
607
608EventEmitter.prototype.on = EventEmitter.prototype.addListener;
609
610EventEmitter.prototype.once = function(type, listener) {
611  if (!isFunction(listener))
612    throw TypeError('listener must be a function');
613
614  var fired = false;
615
616  function g() {
617    this.removeListener(type, g);
618
619    if (!fired) {
620      fired = true;
621      listener.apply(this, arguments);
622    }
623  }
624
625  g.listener = listener;
626  this.on(type, g);
627
628  return this;
629};
630
631// emits a 'removeListener' event iff the listener was removed
632EventEmitter.prototype.removeListener = function(type, listener) {
633  var list, position, length, i;
634
635  if (!isFunction(listener))
636    throw TypeError('listener must be a function');
637
638  if (!this._events || !this._events[type])
639    return this;
640
641  list = this._events[type];
642  length = list.length;
643  position = -1;
644
645  if (list === listener ||
646      (isFunction(list.listener) && list.listener === listener)) {
647    delete this._events[type];
648    if (this._events.removeListener)
649      this.emit('removeListener', type, listener);
650
651  } else if (isObject(list)) {
652    for (i = length; i-- > 0;) {
653      if (list[i] === listener ||
654          (list[i].listener && list[i].listener === listener)) {
655        position = i;
656        break;
657      }
658    }
659
660    if (position < 0)
661      return this;
662
663    if (list.length === 1) {
664      list.length = 0;
665      delete this._events[type];
666    } else {
667      list.splice(position, 1);
668    }
669
670    if (this._events.removeListener)
671      this.emit('removeListener', type, listener);
672  }
673
674  return this;
675};
676
677EventEmitter.prototype.removeAllListeners = function(type) {
678  var key, listeners;
679
680  if (!this._events)
681    return this;
682
683  // not listening for removeListener, no need to emit
684  if (!this._events.removeListener) {
685    if (arguments.length === 0)
686      this._events = {};
687    else if (this._events[type])
688      delete this._events[type];
689    return this;
690  }
691
692  // emit removeListener for all listeners on all events
693  if (arguments.length === 0) {
694    for (key in this._events) {
695      if (key === 'removeListener') continue;
696      this.removeAllListeners(key);
697    }
698    this.removeAllListeners('removeListener');
699    this._events = {};
700    return this;
701  }
702
703  listeners = this._events[type];
704
705  if (isFunction(listeners)) {
706    this.removeListener(type, listeners);
707  } else if (listeners) {
708    // LIFO order
709    while (listeners.length)
710      this.removeListener(type, listeners[listeners.length - 1]);
711  }
712  delete this._events[type];
713
714  return this;
715};
716
717EventEmitter.prototype.listeners = function(type) {
718  var ret;
719  if (!this._events || !this._events[type])
720    ret = [];
721  else if (isFunction(this._events[type]))
722    ret = [this._events[type]];
723  else
724    ret = this._events[type].slice();
725  return ret;
726};
727
728EventEmitter.prototype.listenerCount = function(type) {
729  if (this._events) {
730    var evlistener = this._events[type];
731
732    if (isFunction(evlistener))
733      return 1;
734    else if (evlistener)
735      return evlistener.length;
736  }
737  return 0;
738};
739
740EventEmitter.listenerCount = function(emitter, type) {
741  return emitter.listenerCount(type);
742};
743
744function isFunction(arg) {
745  return typeof arg === 'function';
746}
747
748function isNumber(arg) {
749  return typeof arg === 'number';
750}
751
752function isObject(arg) {
753  return typeof arg === 'object' && arg !== null;
754}
755
756function isUndefined(arg) {
757  return arg === void 0;
758}
759
760
761/***/ }),
762

763/***/ "./node_modules/url-toolkit/src/url-toolkit.js":
764/*!*****************************************************!*\
765  !*** ./node_modules/url-toolkit/src/url-toolkit.js ***!
766  \*****************************************************/
767/*! no static exports found */
768/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
769/***/ (function(module, exports, __webpack_require__) {
770
771// see https://tools.ietf.org/html/rfc1808
772
773/* jshint ignore:start */
774(function(root) { 
775/* jshint ignore:end */
776
777  var URL_REGEX = /^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/\?#]*\/)*.*?)??(;.*?)?(\?.*?)?(#.*?)?$/;
778  var FIRST_SEGMENT_REGEX = /^([^\/?#]*)(.*)$/;
779  var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
780  var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/).*?(?=\/)/g;
781
782  var URLToolkit = { // jshint ignore:line
783    // If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
784    // E.g
785    // With opts.alwaysNormalize = false (default, spec compliant)
786    // http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
787    // With opts.alwaysNormalize = true (not spec compliant)
788    // http://a.com/b/cd + /e/f/../g => http://a.com/e/g
789    buildAbsoluteURL: function(baseURL, relativeURL, opts) {
790      opts = opts || {};
791      // remove any remaining space and CRLF
792      baseURL = baseURL.trim();
793      relativeURL = relativeURL.trim();
794      if (!relativeURL) {
795        // 2a) If the embedded URL is entirely empty, it inherits the
796        // entire base URL (i.e., is set equal to the base URL)
797        // and we are done.
798        if (!opts.alwaysNormalize) {
799          return baseURL;
800        }
801        var basePartsForNormalise = URLToolkit.parseURL(baseURL);
802        if (!basePartsForNormalise) {
803          throw new Error('Error trying to parse base URL.');
804        }
805        basePartsForNormalise.path = URLToolkit.normalizePath(basePartsForNormalise.path);
806        return URLToolkit.buildURLFromParts(basePartsForNormalise);
807      }
808      var relativeParts = URLToolkit.parseURL(relativeURL);
809      if (!relativeParts) {
810        throw new Error('Error trying to parse relative URL.');
811      }
812      if (relativeParts.scheme) {
813        // 2b) If the embedded URL starts with a scheme name, it is
814        // interpreted as an absolute URL and we are done.
815        if (!opts.alwaysNormalize) {
816          return relativeURL;
817        }
818        relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
819        return URLToolkit.buildURLFromParts(relativeParts);
820      }
821      var baseParts = URLToolkit.parseURL(baseURL);
822      if (!baseParts) {
823        throw new Error('Error trying to parse base URL.');
824      }
825      if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {
826        // If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc
827        // This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'
828        var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
829        baseParts.netLoc = pathParts[1];
830        baseParts.path = pathParts[2];
831      }
832      if (baseParts.netLoc && !baseParts.path) {
833        baseParts.path = '/';
834      }
835      var builtParts = {
836        // 2c) Otherwise, the embedded URL inherits the scheme of
837        // the base URL.
838        scheme: baseParts.scheme,
839        netLoc: relativeParts.netLoc,
840        path: null,
841        params: relativeParts.params,
842        query: relativeParts.query,
843        fragment: relativeParts.fragment
844      };
845      if (!relativeParts.netLoc) {
846        // 3) If the embedded URL's <net_loc> is non-empty, we skip to
847        // Step 7.  Otherwise, the embedded URL inherits the <net_loc>
848        // (if any) of the base URL.
849        builtParts.netLoc = baseParts.netLoc;
850        // 4) If the embedded URL path is preceded by a slash "/", the
851        // path is not relative and we skip to Step 7.
852        if (relativeParts.path[0] !== '/') {
853          if (!relativeParts.path) {
854            // 5) If the embedded URL path is empty (and not preceded by a
855            // slash), then the embedded URL inherits the base URL path
856            builtParts.path = baseParts.path;
857            // 5a) if the embedded URL's <params> is non-empty, we skip to
858            // step 7; otherwise, it inherits the <params> of the base
859            // URL (if any) and
860            if (!relativeParts.params) {
861              builtParts.params = baseParts.params;
862              // 5b) if the embedded URL's <query> is non-empty, we skip to
863              // step 7; otherwise, it inherits the <query> of the base
864              // URL (if any) and we skip to step 7.
865              if (!relativeParts.query) {
866                builtParts.query = baseParts.query;
867              }
868            }
869          } else {
870            // 6) The last segment of the base URL's path (anything
871            // following the rightmost slash "/", or the entire path if no
872            // slash is present) is removed and the embedded URL's path is
873            // appended in its place.
874            var baseURLPath = baseParts.path;
875            var newPath = baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) + relativeParts.path;
876            builtParts.path = URLToolkit.normalizePath(newPath);
877          }
878        }
879      }
880      if (builtParts.path === null) {
881        builtParts.path = opts.alwaysNormalize ? URLToolkit.normalizePath(relativeParts.path) : relativeParts.path;
882      }
883      return URLToolkit.buildURLFromParts(builtParts);
884    },
885    parseURL: function(url) {
886      var parts = URL_REGEX.exec(url);
887      if (!parts) {
888        return null;
889      }
890      return {
891        scheme: parts[1] || '',
892        netLoc: parts[2] || '',
893        path: parts[3] || '',
894        params: parts[4] || '',
895        query: parts[5] || '',
896        fragment: parts[6] || ''
897      };
898    },
899    normalizePath: function(path) {
900      // The following operations are
901      // then applied, in order, to the new path:
902      // 6a) All occurrences of "./", where "." is a complete path
903      // segment, are removed.
904      // 6b) If the path ends with "." as a complete path segment,
905      // that "." is removed.
906      path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, '');
907      // 6c) All occurrences of "<segment>/../", where <segment> is a
908      // complete path segment not equal to "..", are removed.
909      // Removal of these path segments is performed iteratively,
910      // removing the leftmost matching pattern on each iteration,
911      // until no matching pattern remains.
912      // 6d) If the path ends with "<segment>/..", where <segment> is a
913      // complete path segment not equal to "..", that
914      // "<segment>/.." is removed.
915      while (path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length) {} // jshint ignore:line
916      return path.split('').reverse().join('');
917    },
918    buildURLFromParts: function(parts) {
919      return parts.scheme + parts.netLoc + parts.path + parts.params + parts.query + parts.fragment;
920    }
921  };
922
923/* jshint ignore:start */
924  if(true)
925    module.exports = URLToolkit;
926  else {}
927})(this);
928/* jshint ignore:end */
929
930
931/***/ }),
932

933/***/ "./node_modules/webworkify-webpack/index.js":
934/*!**************************************************!*\
935  !*** ./node_modules/webworkify-webpack/index.js ***!
936  \**************************************************/
937/*! no static exports found */
938/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
939/***/ (function(module, exports, __webpack_require__) {
940
941function webpackBootstrapFunc (modules) {
942/******/  // The module cache
943/******/  var installedModules = {};
944
945/******/  // The require function
946/******/  function __webpack_require__(moduleId) {
947
948/******/    // Check if module is in cache
949/******/    if(installedModules[moduleId])
950/******/      return installedModules[moduleId].exports;
951
952/******/    // Create a new module (and put it into the cache)
953/******/    var module = installedModules[moduleId] = {
954/******/      i: moduleId,
955/******/      l: false,
956/******/      exports: {}
957/******/    };
958
959/******/    // Execute the module function
960/******/    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
961
962/******/    // Flag the module as loaded
963/******/    module.l = true;
964
965/******/    // Return the exports of the module
966/******/    return module.exports;
967/******/  }
968
969/******/  // expose the modules object (__webpack_modules__)
970/******/  __webpack_require__.m = modules;
971
972/******/  // expose the module cache
973/******/  __webpack_require__.c = installedModules;
974
975/******/  // identity function for calling harmony imports with the correct context
976/******/  __webpack_require__.i = function(value) { return value; };
977
978/******/  // define getter function for harmony exports
979/******/  __webpack_require__.d = function(exports, name, getter) {
980/******/    if(!__webpack_require__.o(exports, name)) {
981/******/      Object.defineProperty(exports, name, {
982/******/        configurable: false,
983/******/        enumerable: true,
984/******/        get: getter
985/******/      });
986/******/    }
987/******/  };
988
989/******/  // define __esModule on exports
990/******/  __webpack_require__.r = function(exports) {
991/******/    Object.defineProperty(exports, '__esModule', { value: true });
992/******/  };
993
994/******/  // getDefaultExport function for compatibility with non-harmony modules
995/******/  __webpack_require__.n = function(module) {
996/******/    var getter = module && module.__esModule ?
997/******/      function getDefault() { return module['default']; } :
998/******/      function getModuleExports() { return module; };
999/******/    __webpack_require__.d(getter, 'a', getter);
1000/******/    return getter;
1001/******/  };
1002
1003/******/  // Object.prototype.hasOwnProperty.call
1004/******/  __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
1005
1006/******/  // __webpack_public_path__
1007/******/  __webpack_require__.p = "/";
1008
1009/******/  // on error function for async loading
1010/******/  __webpack_require__.oe = function(err) { console.error(err); throw err; };
1011
1012  var f = __webpack_require__(__webpack_require__.s = ENTRY_MODULE)
1013  return f.default || f // try to call default if defined to also support babel esmodule exports
1014}
1015
1016var moduleNameReqExp = '[\\.|\\-|\\+|\\w|\/|@]+'
1017var dependencyRegExp = '\\((\/\\*.*?\\*\/)?\s?.*?(' + moduleNameReqExp + ').*?\\)' // additional chars when output.pathinfo is true
1018
1019// http://stackoverflow.com/a/2593661/130442
1020function quoteRegExp (str) {
1021  return (str + '').replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&')
1022}
1023
1024function isNumeric(n) {
1025  return !isNaN(1 * n); // 1 * n converts integers, integers as string ("123"), 1e3 and "1e3" to integers and strings to NaN
1026}
1027
1028function getModuleDependencies (sources, module, queueName) {
1029  var retval = {}
1030  retval[queueName] = []
1031
1032  var fnString = module.toString()
1033  var wrapperSignature = fnString.match(/^function\s?\(\w+,\s*\w+,\s*(\w+)\)/)
1034  if (!wrapperSignature) return retval
1035  var webpackRequireName = wrapperSignature[1]
1036
1037  // main bundle deps
1038  var re = new RegExp('(\\\\n|\\W)' + quoteRegExp(webpackRequireName) + dependencyRegExp, 'g')
1039  var match
1040  while ((match = re.exec(fnString))) {
1041    if (match[3] === 'dll-reference') continue
1042    retval[queueName].push(match[3])
1043  }
1044
1045  // dll deps
1046  re = new RegExp('\\(' + quoteRegExp(webpackRequireName) + '\\("(dll-reference\\s(' + moduleNameReqExp + '))"\\)\\)' + dependencyRegExp, 'g')
1047  while ((match = re.exec(fnString))) {
1048    if (!sources[match[2]]) {
1049      retval[queueName].push(match[1])
1050      sources[match[2]] = __webpack_require__(match[1]).m
1051    }
1052    retval[match[2]] = retval[match[2]] || []
1053    retval[match[2]].push(match[4])
1054  }
1055
1056  // convert 1e3 back to 1000 - this can be important after uglify-js converted 1000 to 1e3
1057  var keys = Object.keys(retval);
1058  for (var i = 0; i < keys.length; i++) {
1059    for (var j = 0; j < retval[keys[i]].length; j++) {
1060      if (isNumeric(retval[keys[i]][j])) {
1061        retval[keys[i]][j] = 1 * retval[keys[i]][j];
1062      }
1063    }
1064  }
1065
1066  return retval
1067}
1068
1069function hasValuesInQueues (queues) {
1070  var keys = Object.keys(queues)
1071  return keys.reduce(function (hasValues, key) {
1072    return hasValues || queues[key].length > 0
1073  }, false)
1074}
1075
1076function getRequiredModules (sources, moduleId) {
1077  var modulesQueue = {
1078    main: [moduleId]
1079  }
1080  var requiredModules = {
1081    main: []
1082  }
1083  var seenModules = {
1084    main: {}
1085  }
1086
1087  while (hasValuesInQueues(modulesQueue)) {
1088    var queues = Object.keys(modulesQueue)
1089    for (var i = 0; i < queues.length; i++) {
1090      var queueName = queues[i]
1091      var queue = modulesQueue[queueName]
1092      var moduleToCheck = queue.pop()
1093      seenModules[queueName] = seenModules[queueName] || {}
1094      if (seenModules[queueName][moduleToCheck] || !sources[queueName][moduleToCheck]) continue
1095      seenModules[queueName][moduleToCheck] = true
1096      requiredModules[queueName] = requiredModules[queueName] || []
1097      requiredModules[queueName].push(moduleToCheck)
1098      var newModules = getModuleDependencies(sources, sources[queueName][moduleToCheck], queueName)
1099      var newModulesKeys = Object.keys(newModules)
1100      for (var j = 0; j < newModulesKeys.length; j++) {
1101        modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]] || []
1102        modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]].concat(newModules[newModulesKeys[j]])
1103      }
1104    }
1105  }
1106
1107  return requiredModules
1108}
1109
1110module.exports = function (moduleId, options) {
1111  options = options || {}
1112  var sources = {
1113    main: __webpack_require__.m
1114  }
1115
1116  var requiredModules = options.all ? { main: Object.keys(sources.main) } : getRequiredModules(sources, moduleId)
1117
1118  var src = ''
1119
1120  Object.keys(requiredModules).filter(function (m) { return m !== 'main' }).forEach(function (module) {
1121    var entryModule = 0
1122    while (requiredModules[module][entryModule]) {
1123      entryModule++
1124    }
1125    requiredModules[module].push(entryModule)
1126    sources[module][entryModule] = '(function(module, exports, __webpack_require__) { module.exports = __webpack_require__; })'
1127    src = src + 'var ' + module + ' = (' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(entryModule)) + ')({' + requiredModules[module].map(function (id) { return '' + JSON.stringify(id) + ': ' + sources[module][id].toString() }).join(',') + '});\n'
1128  })
1129
1130  src = src + 'new ((' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(moduleId)) + ')({' + requiredModules.main.map(function (id) { return '' + JSON.stringify(id) + ': ' + sources.main[id].toString() }).join(',') + '}))(self);'
1131
1132  var blob = new window.Blob([src], { type: 'text/javascript' })
1133  if (options.bare) { return blob }
1134
1135  var URL = window.URL || window.webkitURL || window.mozURL || window.msURL
1136
1137  var workerUrl = URL.createObjectURL(blob)
1138  var worker = new window.Worker(workerUrl)
1139  worker.objectURL = workerUrl
1140
1141  return worker
1142}
1143
1144
1145/***/ }),
1146

1147/***/ "./src/config.js":
1148/*!***********************!*\
1149  !*** ./src/config.js ***!
1150  \***********************/
1151/*! no static exports found */
1152/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
1153/***/ (function(module, exports, __webpack_require__) {
1154
1155"use strict";
1156
1157/**
1158 * HLS config
1159 */
1160Object.defineProperty(exports, "__esModule", { value: true });
1161var abr_controller_1 = __webpack_require__(/*! ./controller/abr-controller */ "./src/controller/abr-controller.js");
1162var buffer_controller_1 = __webpack_require__(/*! ./controller/buffer-controller */ "./src/controller/buffer-controller.js");
1163var cap_level_controller_1 = __webpack_require__(/*! ./controller/cap-level-controller */ "./src/controller/cap-level-controller.js");
1164var fps_controller_1 = __webpack_require__(/*! ./controller/fps-controller */ "./src/controller/fps-controller.js");
1165var xhr_loader_1 = __webpack_require__(/*! ./utils/xhr-loader */ "./src/utils/xhr-loader.js");
1166// import FetchLoader from './utils/fetch-loader';
1167var audio_track_controller_1 = __webpack_require__(/*! ./controller/audio-track-controller */ "./src/controller/audio-track-controller.js");
1168var audio_stream_controller_1 = __webpack_require__(/*! ./controller/audio-stream-controller */ "./src/controller/audio-stream-controller.js");
1169var Cues = __webpack_require__(/*! ./utils/cues */ "./src/utils/cues.js");
1170var timeline_controller_1 = __webpack_require__(/*! ./controller/timeline-controller */ "./src/controller/timeline-controller.js");
1171var subtitle_track_controller_1 = __webpack_require__(/*! ./controller/subtitle-track-controller */ "./src/controller/subtitle-track-controller.js");
1172var subtitle_stream_controller_1 = __webpack_require__(/*! ./controller/subtitle-stream-controller */ "./src/controller/subtitle-stream-controller.js");
1173var eme_controller_1 = __webpack_require__(/*! ./controller/eme-controller */ "./src/controller/eme-controller.js");
1174var mediakeys_helper_1 = __webpack_require__(/*! ./utils/mediakeys-helper */ "./src/utils/mediakeys-helper.js");
1175exports.hlsDefaultConfig = {
1176    autoStartLoad: true,
1177    startPosition: -1,
1178    defaultAudioCodec: undefined,
1179    debug: false,
1180    capLevelOnFPSDrop: false,
1181    capLevelToPlayerSize: false,
1182    initialLiveManifestSize: 1,
1183    maxBufferLength: 30,
1184    maxBufferSize: 60 * 1000 * 1000,
1185    maxBufferHole: 0.5,
1186    lowBufferWatchdogPeriod: 0.5,
1187    highBufferWatchdogPeriod: 3,
1188    nudgeOffset: 0.1,
1189    nudgeMaxRetry: 3,
1190    maxFragLookUpTolerance: 0.25,
1191    liveSyncDurationCount: 3,
1192    liveMaxLatencyDurationCount: Infinity,
1193    liveSyncDuration: undefined,
1194    liveMaxLatencyDuration: undefined,
1195    liveDurationInfinity: false,
1196    liveBackBufferLength: Infinity,
1197    maxMaxBufferLength: 600,
1198    enableWorker: true,
1199    enableSoftwareAES: true,
1200    manifestLoadingTimeOut: 10000,
1201    manifestLoadingMaxRetry: 1,
1202    manifestLoadingRetryDelay: 1000,
1203    manifestLoadingMaxRetryTimeout: 64000,
1204    startLevel: undefined,
1205    levelLoadingTimeOut: 10000,
1206    levelLoadingMaxRetry: 4,
1207    levelLoadingRetryDelay: 1000,
1208    levelLoadingMaxRetryTimeout: 64000,
1209    fragLoadingTimeOut: 20000,
1210    fragLoadingMaxRetry: 6,
1211    fragLoadingRetryDelay: 1000,
1212    fragLoadingMaxRetryTimeout: 64000,
1213    startFragPrefetch: false,
1214    fpsDroppedMonitoringPeriod: 5000,
1215    fpsDroppedMonitoringThreshold: 0.2,
1216    appendErrorMaxRetry: 3,
1217    loader: xhr_loader_1.default,
1218    // loader: FetchLoader,
1219    fLoader: undefined,
1220    pLoader: undefined,
1221    xhrSetup: undefined,
1222    licenseXhrSetup: undefined,
1223    // fetchSetup: undefined,
1224    abrController: abr_controller_1.default,
1225    bufferController: buffer_controller_1.default,
1226    capLevelController: cap_level_controller_1.default,
1227    fpsController: fps_controller_1.default,
1228    stretchShortVideoTrack: false,
1229    maxAudioFramesDrift: 1,
1230    forceKeyFrameOnDiscontinuity: true,
1231    abrEwmaFastLive: 3,
1232    abrEwmaSlowLive: 9,
1233    abrEwmaFastVoD: 3,
1234    abrEwmaSlowVoD: 9,
1235    abrEwmaDefaultEstimate: 5e5,
1236    abrBandWidthFactor: 0.95,
1237    abrBandWidthUpFactor: 0.7,
1238    abrMaxWithRealBitrate: false,
1239    maxStarvationDelay: 4,
1240    maxLoadingDelay: 4,
1241    minAutoBitrate: 0,
1242    emeEnabled: false,
1243    widevineLicenseUrl: undefined,
1244    requestMediaKeySystemAccessFunc: mediakeys_helper_1.requestMediaKeySystemAccess // used by eme-controller
1245};
1246if (true) {

1247    exports.hlsDefaultConfig.subtitleStreamController = subtitle_stream_controller_1.SubtitleStreamController;
1248    exports.hlsDefaultConfig.subtitleTrackController = subtitle_track_controller_1.default;
1249    exports.hlsDefaultConfig.timelineController = timeline_controller_1.default;
1250    exports.hlsDefaultConfig.cueHandler = Cues; // used by timeline-controller
1251    exports.hlsDefaultConfig.enableCEA708Captions = true; // used by timeline-controller
1252    exports.hlsDefaultConfig.enableWebVTT = true; // used by timeline-controller
1253    exports.hlsDefaultConfig.captionsTextTrack1Label = 'English'; // used by timeline-controller
1254    exports.hlsDefaultConfig.captionsTextTrack1LanguageCode = 'en'; // used by timeline-controller
1255    exports.hlsDefaultConfig.captionsTextTrack2Label = 'Spanish'; // used by timeline-controller
1256    exports.hlsDefaultConfig.captionsTextTrack2LanguageCode = 'es'; // used by timeline-controller
1257}
1258if (true) {
1259    exports.hlsDefaultConfig.audioStreamController = audio_stream_controller_1.default;
1260    exports.hlsDefaultConfig.audioTrackController = audio_track_controller_1.default;
1261}
1262if (true) {
1263    exports.hlsDefaultConfig.emeController = eme_controller_1.default;
1264}
1265
1266
1267/***/ }),
1268

1269/***/ "./src/controller/abr-controller.js":
1270/*!******************************************!*\
1271  !*** ./src/controller/abr-controller.js ***!
1272  \******************************************/
1273/*! no static exports found */
1274/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
1275/***/ (function(module, exports, __webpack_require__) {
1276
1277"use strict";
1278/* WEBPACK VAR INJECTION */(function(Number) {
1279/*
1280 * simple ABR Controller
1281 *  - compute next level based on last fragment bw heuristics
1282 *  - implement an abandon rules triggered if we have less than 2 frag buffered and if computed bw shows that we risk buffer stalling
1283 */
1284var __extends = (this && this.__extends) || (function () {
1285    var extendStatics = Object.setPrototypeOf ||
1286        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
1287        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
1288    return function (d, b) {
1289        extendStatics(d, b);
1290        function __() { this.constructor = d; }
1291        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
1292    };
1293})();
1294Object.defineProperty(exports, "__esModule", { value: true });
1295var events_1 = __webpack_require__(/*! ../events */ "./src/events.js");
1296var event_handler_1 = __webpack_require__(/*! ../event-handler */ "./src/event-handler.js");
1297var buffer_helper_1 = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.js");
1298var errors_1 = __webpack_require__(/*! ../errors */ "./src/errors.js");
1299var logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.js");
1300var ewma_bandwidth_estimator_1 = __webpack_require__(/*! ../utils/ewma-bandwidth-estimator */ "./src/utils/ewma-bandwidth-estimator.js");
1301var performance = window.performance;
1302var AbrController = /** @class */ (function (_super) {
1303    __extends(AbrController, _super);
1304    function AbrController(hls) {
1305        var _this = _super.call(this, hls, events_1.default.FRAG_LOADING, events_1.default.FRAG_LOADED, events_1.default.FRAG_BUFFERED, events_1.default.ERROR) || this;
1306        _this.lastLoadedFragLevel = 0;
1307        _this._nextAutoLevel = -1;
1308        _this.hls = hls;
1309        _this.timer = null;
1310        _this._bwEstimator = null;
1311        _this.onCheck = _this._abandonRulesCheck.bind(_this);
1312        return _this;
1313    }
1314    AbrController.prototype.destroy = function () {
1315        this.clearTimer();
1316        event_handler_1.default.prototype.destroy.call(this);
1317    };
1318    AbrController.prototype.onFragLoading = function (data) {
1319        var frag = data.frag;
1320        if (frag.type === 'main') {
1321            if (!this.timer) {
1322                this.fragCurrent = frag;
1323                this.timer = setInterval(this.onCheck, 100);
1324            }
1325            // lazy init of BwEstimator, rationale is that we use different params for Live/VoD
1326            // so we need to wait for stream manifest / playlist type to instantiate it.
1327            if (!this._bwEstimator) {
1328                var hls_1 = this.hls;
1329                var config = hls_1.config;
1330                var level = frag.level;
1331                var isLive = hls_1.levels[level].details.live;
1332                var ewmaFast = void 0, ewmaSlow = void 0;
1333                if (isLive) {
1334                    ewmaFast = config.abrEwmaFastLive;
1335                    ewmaSlow = config.abrEwmaSlowLive;
1336                }
1337                else {
1338                    ewmaFast = config.abrEwmaFastVoD;
1339                    ewmaSlow = config.abrEwmaSlowVoD;
1340                }
1341                this._bwEstimator = new ewma_bandwidth_estimator_1.default(hls_1, ewmaSlow, ewmaFast, config.abrEwmaDefaultEstimate);
1342            }
1343        }
1344    };
1345    AbrController.prototype._abandonRulesCheck = function () {
1346        /*
1347          monitor fragment retrieval time...
1348          we compute expected time of arrival of the complete fragment.
1349          we compare it to expected time of buffer starvation
1350        */
1351        var hls = this.hls;
1352        var video = hls.media;
1353        var frag = this.fragCurrent;
1354        if (!frag) {
1355            return;
1356        }
1357        var loader = frag.loader;
1358        var minAutoLevel = hls.minAutoLevel;
1359        // if loader has been destroyed or loading has been aborted, stop timer and return
1360        if (!loader || (loader.stats && loader.stats.aborted)) {
1361            logger_1.logger.warn('frag loader destroy or aborted, disarm abandonRules');
1362            this.clearTimer();
1363            // reset forced auto level value so that next level will be selected
1364            this._nextAutoLevel = -1;
1365            return;
1366        }
1367        var stats = loader.stats;
1368        /* only monitor frag retrieval time if
1369        (video not paused OR first fragment being loaded(ready state === HAVE_NOTHING = 0)) AND autoswitching enabled AND not lowest level (=> means that we have several levels) */
1370        if (video && stats && ((!video.paused && (video.playbackRate !== 0)) || !video.readyState) && frag.autoLevel && frag.level) {

1371            var requestDelay = performance.now() - stats.trequest, playbackRate = Math.abs(video.playbackRate);
1372            // monitor fragment load progress after half of expected fragment duration,to stabilize bitrate
1373            if (requestDelay > (500 * frag.duration / playbackRate)) {
1374                var levels = hls.levels, loadRate = Math.max(1, stats.bw ? stats.bw / 8 : stats.loaded * 1000 / requestDelay), // byte/s; at least 1 byte/s to avoid division by zero
1375                // compute expected fragment length using frag duration and level bitrate. also ensure that expected len is gte than already loaded size
1376                level = levels[frag.level], levelBitrate = level.realBitrate ? Math.max(level.realBitrate, level.bitrate) : level.bitrate, expectedLen = stats.total ? stats.total : Math.max(stats.loaded, Math.round(frag.duration * levelBitrate / 8)), pos = video.currentTime, fragLoadedDelay = (expectedLen - stats.loaded) / loadRate, bufferStarvationDelay = (buffer_helper_1.BufferHelper.bufferInfo(video, pos, hls.config.maxBufferHole).end - pos) / playbackRate;
1377                // consider emergency switch down only if we have less than 2 frag buffered AND
1378                // time to finish loading current fragment is bigger than buffer starvation delay
1379                // ie if we risk buffer starvation if bw does not increase quickly
1380                if ((bufferStarvationDelay < (2 * frag.duration / playbackRate)) && (fragLoadedDelay > bufferStarvationDelay)) {
1381                    var fragLevelNextLoadedDelay = void 0, nextLoadLevel = void 0;
1382                    // lets iterate through lower level and try to find the biggest one that could avoid rebuffering
1383                    // we start from current level - 1 and we step down , until we find a matching level
1384                    for (nextLoadLevel = frag.level - 1; nextLoadLevel > minAutoLevel; nextLoadLevel--) {
1385                        // compute time to load next fragment at lower level
1386                        // 0.8 : consider only 80% of current bw to be conservative
1387                        // 8 = bits per byte (bps/Bps)
1388                        var levelNextBitrate = levels[nextLoadLevel].realBitrate ? Math.max(levels[nextLoadLevel].realBitrate, levels[nextLoadLevel].bitrate) : levels[nextLoadLevel].bitrate;
1389                        fragLevelNextLoadedDelay = frag.duration * levelNextBitrate / (8 * 0.8 * loadRate);
1390                        if (fragLevelNextLoadedDelay < bufferStarvationDelay) {
1391                            // we found a lower level that be rebuffering free with current estimated bw !
1392                            break;
1393                        }
1394                    }
1395                    // only emergency switch down if it takes less time to load new fragment at lowest level instead
1396                    // of finishing loading current one ...
1397                    if (fragLevelNextLoadedDelay < fragLoadedDelay) {
1398                        logger_1.logger.warn("loading too slow, abort fragment loading and switch to level " + nextLoadLevel + ":fragLoadedDelay[" + nextLoadLevel + "]<fragLoadedDelay[" + (frag.level - 1) + "];bufferStarvationDelay:" + fragLevelNextLoadedDelay.toFixed(1) + "<" + fragLoadedDelay.toFixed(1) + ":" + bufferStarvationDelay.toFixed(1));
1399                        // force next load level in auto mode
1400                        hls.nextLoadLevel = nextLoadLevel;
1401                        // update bw estimate for this fragment before cancelling load (this will help reducing the bw)
1402                        this._bwEstimator.sample(requestDelay, stats.loaded);
1403                        // abort fragment loading
1404                        loader.abort();
1405                        // stop abandon rules timer
1406                        this.clearTimer();
1407                        hls.trigger(events_1.default.FRAG_LOAD_EMERGENCY_ABORTED, { frag: frag, stats: stats });
1408                    }
1409                }
1410            }
1411        }
1412    };
1413    AbrController.prototype.onFragLoaded = function (data) {
1414        var frag = data.frag;
1415        if (frag.type === 'main' && Number.isFinite(frag.sn)) {
1416            // stop monitoring bw once frag loaded
1417            this.clearTimer();
1418            // store level id after successful fragment load
1419            this.lastLoadedFragLevel = frag.level;
1420            // reset forced auto level value so that next level will be selected
1421            this._nextAutoLevel = -1;
1422            // compute level average bitrate
1423            if (this.hls.config.abrMaxWithRealBitrate) {
1424                var level = this.hls.levels[frag.level];
1425                var loadedBytes = (level.loaded ? level.loaded.bytes : 0) + data.stats.loaded;
1426                var loadedDuration = (level.loaded ? level.loaded.duration : 0) + data.frag.duration;
1427                level.loaded = { bytes: loadedBytes, duration: loadedDuration };
1428                level.realBitrate = Math.round(8 * loadedBytes / loadedDuration);
1429            }
1430            // if fragment has been loaded to perform a bitrate test,
1431            if (data.frag.bitrateTest) {
1432                var stats = data.stats;
1433                stats.tparsed = stats.tbuffered = stats.tload;
1434                this.onFragBuffered(data);
1435            }
1436        }
1437    };
1438    AbrController.prototype.onFragBuffered = function (data) {
1439        var stats = data.stats;
1440        var frag = data.frag;
1441        // only update stats on first frag buffering
1442        // if same frag is loaded multiple times, it might be in browser cache, and loaded quickly
1443        // and leading to wrong bw estimation
1444        // on bitrate test, also only update stats once (if tload = tbuffered == on FRAG_LOADED)
1445        if (stats.aborted !== true && frag.type === 'main' && Number.isFinite(frag.sn) && ((!frag.bitrateTest || stats.tload === stats.tbuffered))) {
1446            // use tparsed-trequest instead of tbuffered-trequest to compute fragLoadingProcessing; rationale is that  buffer appending only happens once media is attached
1447            // in case we use config.startFragPrefetch while media is not attached yet, fragment might be parsed while media not attached yet, but it will only be buffered on media attached
1448            // as a consequence it could happen really late in the process. meaning that appending duration might appears huge ... leading to underestimated throughput estimation
1449            var fragLoadingProcessingMs = stats.tparsed - stats.trequest;
1450            logger_1.logger.log("latency/loading/parsing/append/kbps:" + Math.round(stats.tfirst - stats.trequest) + "/" + Math.round(stats.tload - stats.tfirst) + "/" + Math.round(stats.tparsed - stats.tload) + "/" + Math.round(stats.tbuffered - stats.tparsed) + "/" + Math.round(8 * stats.loaded / (stats.tbuffered - stats.trequest)));
1451            this._bwEstimator.sample(fragLoadingProcessingMs, stats.loaded);
1452            stats.bwEstimate = this._bwEstimator.getEstimate();
1453            // if fragment has been loaded to perform a bitrate test, (hls.startLevel = -1), store bitrate test delay duration
1454            if (frag.bitrateTest) {

1455                this.bitrateTestDelay = fragLoadingProcessingMs / 1000;
1456            }
1457            else {
1458                this.bitrateTestDelay = 0;
1459            }
1460        }
1461    };
1462    AbrController.prototype.onError = function (data) {
1463        // stop timer in case of frag loading error
1464        switch (data.details) {
1465            case errors_1.ErrorDetails.FRAG_LOAD_ERROR:
1466            case errors_1.ErrorDetails.FRAG_LOAD_TIMEOUT:
1467                this.clearTimer();
1468                break;
1469            default:
1470                break;
1471        }
1472    };
1473    AbrController.prototype.clearTimer = function () {
1474        clearInterval(this.timer);
1475        this.timer = null;
1476    };
1477    Object.defineProperty(AbrController.prototype, "nextAutoLevel", {
1478        // return next auto level
1479        get: function () {
1480            var forcedAutoLevel = this._nextAutoLevel;
1481            var bwEstimator = this._bwEstimator;
1482            // in case next auto level has been forced, and bw not available or not reliable, return forced value
1483            if (forcedAutoLevel !== -1 && (!bwEstimator || !bwEstimator.canEstimate())) {
1484                return forcedAutoLevel;
1485            }
1486            // compute next level using ABR logic
1487            var nextABRAutoLevel = this._nextABRAutoLevel;
1488            // if forced auto level has been defined, use it to cap ABR computed quality level
1489            if (forcedAutoLevel !== -1) {
1490                nextABRAutoLevel = Math.min(forcedAutoLevel, nextABRAutoLevel);
1491            }
1492            return nextABRAutoLevel;
1493        },
1494        set: function (nextLevel) {
1495            this._nextAutoLevel = nextLevel;
1496        },
1497        enumerable: true,
1498        configurable: true
1499    });
1500    Object.defineProperty(AbrController.prototype, "_nextABRAutoLevel", {
1501        get: function () {
1502            var hls = this.hls, maxAutoLevel = hls.maxAutoLevel, levels = hls.levels, config = hls.config, minAutoLevel = hls.minAutoLevel;
1503            var video = hls.media, currentLevel = this.lastLoadedFragLevel, currentFragDuration = this.fragCurrent ? this.fragCurrent.duration : 0, pos = (video ? video.currentTime : 0), 
1504            // playbackRate is the absolute value of the playback rate; if video.playbackRate is 0, we use 1 to load as
1505            // if we're playing back at the normal rate.
1506            playbackRate = ((video && (video.playbackRate !== 0)) ? Math.abs(video.playbackRate) : 1.0), avgbw = this._bwEstimator ? this._bwEstimator.getEstimate() : config.abrEwmaDefaultEstimate, 
1507            // bufferStarvationDelay is the wall-clock time left until the playback buffer is exhausted.
1508            bufferStarvationDelay = (buffer_helper_1.BufferHelper.bufferInfo(video, pos, config.maxBufferHole).end - pos) / playbackRate;
1509            // First, look to see if we can find a level matching with our avg bandwidth AND that could also guarantee no rebuffering at all
1510            var bestLevel = this._findBestLevel(currentLevel, currentFragDuration, avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, config.abrBandWidthFactor, config.abrBandWidthUpFactor, levels);
1511            if (bestLevel >= 0) {
1512                return bestLevel;
1513            }
1514            else {
1515                logger_1.logger.trace('rebuffering expected to happen, lets try to find a quality level minimizing the rebuffering');
1516                // not possible to get rid of rebuffering ... let's try to find level that will guarantee less than maxStarvationDelay of rebuffering
1517                // if no matching level found, logic will return 0
1518                var maxStarvationDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxStarvationDelay) : config.maxStarvationDelay, bwFactor = config.abrBandWidthFactor, bwUpFactor = config.abrBandWidthUpFactor;
1519                if (bufferStarvationDelay === 0) {
1520                    // in case buffer is empty, let's check if previous fragment was loaded to perform a bitrate test
1521                    var bitrateTestDelay = this.bitrateTestDelay;
1522                    if (bitrateTestDelay) {
1523                        // if it is the case, then we need to adjust our max starvation delay using maxLoadingDelay config value
1524                        // max video loading delay used in  automatic start level selection :
1525                        // in that mode ABR controller will ensure that video loading time (ie the time to fetch the first fragment at lowest quality level +
1526                        // the time to fetch the fragment at the appropriate quality level is less than ```maxLoadingDelay``` )
1527                        // cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
1528                        var maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
1529                        maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
1530                        logger_1.logger.trace("bitrate test took " + Math.round(1000 * bitrateTestDelay) + "ms, set first fragment max fetchDuration to " + Math.round(1000 * maxStarvationDelay) + " ms");
1531                        // don't use conservative factor on bitrate test
1532                        bwFactor = bwUpFactor = 1;
1533                    }
1534                }
1535                bestLevel = this._findBestLevel(currentLevel, currentFragDuration, avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay + maxStarvationDelay, bwFactor, bwUpFactor, levels);
1536                return Math.max(bestLevel, 0);
1537            }
1538        },
1539        enumerable: true,
1540        configurable: true
1541    });
1542    AbrController.prototype._findBestLevel = function (currentLevel, currentFragDuration, currentBw, minAutoLevel, maxAutoLevel, maxFetchDuration, bwFactor, bwUpFactor, levels) {
1543        for (var i = maxAutoLevel; i >= minAutoLevel; i--) {
1544            var levelInfo = levels[i];
1545            if (!levelInfo) {
1546                continue;
1547            }
1548            var levelDetails = levelInfo.details, avgDuration = levelDetails ? levelDetails.totalduration / levelDetails.fragments.length : currentFragDuration, live = levelDetails ? levelDetails.live : false, adjustedbw = void 0;
1549            // follow algorithm captured from stagefright :
1550            // https://android.googlesource.com/platform/frameworks/av/+/master/media/libstagefright/httplive/LiveSession.cpp
1551            // Pick the highest bandwidth stream below or equal to estimated bandwidth.
1552            // consider only 80% of the available bandwidth, but if we are switching up,
1553            // be even more conservative (70%) to avoid overestimating and immediately
1554            // switching back.
1555            if (i <= currentLevel) {
1556                adjustedbw = bwFactor * currentBw;
1557            }
1558            else {
1559                adjustedbw = bwUpFactor * currentBw;
1560            }
1561            var bitrate = levels[i].realBitrate ? Math.max(levels[i].realBitrate, levels[i].bitrate) : levels[i].bitrate, fetchDuration = bitrate * avgDuration / adjustedbw;
1562            logger_1.logger.trace("level/adjustedbw/bitrate/avgDuration/maxFetchDuration/fetchDuration: " + i + "/" + Math.round(adjustedbw) + "/" + bitrate + "/" + avgDuration + "/" + maxFetchDuration + "/" + fetchDuration);

1563            // if adjusted bw is greater than level bitrate AND
1564            if (adjustedbw > bitrate &&
1565                // fragment fetchDuration unknown OR live stream OR fragment fetchDuration less than max allowed fetch duration, then this level matches
1566                // we don't account for max Fetch Duration for live streams, this is to avoid switching down when near the edge of live sliding window ...
1567                // special case to support startLevel = -1 (bitrateTest) on live streams : in that case we should not exit loop so that _findBestLevel will return -1
1568                (!fetchDuration || (live && !this.bitrateTestDelay) || fetchDuration < maxFetchDuration)) {
1569                // as we are looping from highest to lowest, this will return the best achievable quality level
1570                return i;
1571            }
1572        }
1573        // not enough time budget even with quality level 0 ... rebuffering might happen
1574        return -1;
1575    };
1576    return AbrController;
1577}(event_handler_1.default));
1578exports.default = AbrController;
1579
1580/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.js")["Number"]))
1581
1582/***/ }),
1583

1584/***/ "./src/controller/audio-stream-controller.js":
1585/*!***************************************************!*\
1586  !*** ./src/controller/audio-stream-controller.js ***!
1587  \***************************************************/
1588/*! no static exports found */
1589/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
1590/***/ (function(module, exports, __webpack_require__) {
1591
1592"use strict";
1593/* WEBPACK VAR INJECTION */(function(Number) {
1594/*
1595 * Audio Stream Controller
1596*/
1597var __extends = (this && this.__extends) || (function () {
1598    var extendStatics = Object.setPrototypeOf ||
1599        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
1600        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
1601    return function (d, b) {
1602        extendStatics(d, b);
1603        function __() { this.constructor = d; }
1604        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
1605    };
1606})();
1607Object.defineProperty(exports, "__esModule", { value: true });
1608var binary_search_1 = __webpack_require__(/*! ../utils/binary-search */ "./src/utils/binary-search.js");
1609var buffer_helper_1 = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.js");
1610var demuxer_1 = __webpack_require__(/*! ../demux/demuxer */ "./src/demux/demuxer.js");
1611var events_1 = __webpack_require__(/*! ../events */ "./src/events.js");
1612var LevelHelper = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.js");
1613var time_ranges_1 = __webpack_require__(/*! ../utils/time-ranges */ "./src/utils/time-ranges.js");
1614var errors_1 = __webpack_require__(/*! ../errors */ "./src/errors.js");
1615var logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.js");
1616var discontinuities_1 = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.js");
1617var fragment_tracker_1 = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.js");
1618var fragment_1 = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.js");
1619var base_stream_controller_1 = __webpack_require__(/*! ./base-stream-controller */ "./src/controller/base-stream-controller.js");
1620var performance = window.performance;
1621var TICK_INTERVAL = 100; // how often to tick in ms
1622var AudioStreamController = /** @class */ (function (_super) {
1623    __extends(AudioStreamController, _super);
1624    function AudioStreamController(hls, fragmentTracker) {
1625        var _this = _super.call(this, hls, events_1.default.MEDIA_ATTA

1625CHED, events_1.default.MEDIA_DETACHING, events_1.default.AUDIO_TRACKS_UPDATED, events_1.default.AUDIO_TRACK_SWITCHING, events_1.default.AUDIO_TRACK_LOADED, events_1.default.KEY_LOADED, events_1.default.FRAG_LOADED, events_1.default.FRAG_PARSING_INIT_SEGMENT, events_1.default.FRAG_PARSING_DATA, events_1.default.FRAG_PARSED, events_1.default.ERROR, events_1.default.BUFFER_RESET, events_1.default.BUFFER_CREATED, events_1.default.BUFFER_APPENDED, events_1.default.BUFFER_FLUSHED, events_1.default.INIT_PTS_FOUND) || this;
1626        _this.fragmentTracker = fragmentTracker;
1627        _this.config = hls.config;
1628        _this.audioCodecSwap = false;
1629        _this._state = base_stream_controller_1.State.STOPPED;
1630        _this.initPTS = [];
1631        _this.waitingFragment = null;
1632        _this.videoTrackCC = null;
1633        return _this;
1634    }
1635    // Signal that video PTS was found
1636    AudioStreamController.prototype.onInitPtsFound = function (data) {
1637        var demuxerId = data.id, cc = data.frag.cc, initPTS = data.initPTS;
1638        if (demuxerId === 'main') {
1639            // Always update the new INIT PTS
1640            // Can change due level switch
1641            this.initPTS[cc] = initPTS;
1642            this.videoTrackCC = cc;
1643            logger_1.logger.log("InitPTS for cc: " + cc + " found from video track: " + initPTS);
1644            // If we are waiting we need to demux/remux the waiting frag

1645            // With the new initPTS
1646            if (this.state === base_stream_controller_1.State.WAITING_INIT_PTS) {
1647                this.tick();
1648            }
1649        }
1650    };
1651    AudioStreamController.prototype.startLoad = function (startPosition) {
1652        if (this.tracks) {
1653            var lastCurrentTime = this.lastCurrentTime;
1654            this.stopLoad();
1655            this.setInterval(TICK_INTERVAL);
1656            this.fragLoadError = 0;
1657            if (lastCurrentTime > 0 && startPosition === -1) {
1658                logger_1.logger.log("audio:override startPosition with lastCurrentTime @" + lastCurrentTime.toFixed(3));
1659                this.state = base_stream_controller_1.State.IDLE;
1660            }
1661            else {
1662                this.lastCurrentTime = this.startPosition ? this.startPosition : startPosition;
1663                this.state = base_stream_controller_1.State.STARTING;
1664            }
1665            this.nextLoadPosition = this.startPosition = this.lastCurrentTime;
1666            this.tick();
1667        }
1668        else {
1669            this.startPosition = startPosition;
1670            this.state = base_stream_controller_1.State.STOPPED;
1671        }
1672    };
1673    Object.defineProperty(AudioStreamController.prototype, "state", {
1674        get: function () {
1675            return this._state;
1676        },
1677        set: function (nextState) {
1678            if (this.state !== nextState) {
1679                var previousState = this.state;
1680                this._state = nextState;
1681                logger_1.logger.log("audio stream:" + previousState + "->" + nextState);
1682            }
1683        },
1684        enumerable: true,
1685        configurable: true
1686    });
1687    AudioStreamController.prototype.doTick = function () {
1688        var pos, track, trackDetails, hls = this.hls, config = hls.config;
1689        // logger.log('audioStream:' + this.state);
1690        switch (this.state) {
1691            case base_stream_controller_1.State.ERROR:
1692            // don't do anything in error state to avoid breaking further ...
1693            case base_stream_controller_1.State.PAUSED:
1694            // don't do anything in paused state either ...
1695            case base_stream_controller_1.State.BUFFER_FLUSHING:
1696                break;
1697            case base_stream_controller_1.State.STARTING:
1698                this.state = base_stream_controller_1.State.WAITING_TRACK;
1699                this.loadedmetadata = false;
1700                break;
1701            case base_stream_controller_1.State.IDLE:
1702                var tracks = this.tracks;
1703                // audio tracks not received => exit loop
1704                if (!tracks) {
1705                    break;
1706                }
1707                // if video not attached AND
1708                // start fragment already requested OR start frag prefetch disable
1709                // exit loop
1710                // => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
1711                if (!this.media &&
1712                    (this.startFragRequested || !config.startFragPrefetch)) {
1713                    break;
1714                }
1715                // determine next candidate fragment to be loaded, based on current position and
1716                //  end of buffer position
1717                // if we have not yet loaded any fragment, start loading from start position
1718                if (this.loadedmetadata) {
1719                    pos = this.media.currentTime;
1720                }
1721                else {
1722                    pos = this.nextLoadPosition;
1723                    if (pos === undefined) {
1724                        break;
1725                    }
1726                }
1727                var media = this.mediaBuffer ? this.mediaBuffer : this.media, videoBuffer = this.videoBuffer ? this.videoBuffer : this.media, bufferInfo = buffer_helper_1.BufferHelper.bufferInfo(media, pos, config.maxBufferHole), mainBufferInfo = buffer_helper_1.BufferHelper.bufferInfo(videoBuffer, pos, config.maxBufferHole), bufferLen = bufferInfo.len, bufferEnd_1 = bufferInfo.end, fragPrevious = this.fragPrevious, 
1728                // ensure we buffer at least config.maxBufferLength (default 30s) or config.max

1728MaxBufferLength (default: 600s)
1729                // whichever is smaller.
1730                // once we reach that threshold, don't buffer more than video (mainBufferInfo.len)
1731                maxConfigBuffer = Math.min(config.maxBufferLength, config.maxMaxBufferLength), maxBufLen = Math.max(maxConfigBuffer, mainBufferInfo.len), audioSwitch = this.audioSwitch, trackId = this.trackId;
1732                // if buffer length is less than maxBufLen try to load a new fragment
1733                if ((bufferLen < maxBufLen || audioSwitch) && trackId < tracks.length) {
1734                    trackDetails = tracks[trackId].details;
1735                    // if track info not retrieved yet, switch state and wait for track retrieval
1736                    if (typeof trackDetails === 'undefined') {
1737                        this.state = base_stream_controller_1.State.WAITING_TRACK;
1738                        break;
1739                    }
1740                    if (!audioSwitch && this._streamEnded(bufferInfo, trackDetails)) {
1741                        this.hls.trigger(events_1.default.BUFFER_EOS, { type: 'audio' });
1742                        this.state = base_stream_controller_1.State.ENDED;
1743                        return;
1744                    }
1745                    // find fragment index, contiguous with end of buffer position
1746                    var fragments = trackDetails.fragments, fragLen = fragments.length, start = fragments[0].start, end = fragments[fragLen - 1].start + fragments[fragLen - 1].duration, frag = void 0;
1747                    // When switching audio track, reload audio as close as possible to currentTime
1748                    if (audioSwitch) {
1749                        if (trackDetails.live && !trackDetails.PTSKnown) {
1750                            logger_1.logger.log('switching audiotrack, live stream, unknown PTS,load first fragment');
1751                            bufferEnd_1 = 0;
1752                        }
1753                        else {
1754                            bufferEnd_1 = pos;
1755                            // if currentTime (pos) is less than alt audio playlist start time, it means that alt audio is ahead of currentTime
1756                            if (trackDetails.PTSKnown && pos < start) {
1757                                // if everything is buffered from pos to start or if audio buffer upfront, let's seek to start
1758                                if (bufferInfo.end > start || bufferInfo.nextStart) {
1759                                    logger_1.logger.log('alt audio track ahead of main track, seek to start of alt audio track');
1760                                    this.media.currentTime = start + 0.05;
1761                                }
1762                                else {
1763                                    return;
1764                                }
1765                            }
1766                        }
1767                    }
1768                    if (trackDetails.initSegment && !trackDetails.initSegment.data) {
1769                        frag = trackDetails.initSegment;
1770                    } // eslint-disable-line brace-style
1771                    // if bufferEnd before start of playlist, load first fragment
1772                    else if (bufferEnd_1 <= start) {
1773                        frag = fragments[0];
1774                        if (this.videoTrackCC !== null && frag.cc !== this.videoTrackCC) {
1775                            // Ensure we find a fragment which matches the continuity of the video track
1776                            frag = discontinuities_1.findFragWithCC(fragments, this.videoTrackCC);
1777                        }
1778                        if (trackDetails.live && frag.loadIdx && frag.loadIdx === this.fragLoadIdx) {
1779                            // we just loaded this first fragment, and we are still lagging behind the start of the live playlist
1780                            // let's force seek to start
1781                            var nextBuffered = bufferInfo.nextStart ? bufferInfo.nextStart : start;
1782                            logger_1.logger.log("no alt audio available @currentTime:" + this.media.currentTime + ", seeking @" + (nextBuffered + 0.05));
1783                            this.media.currentTime = nextBuffered + 0.05;
1784                            return;
1785                        }
1786                    }
1787                    else {
1788                        var foundFrag = void 0;
1789                        var maxFragLookUpTolerance_1 = config.maxFragLookUpTolerance;
1790                        var fragNext = fragPrevious ? fragments[fragPrevious.sn - fragments[0].sn + 1] : undefined;
1791                        var fragmentWithinToleranceTest = function (candidate) {
1792                            // offset should be within fragment boundary - config.maxFragLookUpTolerance
1793                            // this is to cope with situations like
1794                            // bufferEnd = 9.991
1795                            // frag[Ø] : [0,10]
1796                            // frag[1] : [10,20]
1797                            // bufferEnd is within frag[0] range ... although what we are expecting is to return frag[1] here
1798                            //              frag start               frag start+duration
1799                            //                  |-----------------------------|
1800                            //              <--->                         <--->

1801                            //  ...--------><-----------------------------><---------....
1802                            // previous frag         matching fragment         next frag
1803                            //  return -1             return 0                 return 1
1804                            // logger.log(`level/sn/start/end/bufEnd:${level}/${candidate.sn}/${candidate.start}/${(candidate.start+candidate.duration)}/${bufferEnd}`);
1805                            // Set the lookup tolerance to be small enough to detect the current segment - ensures we don't skip over very small segments
1806                            var candidateLookupTolerance = Math.min(maxFragLookUpTolerance_1, candidate.duration);
1807                            if ((candidate.start + candidate.duration - candidateLookupTolerance) <= bufferEnd_1) {
1808                                return 1;
1809                            }
1810                            else if (candidate.start - candidateLookupTolerance > bufferEnd_1 && candidate.start) {
1811                                // if maxFragLookUpTolerance will have negative value then don't return -1 for first element
1812                                return -1;
1813                            }
1814                            return 0;
1815                        };
1816                        if (bufferEnd_1 < end) {
1817                            if (bufferEnd_1 > end - maxFragLookUpTolerance_1) {
1818                                maxFragLookUpTolerance_1 = 0;
1819                            }
1820                            // Prefer the next fragment if it's within tolerance
1821                            if (fragNext && !fragmentWithinToleranceTest(fragNext)) {
1822                                foundFrag = fragNext;
1823                            }
1824                            else {
1825                                foundFrag = binary_search_1.default.search(fragments, fragmentWithinToleranceTest);
1826                            }
1827                        }
1828                        else {
1829                            // reach end of playlist
1830                            foundFrag = fragments[fragLen - 1];
1831                        }
1832                        if (foundFrag) {
1833                            frag = foundFrag;
1834                            start = foundFrag.start;
1835                            // logger.log('find SN matching with pos:' +  bufferEnd + ':' + frag.sn);
1836                            if (fragPrevious && frag.level === fragPrevious.level && frag.sn === fragPrevious.sn) {
1837                                if (frag.sn < trackDetails.endSN) {
1838                                    frag = fragments[frag.sn + 1 - trackDetails.startSN];
1839                                    logger_1.logger.log("SN just loaded, load next one: " + frag.sn);
1840                                }
1841                                else {
1842                                    frag = null;
1843                                }
1844                            }
1845                        }
1846                    }
1847                    if (frag) {
1848                        // logger.log('      loading frag ' + i +',pos/bufEnd:' + pos.toFixed(3) + '/' + bufferEnd.toFixed(3));
1849                        if (frag.encrypted) {
1850                            logger_1.logger.log("Loading key for " + frag.sn + " of [" + trackDetails.startSN + " ," + trackDetails.endSN + "],track " + trackId);
1851                            this.state = base_stream_controller_1.State.KEY_LOADING;
1852                            hls.trigger(events_1.default.KEY_LOADING, { frag: frag });
1853                        }
1854                        else {
1855                            logger_1.logger.log("Loading " + frag.sn + ", cc: " + frag.cc + " of [" + trackDetails.startSN + " ," + trackDetails.endSN + "],track " + trackId + ", currentTime:" + pos + ",bufferEnd:" + bufferEnd_1.toFixed(3));
1856                            // only load if fragment is not loaded or if in audio switch
1857                            // we force a frag loading in audio switch as fragment tracker might not have evicted previous frags in case of quick audio switch
1858                            this.fragCurrent = frag;
1859                            if (audioSwitch || this.fragmentTracker.getState(frag) === fragment_tracker_1.FragmentState.NOT_LOADED) {
1860                                this.startFragRequested = true;
1861                                if (Number.isFinite(frag.sn)) {
1862                                    this.nextLoadPosition = frag.start + frag.duration;
1863                                }
1864                                hls.trigger(events_1.default.FRAG_LOADING, { frag: frag });
1865                                this.state = base_stream_controller_1.State.FRAG_LOADING;
1866                            }
1867                        }
1868                    }
1869                }
1870                break;
1871            case base_stream_controller_1.State.WAITING_TRACK:
1872                track = this.tracks[this.trackId];
1873                // check if playlist is already loaded
1874                if (track && track.details) {
1875                    this.state = base_stream_controller_1.State.IDLE;
1876                }
1877                break;
1878            case base_stream_controller_1.State.FRAG_LOADING_WAITING_RETRY:
1879                var now = performance.now();
1880                var retryDate = this.retryDate;
1881                media = this.media;
1882                var isSeeking = media && media.seeking;
1883                // if current time is gt than retryDate, or if media seeking let's switch to IDLE state to retry loading
1884                if (!retryDate || (now >= retryDate) || isSeeking) {
1885                    logger_1.logger.log('audioStreamController: retryDate reached, switch back to IDLE state');
1886                    this.state = base_stream_controller_1.State.IDLE;
1887                }
1888                break;
1889            case base_stream_controller_1.State.WAITING_INIT_PTS:
1890                var videoTrackCC = this.videoTrackCC;
1891                if (this.initPTS[videoTrackCC] === undefined) {
1892                    break;
1893                }
1894                // Ensure we don't get stuck in the WAITING_INIT_PTS state if the waiting frag CC doesn't match any initPTS
1895                var waitingFrag = this.waitingFragment;
1896                if (waitingFrag) {
1897                    var waitingFragCC = waitingFrag.frag.cc;
1898                    if (videoTrackCC !== waitingFragCC) {
1899                        track = this.tracks[this.trackId];
1900                        if (track.details && track.details.live) {
1901                            logger_1.logger.warn("Waiting fragment CC (" + waitingFragCC + ") does not match video track CC (" + videoTrackCC + ")");
1902                            this.waitingFragment = null;
1903                            this.state = base_stream_controller_1.State.IDLE;
1904                        }
1905                    }
1906                    else {
1907                        this.state = base_stream_controller_1.State.FRAG_LOADING;
1908                        this.onFragLoaded(this.waitingFragment);
1909                        this.waitingFragment = null;
1910                    }
1911                }
1912                else {
1913                    this.state = base_stream_controller_1.State.IDLE;
1914                }
1915                break;
1916            case base_stream_controller_1.State.STOPPED:
1917            case base_stream_controller_1.State.FRAG_LOADING:
1918            case base_stream_controller_1.State.PARSING:
1919            case base_stream_controller_1.State.PARSED:
1920            case base_stream_controller_1.State.ENDED:
1921                break;
1922            default:
1923                break;
1924        }
1925    };
1926    AudioStreamController.prototype.onMediaAttached = function (data) {
1927        var media = this.media = this.mediaBuffer = data.media;
1928        this.onvseeking = this.onMediaSeeking.bind(this);
1929        this.onvended = this.onMediaEnded.bind(this);
1930        media.addEventListener('seeking', this.onvseeking);
1931        media.addEventListener('ended', this.onvended);
1932        var config = this.config;
1933        if (this.tracks && config.autoStartLoad) {
1934            this.startLoad(config.startPosition);
1935        }
1936    };
1937    AudioStreamController.prototype.onMediaDetaching = function () {
1938        var media = this.media;
1939        if (media && media.ended) {
1940            logger_1.logger.log('MSE detaching and video ended, reset startPosition');
1941            this.startPosition = this.lastCurrentTime = 0;
1942        }
1943        // remove video listeners
1944        if (media) {
1945            media.removeEventListener('seeking', this.onvseeking);
1946            media.removeEventListener('ended', this.onvended);
1947            this.onvseeking = this.onvseeked = this.onvended = null;
1948        }
1949        this.media = this.mediaBuffer = this.videoBuffer = null;
1950        this.loadedmetadata = false;

1951        this.stopLoad();
1952    };
1953    AudioStreamController.prototype.onAudioTracksUpdated = function (data) {
1954        logger_1.logger.log('audio tracks updated');
1955        this.tracks = data.audioTracks;
1956    };
1957    AudioStreamController.prototype.onAudioTrackSwitching = function (data) {
1958        // if any URL found on new audio track, it is an alternate audio track
1959        var altAudio = !!data.url;
1960        this.trackId = data.id;
1961        this.fragCurrent = null;
1962        this.state = base_stream_controller_1.State.PAUSED;
1963        this.waitingFragment = null;
1964        // destroy useless demuxer when switching audio to main
1965        if (!altAudio) {
1966            if (this.demuxer) {
1967                this.demuxer.destroy();
1968                this.demuxer = null;
1969            }
1970        }
1971        else {
1972            // switching to audio track, start timer if not already started
1973            this.setInterval(TICK_INTERVAL);
1974        }
1975        // should we switch tracks ?
1976        if (altAudio) {
1977            this.audioSwitch = true;
1978            // main audio track are handled by stream-controller, just do something if switching to alt audio track
1979            this.state = base_stream_controller_1.State.IDLE;
1980        }
1981        this.tick();
1982    };
1983    AudioStreamController.prototype.onAudioTrackLoaded = function (data) {
1984        var newDetails = data.details, trackId = data.id, track = this.tracks[trackId], duration = newDetails.totalduration, sliding = 0;
1985        logger_1.logger.log("track " + trackId + " loaded [" + newDetails.startSN + "," + newDetails.endSN + "],duration:" + duration);
1986        if (newDetails.live) {
1987            var curDetails = track.details;
1988            if (curDetails && newDetails.fragments.length > 0) {
1989                // we already have details for that level, merge them
1990                LevelHelper.mergeDetails(curDetails, newDetails);
1991                sliding = newDetails.fragments[0].start;
1992                // TODO
1993                // this.liveSyncPosition = this.computeLivePosition(sliding, curDetails);
1994                if (newDetails.PTSKnown) {
1995                    logger_1.logger.log("live audio playlist sliding:" + sliding.toFixed(3));
1996                }
1997                else {
1998                    logger_1.logger.log('live audio playlist - outdated PTS, unknown sliding');
1999                }
2000            }
2001            else {
2002                newDetails.PTSKnown = false;
2003                logger_1.logger.log('live audio playlist - first load, unknown sliding');
2004            }
2005        }
2006        else {
2007            newDetails.PTSKnown = false;
2008        }
2009        track.details = newDetails;
2010        // compute start position
2011        if (!this.startFragRequested) {
2012            // compute start position if set to -1. use it straight away if value is defined
2013            if (this.startPosition === -1) {
2014                // first, check if start time offset has been set in playlist, if yes, use this value
2015                var startTimeOffset = newDetails.startTimeOffset;
2016                if (Number.isFinite(startTimeOffset)) {
2017                    logger_1.logger.log("start time offset found in playlist, adjust startPosition to " + startTimeOffset);
2018                    this.startPosition = startTimeOffset;
2019                }
2020                else {
2021                    this.startPosition = 0;
2022                }
2023            }
2024            this.nextLoadPosition = this.startPosition;
2025        }
2026        // only switch batck to IDLE state if we were waiting for track to start downloading a new fragment
2027        if (this.state === base_stream_controller_1.State.WAITING_TRACK) {
2028            this.state = base_stream_controller_1.State.IDLE;
2029        }
2030        // trigger handler right now
2031        this.tick();
2032    };
2033    AudioStreamController.prototype.onKeyLoaded = function () {
2034        if (this.state === base_stream_controller_1.State.KEY_LOADING) {
2035            this.state = base_stream_controller_1.State.IDLE;
2036            this.tick();
2037        }
2038    };
2039    AudioStreamController.prototype.onFragLoaded = function (data) {
2040        var fragCurrent = this.fragCurrent, fragLoaded = data.frag;
2041        if (this.state === base_stream_controller_1.State.FRAG_LOADING &&
2042            fragCurrent &&
2043            fragLoaded.type === 'audio' &&
2044            fragLoaded.level === fragCurrent.level &&
2045            fragLoaded.sn === fragCurrent.sn) {
2046            var track = this.tracks[this.trackId], details = track.details, duration = details.totalduration, trackId = fragCurrent.level, sn = fragCurrent.sn, cc = fragCurrent.cc, audioCodec = this.config.defaultAudioCodec || track.audioCodec || 'mp4a.40.2', stats = this.stats = data.stats;
2047            if (sn === 'initSegment') {
2048                this.state = base_stream_controller_1.State.IDLE;
2049                stats.tparsed = stats.tbuffered = performance.now();
2050                details.initSegment.data = data.payload;
2051                this.hls.trigger(events_1.default.FRAG_BUFFERED, { stats: stats, frag: fragCurrent, id: 'audio' });
2052                this.tick();
2053            }
2054            else {
2055                this.state = base_stream_controller_1.State.PARSING;
2056                // transmux the MPEG-TS data to ISO-BMFF segments
2057                this.appended = false;

2058                if (!this.demuxer) {
2059                    this.demuxer = new demuxer_1.default(this.hls, 'audio');
2060                }
2061                // Check if we have video initPTS
2062                // If not we need to wait for it
2063                var initPTS = this.initPTS[cc];
2064                var initSegmentData = details.initSegment ? details.initSegment.data : [];
2065                if (details.initSegment || initPTS !== undefined) {
2066                    this.pendingBuffering = true;
2067                    logger_1.logger.log("Demuxing " + sn + " of [" + details.startSN + " ," + details.endSN + "],track " + trackId);
2068                    // time Offset is accurate if level PTS is known, or if playlist is not sliding (not live)
2069                    var accurateTimeOffset = false; // details.PTSKnown || !details.live;
2070                    this.demuxer.push(data.payload, initSegmentData, audioCodec, null, fragCurrent, duration, accurateTimeOffset, initPTS);
2071                }
2072                else {
2073                    logger_1.logger.log("unknown video PTS for continuity counter " + cc + ", waiting for video PTS before demuxing audio frag " + sn + " of [" + details.startSN + " ," + details.endSN + "],track " + trackId);
2074                    this.waitingFragment = data;
2075                    this.state = base_stream_controller_1.State.WAITING_INIT_PTS;
2076                }
2077            }
2078        }
2079        this.fragLoadError = 0;
2080    };
2081    AudioStreamController.prototype.onFragParsingInitSegment = function (data) {
2082        var fragCurrent = this.fragCurrent;
2083        var fragNew = data.frag;
2084        if (fragCurrent &&
2085            data.id === 'audio' &&
2086            fragNew.sn === fragCurrent.sn &&
2087            fragNew.level === fragCurrent.level &&
2088            this.state === base_stream_controller_1.State.PARSING) {
2089            var tracks = data.tracks, track = void 0;
2090            // delete any video track found on audio demuxer
2091            if (tracks.video) {
2092                delete tracks.video;
2093            }
2094            // include levelCodec in audio and video tracks
2095            track = tracks.audio;
2096            if (track) {
2097                track.levelCodec = track.codec;
2098                track.id = data.id;
2099                this.hls.trigger(events_1.default.BUFFER_CODECS, tracks);
2100                logger_1.logger.log("audio track:audio,container:" + track.container + ",codecs[level/parsed]=[" + track.levelCodec + "/" + track.codec + "]");
2101                var initSegment = track.initSegment;
2102                if (initSegment) {
2103                    var appendObj = { type: 'audio', data: initSegment, parent: 'audio', content: 'initSegment' };
2104                    if (this.audioSwitch) {
2105                        this.pendingData = [appendObj];
2106                    }
2107                    else {
2108                        this.appended = true;
2109                        // arm pending Buffering flag before appending a segment
2110                        this.pendingBuffering = true;
2111                        this.hls.trigger(events_1.default.BUFFER_APPENDING, appendObj);
2112                    }
2113                }
2114                // trigger handler right now
2115                this.tick();
2116            }
2117        }
2118    };
2119    AudioStreamController.prototype.onFragParsingData = function (data) {
2120        var _this = this;
2121        var fragCurrent = this.fragCurrent;
2122        var fragNew = data.frag;
2123        if (fragCurrent &&
2124            data.id === 'audio' &&
2125            data.type === 'audio' &&
2126            fragNew.sn === fragCurrent.sn &&
2127            fragNew.level === fragCurrent.level &&
2128            this.state === base_stream_controller_1.State.PARSING) {
2129            var trackId = this.trackId, track = this.tracks[trackId], hls_1 = this.hls;
2130            if (!Number.isFinite(data.endPTS)) {
2131                data.endPTS = data.startPTS + fragCurrent.duration;
2132                data.endDTS = data.startDTS + fragCurrent.duration;
2133            }
2134            fragCurrent.addElementaryStream(fragment_1.default.ElementaryStreamTypes.AUDIO);
2135            logger_1.logger.log("parsed " + data.type + ",PTS:[" + data.startPTS.toFixed(3) + "," + data.endPTS.toFixed(3) + "],DTS:[" + data.startDTS.toFixed(3) + "/" + data.endDTS.toFixed(3) + "],nb:" + data.nb);
2136            LevelHelper.updateFragPTSDTS(track.details, fragCurrent, data.startPTS, data.endPTS);
2137            var audioSwitch = this.audioSwitch, media = this.media, appendOnBufferFlush = false;

2138            // Only flush audio from old audio tracks when PTS is known on new audio track
2139            if (audioSwitch && media) {
2140                if (media.readyState) {
2141                    var currentTime = media.currentTime;
2142                    logger_1.logger.log('switching audio track : currentTime:' + currentTime);
2143                    if (currentTime >= data.startPTS) {
2144                        logger_1.logger.log('switching audio track : flushing all audio');
2145                        this.state = base_stream_controller_1.State.BUFFER_FLUSHING;
2146                        hls_1.trigger(events_1.default.BUFFER_FLUSHING, { startOffset: 0, endOffset: Number.POSITIVE_INFINITY, type: 'audio' });
2147                        appendOnBufferFlush = true;
2148                        // Lets announce that the initial audio track switch flush occur
2149                        this.audioSwitch = false;
2150                        hls_1.trigger(events_1.default.AUDIO_TRACK_SWITCHED, { id: trackId });
2151                    }
2152                }
2153                else {
2154                    // Lets announce that the initial audio track switch flush occur
2155                    this.audioSwitch = false;
2156                    hls_1.trigger(events_1.default.AUDIO_TRACK_SWITCHED, { id: trackId });
2157                }
2158            }
2159            var pendingData_1 = this.pendingData;
2160            if (!pendingData_1) {
2161                logger_1.logger.warn('Apparently attempt to enqueue media payload without codec initialization data upfront');
2162                hls_1.trigger(events_1.default.ERROR, { type: errors_1.ErrorTypes.MEDIA_ERROR, details: null, fatal: true });
2163                return;
2164            }
2165            if (!this.audioSwitch) {
2166                [data.data1, data.data2].forEach(function (buffer) {
2167                    if (buffer && buffer.length) {
2168                        pendingData_1.push({ type: data.type, data: buffer, parent: 'audio', content: 'data' });
2169                    }
2170                });
2171                if (!appendOnBufferFlush && pendingData_1.length) {
2172                    pendingData_1.forEach(function (appendObj) {
2173                        // only append in PARSING state (rationale is that an appending error could happen synchronously on first segment appending)
2174                        // in that case it is useless to append following segments
2175                        if (_this.state === base_stream_controller_1.State.PARSING) {
2176                            // arm pending Buffering flag before appending a segment
2177                            _this.pendingBuffering = true;
2178                            _this.hls.trigger(events_1.default.BUFFER_APPENDING, appendObj);
2179                        }
2180                    });
2181                    this.pendingData = [];
2182                    this.appended = true;
2183                }
2184            }
2185            // trigger handler right now
2186            this.tick();
2187        }
2188    };
2189    AudioStreamController.prototype.onFragParsed = function (data) {
2190        var fragCurrent = this.fragCurrent;
2191        var fragNew = data.frag;
2192        if (fragCurrent &&
2193            data.id === 'audio' &&
2194            fragNew.sn === fragCurrent.sn &&
2195            fragNew.level === fragCurrent.level &&
2196            this.state === base_stream_controller_1.State.PARSING) {
2197            this.stats.tparsed = performance.now();
2198            this.state = base_stream_controller_1.State.PARSED;
2199            this._checkAppendedParsed();
2200        }
2201    };
2202    AudioStreamController.prototype.onBufferReset = function () {
2203        // reset reference to sourcebuffers
2204        this.mediaBuffer = this.videoBuffer = null;
2205        this.loadedmetadata = false;
2206    };
2207    AudioStreamController.prototype.onBufferCreated = function (data) {
2208        var audioTrack = data.tracks.audio;
2209        if (audioTrack) {
2210            this.mediaBuffer = audioTrack.buffer;
2211            this.loadedmetadata = true;
2212        }
2213        if (data.tracks.video) {
2214            this.videoBuffer = data.tracks.video.buffer;
2215        }
2216    };
2217    AudioStreamController.prototype.onBufferAppended = function (data) {
2218        if (data.parent === 'audio') {
2219            var state = this.state;
2220            if (state === base_stream_controller_1.State.PARSING || state === base_stream_controller_1.State.PARSED) {
2221                // check if all buffers have been appended
2222                this.pendingBuffering = (data.pending > 0);
2223                this._checkAppendedParsed();
2224            }
2225        }
2226    };
2227    AudioStreamController.prototype._checkAppendedParsed = function () {
2228        // trigger handler right now
2229        if (this.state === base_stream_controller_1.State.PARSED && (!this.appended || !this.pendingBuffering)) {
2230            var frag = this.fragCurrent, stats = this.stats, hls_2 = this.hls;
2231            if (frag) {
2232                this.fragPrevious = frag;
2233                stats.tbuffered = performance.now();
2234                hls_2.trigger(events_1.default.FRAG_BUFFERED, { stats: stats, frag: frag, id: 'audio' });
2235                var media = this.mediaBuffer ? this.mediaBuffer : this.media;
2236                logger_1.logger.log("audio buffered : " + time_ranges_1.default.toString(media.buffered));
2237                if (this.audioSwitch && this.appended) {
2238                    this.audioSwitch = false;

2239                    hls_2.trigger(events_1.default.AUDIO_TRACK_SWITCHED, { id: this.trackId });
2240                }
2241                this.state = base_stream_controller_1.State.IDLE;
2242            }
2243            this.tick();
2244        }
2245    };
2246    AudioStreamController.prototype.onError = function (data) {
2247        var frag = data.frag;
2248        // don't handle frag error not related to audio fragment
2249        if (frag && frag.type !== 'audio') {
2250            return;
2251        }
2252        switch (data.details) {
2253            case errors_1.ErrorDetails.FRAG_LOAD_ERROR:
2254            case errors_1.ErrorDetails.FRAG_LOAD_TIMEOUT:
2255                var frag_1 = data.frag;
2256                // don't handle frag error not related to audio fragment
2257                if (frag_1 && frag_1.type !== 'audio') {
2258                    break;
2259                }
2260                if (!data.fatal) {
2261                    var loadError = this.fragLoadError;
2262                    if (loadError) {
2263                        loadError++;
2264                    }
2265                    else {
2266                        loadError = 1;
2267                    }
2268                    var config = this.config;
2269                    if (loadError <= config.fragLoadingMaxRetry) {
2270                        this.fragLoadError = loadError;
2271                        // exponential backoff capped to config.fragLoadingMaxRetryTimeout
2272                        var delay = Math.min(Math.pow(2, loadError - 1) * config.fragLoadingRetryDelay, config.fragLoadingMaxRetryTimeout);
2273                        logger_1.logger.warn("AudioStreamController: frag loading failed, retry in " + delay + " ms");
2274                        this.retryDate = performance.now() + delay;
2275                        // retry loading state
2276                        this.state = base_stream_controller_1.State.FRAG_LOADING_WAITING_RETRY;
2277                    }
2278                    else {
2279                        logger_1.logger.error("AudioStreamController: " + data.details + " reaches max retry, redispatch as fatal ...");
2280                        // switch error to fatal
2281                        data.fatal = true;
2282                        this.state = base_stream_controller_1.State.ERROR;
2283                    }
2284                }
2285                break;
2286            case errors_1.ErrorDetails.AUDIO_TRACK_LOAD_ERROR:
2287            case errors_1.ErrorDetails.AUDIO_TRACK_LOAD_TIMEOUT:
2288            case errors_1.ErrorDetails.KEY_LOAD_ERROR:
2289            case errors_1.ErrorDetails.KEY_LOAD_TIMEOUT:
2290                //  when in ERROR state, don't switch back to IDLE state in case a non-fatal error is received
2291                if (this.state !== base_stream_controller_1.State.ERROR) {
2292                    // if fatal error, stop processing, otherwise move to IDLE to retry loading
2293                    this.state = data.fatal ? base_stream_controller_1.State.ERROR : base_stream_controller_1.State.IDLE;
2294                    logger_1.logger.warn("AudioStreamController: " + data.details + " while loading frag, now switching to " + this.state + " state ...");
2295                }
2296                break;
2297            case errors_1.ErrorDetails.BUFFER_FULL_ERROR:
2298                // if in appending state
2299                if (data.parent === 'audio' && (this.state === base_stream_controller_1.State.PARSING || this.state === base_stream_controller_1.State.PARSED)) {
2300                    var media = this.mediaBuffer, currentTime = this.media.currentTime, mediaBuffered = media && buffer_helper_1.BufferHelper.isBuffered(media, currentTime) && buffer_helper_1.BufferHelper.isBuffered(media, currentTime + 0.5);
2301                    // reduce max buf len if current position is buffered
2302                    if (mediaBuffered) {
2303                        var config = this.config;
2304                        if (config.maxMaxBufferLength >= config.maxBufferLength) {
2305                            // reduce max buffer length as it might be too high. we do this to avoid loop flushing ...
2306                            config.maxMaxBufferLength /= 2;
2307                            logger_1.logger.warn("AudioStreamController: reduce max buffer length to " + config.max

2307MaxBufferLength + "s");
2308                        }
2309                        this.state = base_stream_controller_1.State.IDLE;
2310                    }
2311                    else {
2312                        // current position is not buffered, but browser is still complaining about buffer full error
2313                        // this happens on IE/Edge, refer to https://github.com/video-dev/hls.js/pull/708
2314                        // in that case flush the whole audio buffer to recover
2315                        logger_1.logger.warn('AudioStreamController: buffer full error also media.currentTime is not buffered, flush audio buffer');
2316                        this.fragCurrent = null;
2317                        // flush everything
2318                        this.state = base_stream_controller_1.State.BUFFER_FLUSHING;
2319                        this.hls.trigger(events_1.default.BUFFER_FLUSHING, { startOffset: 0, endOffset: Number.POSITIVE_INFINITY, type: 'audio' });
2320                    }
2321                }
2322                break;
2323            default:
2324                break;
2325        }
2326    };
2327    AudioStreamController.prototype.onBufferFlushed = function () {
2328        var _this = this;
2329        var pendingData = this.pendingData;
2330        if (pendingData && pendingData.length) {
2331            logger_1.logger.log('AudioStreamController: appending pending audio data after buffer flushed');
2332            pendingData.forEach(function (appendObj) {
2333                _this.hls.trigger(events_1.default.BUFFER_APPENDING, appendObj);
2334            });
2335            this.appended = true;
2336            this.pendingData = [];
2337            this.state = base_stream_controller_1.State.PARSED;
2338        }
2339        else {
2340            // move to IDLE once flush complete. this should trigger new fragment loading
2341            this.state = base_stream_controller_1.State.IDLE;
2342            // reset reference to frag
2343            this.fragPrevious = null;
2344            this.tick();
2345        }
2346    };
2347    return AudioStreamController;
2348}(base_stream_controller_1.default));
2349exports.default = AudioStreamController;
2350
2351/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.js")["Number"]))
2352
2353/***/ }),
2354

2355/***/ "./src/controller/audio-track-controller.js":
2356/*!**************************************************!*\
2357  !*** ./src/controller/audio-track-controller.js ***!
2358  \**************************************************/
2359/*! no static exports found */
2360/*! ModuleConcatenation bailout: Module is not an ECMAScript module */
2361/***/ (function(module, exports, __webpack_require__) {
2362
2363"use strict";
2364
2365var __extends = (this && this.__extends) || (function () {
2366    var extendStatics = Object.setPrototypeOf ||
2367        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
2368        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
2369    return function (d, b) {
2370        extendStatics(d, b);
2371        function __() { this.constructor = d; }
2372        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2373    };
2374})();
2375Object.defineProperty(exports, "__esModule", { value: true });
2376var events_1 = __webpack_require__(/*! ../events */ "./src/events.js");
2377var task_loop_1 = __webpack_require__(/*! ../task-loop */ "./src/task-loop.js");
2378var logger_1 = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.js");
2379var errors_1 = __webpack_require__(/*! ../errors */ "./src/errors.js");
2380/**
2381 * @class AudioTrackController
2382 * @implements {EventHandler}
2383 *
2384 * Handles main manifest and audio-track metadata loaded,
2385 * owns and exposes the selectable audio-tracks data-models.
2386 *
2387 * Exposes internal interface to select available audio-tracks.
2388 *
2389 * Handles errors on loading audio-track playlists. Manages fallback mechanism
2390 * with redundants tracks (group-IDs).
2391 *
2392 * Handles level-loading and group-ID switches for video (fallback on video levels),
2393 * and eventually adapts the audio-track group-ID to match.
2394 *
2395 * @fires AUDIO_TRACK_LOADING
2396 * @fires AUDIO_TRACK_SWITCHING
2397 * @fires AUDIO_TRACKS_UPDATED
2398 * @fires ERROR
2399 *
2400 */
2401var AudioTrackController = /** @class */ (function (_super) {
2402    __extends(AudioTrackController, _super);
2403    function AudioTrackController(hls) {
2404        var _this = _super.call(this, hls, events_1.default.MANIFEST_LOADING, events_1.default.MANIFEST_PARSED, events_1.default.AUDIO_TRACK_LOADED, events_1.default.AUDIO_TRACK_SWITCHED, events_1.default.LEVEL_LOADED, events_1.default.ERROR) || this;
2405        /**
2406         * @private
2407         * Currently selected index in `tracks`
2408         * @member {number} trackId
2409         */
2410        _this._trackId = -1;
2411        /**
2412         * @private
2413         * If should select tracks according to default track attribute
2414         * @member {boolean} _selectDefaultTrack
2415         */
2416        _this._selectDefaultTrack = true;
2417        /**
2418         * @public
2419         * All tracks available
2420         * @member {AudioTrack[]}
2421         */
2422        _this.tracks = [];
2423        /**
2424         * @public
2425         * List of blacklisted audio track IDs (that have caused failure)
2426         * @member {number[]}
2427         */
2428        _this.trackIdBlacklist = Object.create(null);
2429        /**
2430         * @public
2431         * The currently running group ID for audio
2432         * (we grab this on manifest-parsed and new level-loaded)
2433         * @member {string}
2434         */
2435        _this.audioGroupId = null;
2436        return _this;
2437    }
2438    /**
2439     * Reset audio tracks on new manifest loading.
2440     */
2441    AudioTrackController.prototype.onManifestLoading = function () {
2442        this.tracks = [];
2443        this._trackId = -1;
2444        this._selectDefaultTrack = true;
2445    };
2446    /**
2447     * Store tracks data from manifest parsed data.
2448     *
2449     * Trigger AUDIO_TRACKS_UPDATED event.
2450     *
2451     * @param {*} data
2452     */
2453    AudioTrackController.prototype.onManifestParsed = function (data) {
2454        var tracks = this.tracks = data.audioTracks || [];
2455        this.hls.trigger(events_1.default.AUDIO_TRACKS_UPDATED, { audioTracks: tracks });
2456    };
2457    /**
2458     * Store track details of loaded track in our data-model.
2459     *
2460     * Set-up metadata update interval task for live-mode streams.
2461     *
2462     * @param {} data
2463     */
2464    AudioTrackController.prototype.onAudioTrackLoaded = function (data) {
2465        if (data.id >= this.tracks.length) {
2466            logger_1.logger.warn('Invalid audio track id:', data.id);
2467            return;
2468        }
2469        logger_1.logger.log("audioTrack " + data.id + " loaded");
2470        this.tracks[data.id].details = data.details;
2471        // check if current playlist is a live playlist
2472        // and if we have already our reload interval setup
2473        if (data.details.live && !this.hasInterval()) {
2474            // if live playlist we will have to reload it periodically
2475            // set reload period to playlist target duration
2476            var updatePeriodMs = data.details.targetduration * 1000;
2477            this.setInterval(updatePeriodMs);
2478        }
2479        if (!data.details.live && this.hasInterval()) {
2480            // playlist is not live and timer is scheduled: cancel it
2481            this.clearInterval();
2482        }
2483    };
2484    /**
2485     * Update the internal group ID to any audio-track we may have set manually
2486     * or because of a failure-handling fallback.
2487     *
2488     * Quality-levels should update to that group ID in this case.
2489     *
2490     * @param {*} data
2491     */
2492    AudioTrackController.prototype.onAudioTrackSwitched = function (data) {
2493        var audioGroupId = this.tracks[data.id].groupId;
2494        if (audioGroupId && (this.audioGroupId !== audioGroupId)) {
2495            this.audioGroupId = audioGroupId;
2496        }
2497    };
2498    /**
2499     * When a level gets loaded, if it has redundant audioGroupIds (in the same ordinality as it's redundant URLs)
2500     * we are setting our audio-group ID internally to the one set, if it is different from the group ID currently set.
2501     *
2502     * If group-ID got update, we re-select the appropriate audio-track with this group-ID matching the currently
2503     * selected one (based on NAME property).
2504     *
2505     * @param {*} data
2506     */
2507    AudioTrackController.prototype.onLevelLoaded = function (data) {
2508        // FIXME: crashes because currentLevel is undefined
2509        // const levelInfo = this.hls.levels[this.hls.currentLevel];
2510        var levelInfo = this.hls.levels[data.level];
2511        if (!levelInfo.audioGroupIds) {
2512            return;
2513        }
2514        var audioGroupId = levelInfo.audioGroupIds[levelInfo.urlId];
2515        if (this.audioGroupId !== audioGroupId) {
2516            this.audioGroupId = audioGroupId;
2517            this._selectInitialAudioTrack();
2518        }
2519    };
2520    /**
2521     * Handle network errors loading audio track manifests
2522     * and also pausing on any netwok errors.
2523     *
2524     * @param {ErrorEventData} data
2525     */
2526    AudioTrackController.prototype.onError = function (data) {
2527        // Only handle network errors

2528        if (data.type !== errors_1.ErrorTypes.NETWORK_ERROR) {
2529            return;
2530        }
2531        // If fatal network error, cancel update task
2532        if (data.fatal) {
2533            this.clearInterval();
2534        }
2535        // If not an audio-track loading error don't handle further
2536        if (data.details !== errors_1.ErrorDetails.AUDIO_TRACK_LOAD_ERROR) {
2537            return;
2538        }
2539        logger_1.logger.warn('Network failure on audio-track id:', data.context.id);
2540        this._handleLoadError();
2541    };
2542    Object.defineProperty(AudioTrackController.prototype, "audioTracks", {
2543        /**
2544         * @type {AudioTrack[]} Audio-track list we own
2545         */
2546        get: function () {
2547            return this.tracks;
2548        },
2549        enumerable: true,
2550        configurable: true
2551    });
2552    Object.defineProperty(AudioTrackController.prototype, "audioTrack", {
2553        /**
2554         * @type {number} Index into audio-tracks list of currently selected track.
2555         */
2556        get: function () {
2557            return this._trackId;
2558        },
2559        /**
2560         * Select current track by index
2561         */
2562        set: function (newId) {
2563            this._setAudioTrack(newId);
2564            // If audio track is selected from API then don't choose from the manifest default track
2565            this._selectDefaultTrack = false;
2566        },
2567        enumerable: true,
2568        configurable: true
2569    });
2570    /**
2571     * @private
2572     * @param {number} newId
2573     */
2574    AudioTrackController.prototype._setAudioTrack = function (newId) {
2575        // noop on same audio track id as already set
2576        if (this._trackId === newId && this.tracks[this._trackId].details) {
2577            logger_1.logger.debug('Same id as current audio-track passed, and track details available -> no-op');
2578            return;
2579        }
2580        // check if level idx is valid
2581        if (newId < 0 || newId >= this.tracks.length) {
2582            logger_1.logger.warn('Invalid id passed to audio-track controller');
2583            return;
2584        }
2585        var audioTrack = this.tracks[newId];
2586        logger_1.logger.log("Now switching to audio-track index " + newId);
2587        // stopping live reloading timer if any
2588        this.clearInterval();
2589        this._trackId = newId;
2590        var url = audioTrack.url, type = audioTrack.type, id = audioTrack.id;
2591        this.hls.trigger(events_1.default.AUDIO_TRACK_SWITCHING, { id: id, type: type, url: url });
2592        this._loadTrackDetailsIfNeeded(audioTrack);
2593    };
2594    /**
2595     * @override
2596     */
2597    AudioTrackController.prototype.doTick = function () {
2598        this._updateTrack(this._trackId);
2599    };
2600    /**
2601     * Select initial track
2602     * @private
2603     */
2604    AudioTrackController.prototype._selectInitialAudioTrack = function () {
2605        var _this = this;
2606        var tracks = this.tracks;
2607        if (!tracks.length) {
2608            return;
2609        }
2610        var currentAudioTrack = this.tracks[this._trackId];
2611        var name = null;
2612        if (currentAudioTrack) {
2613            name = currentAudioTrack.name;
2614        }
2615        // Pre-select default tracks if there are any
2616        if (this._selectDefaultTrack) {
2617            var defaultTracks = tracks.filter(function (track) { return track.default; });
2618            if (defaultTracks.length) {
2619                tracks = defaultTracks;
2620            }
2621            else {
2622                logger_1.logger.warn('No default audio tracks defined');
2623            }
2624        }
2625        var trackFound = false;
2626        var traverseTracks = function () {
2627            // Select track with right group ID
2628            tracks.forEach(function (track) {
2629                if (trackFound) {
2630                    return;
2631                }
2632                // We need to match the (pre-)selected group ID
2633                // and the NAME of the current track.
2634                if ((!_this.audioGroupId || track.groupId === _this.audioGroupId) &&
2635                    (!name || name === track.name)) {
2636                    // If there was a previous track try to stay with the same `NAME`.
2637                    // It should be unique across tracks of same group, and consistent through redundant track groups.
2638                    _this._setAudioTrack(track.id);
2639                    trackFound = true;
2640                }
2641            });
2642        };
2643        traverseTracks();
2644        if (!trackFound) {
2645            name = null;
2646            traverseTracks();
2647        }
2648        if (!trackFound) {
2649            logger_1.logger.error("No track found for running audio group-ID: " + this.audioGroupId);
2650            this.hls.trigger(events_1.default.ERROR, {
2651                type: errors_1.ErrorTypes.MEDIA_ERROR,
2652                details: errors_1.ErrorDetails.AUDIO_TRACK_LOAD_ERROR,
2653                fatal: true
2654            });
2655        }
2656    };
2657    /**
2658     * @private
2659     * @param {AudioTrack} audioTrack
2660     * @returns {boolean}
2661     */
2662    AudioTrackController.prototype._needsTrackLoading = function (audioTrack) {
2663        var details = audioTrack.details, url = audioTrack.url;