https://docs.paykeeper.ru/wp-content/plugins/plyr-hls//deps/hls/hls.light.js

1(function __HLS_WORKER_BUNDLE__(__IN_WORKER__){
2(function (global, factory) {
3  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
4  typeof define === 'function' && define.amd ? define(factory) :
5  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Hls = factory());
6})(this, (function () { 'use strict';
7
8  function _construct(t, e, r) {
9    if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
10    var o = [null];
11    o.push.apply(o, e);
12    var p = new (t.bind.apply(t, o))();
13    return r && _setPrototypeOf(p, r.prototype), p;
14  }
15  function _defineProperties(e, r) {
16    for (var t = 0; t < r.length; t++) {
17      var o = r[t];
18      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
19    }
20  }
21  function _createClass(e, r, t) {
22    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
23      writable: !1
24    }), e;
25  }
26  function _defineProperty(e, r, t) {
27    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
28      value: t,
29      enumerable: !0,
30      configurable: !0,
31      writable: !0
32    }) : e[r] = t, e;
33  }
34  function _extends() {
35    return _extends = Object.assign ? Object.assign.bind() : function (n) {
36      for (var e = 1; e < arguments.length; e++) {
37        var t = arguments[e];
38        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
39      }
40      return n;
41    }, _extends.apply(null, arguments);
42  }
43  function _getPrototypeOf(t) {
44    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
45      return t.__proto__ || Object.getPrototypeOf(t);
46    }, _getPrototypeOf(t);
47  }
48  function _inheritsLoose(t, o) {
49    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
50  }
51  function _isNativeFunction(t) {
52    try {
53      return -1 !== Function.toString.call(t).indexOf("[native code]");
54    } catch (n) {
55      return "function" == typeof t;
56    }
57  }
58  function _isNativeReflectConstruct() {
59    try {
60      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
61    } catch (t) {}
62    return (_isNativeReflectConstruct = function () {
63      return !!t;
64    })();
65  }
66  function ownKeys(e, r) {
67    var t = Object.keys(e);
68    if (Object.getOwnPropertySymbols) {
69      var o = Object.getOwnPropertySymbols(e);
70      r && (o = o.filter(function (r) {
71        return Object.getOwnPropertyDescriptor(e, r).enumerable;
72      })), t.push.apply(t, o);
73    }
74    return t;
75  }
76  function _objectSpread2(e) {
77    for (var r = 1; r < arguments.length; r++) {
78      var t = null != arguments[r] ? arguments[r] : {};
79      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
80        _defineProperty(e, r, t[r]);
81      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
82        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
83      });
84    }
85    return e;
86  }
87  function _setPrototypeOf(t, e) {
88    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
89      return t.__proto__ = e, t;
90    }, _setPrototypeOf(t, e);
91  }
92  function _toPrimitive(t, r) {
93    if ("object" != typeof t || !t) return t;
94    var e = t[Symbol.toPrimitive];
95    if (void 0 !== e) {
96      var i = e.call(t, r || "default");
97      if ("object" != typeof i) return i;
98      throw new TypeError("@@toPrimitive must return a primitive value.");
99    }
100    return ("string" === r ? String : Number)(t);
101  }
102  function _toPropertyKey(t) {
103    var i = _toPrimitive(t, "string");
104    return "symbol" == typeof i ? i : i + "";
105  }
106  function _wrapNativeSuper(t) {
107    var r = "function" == typeof Map ? new Map() : void 0;
108    return _wrapNativeSuper = function (t) {
109      if (null === t || !_isNativeFunction(t)) return t;
110      if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
111      if (void 0 !== r) {
112        if (r.has(t)) return r.get(t);
113        r.set(t, Wrapper);
114      }
115      function Wrapper() {
116        return _construct(t, arguments, _getPrototypeOf(this).constructor);
117      }
118      return Wrapper.prototype = Object.create(t.prototype, {
119        constructor: {
120          value: Wrapper,
121          enumerable: !1,
122          writable: !0,
123          configurable: !0
124        }
125      }), _setPrototypeOf(Wrapper, t);
126    }, _wrapNativeSuper(t);
127  }
128
129  function getDefaultExportFromCjs (x) {
130  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
131  }
132
133  var urlToolkit = {exports: {}};
134

135  (function (module, exports) {
136  	// see https://tools.ietf.org/html/rfc1808
137
138  	(function (root) {
139  	  var URL_REGEX =
140  	    /^(?=((?:[a-zA-Z0-9+\-.]+:)?))\1(?=((?:\/\/[^\/?#]*)?))\2(?=((?:(?:[^?#\/]*\/)*[^;?#\/]*)?))\3((?:;[^?#]*)?)(\?[^#]*)?(#[^]*)?$/;
141  	  var FIRST_SEGMENT_REGEX = /^(?=([^\/?#]*))\1([^]*)$/;
142  	  var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
143  	  var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
144
145  	  var URLToolkit = {
146  	    // If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
147  	    // E.g
148  	    // With opts.alwaysNormalize = false (default, spec compliant)
149  	    // http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
150  	    // With opts.alwaysNormalize = true (not spec compliant)
151  	    // http://a.com/b/cd + /e/f/../g => http://a.com/e/g
152  	    buildAbsoluteURL: function (baseURL, relativeURL, opts) {
153  	      opts = opts || {};
154  	      // remove any remaining space and CRLF
155  	      baseURL = baseURL.trim();
156  	      relativeURL = relativeURL.trim();
157  	      if (!relativeURL) {
158  	        // 2a) If the embedded URL is entirely empty, it inherits the
159  	        // entire base URL (i.e., is set equal to the base URL)
160  	        // and we are done.
161  	        if (!opts.alwaysNormalize) {
162  	          return baseURL;
163  	        }
164  	        var basePartsForNormalise = URLToolkit.parseURL(baseURL);
165  	        if (!basePartsForNormalise) {
166  	          throw new Error('Error trying to parse base URL.');
167  	        }
168  	        basePartsForNormalise.path = URLToolkit.normalizePath(
169  	          basePartsForNormalise.path
170  	        );
171  	        return URLToolkit.buildURLFromParts(basePartsForNormalise);
172  	      }
173  	      var relativeParts = URLToolkit.parseURL(relativeURL);
174  	      if (!relativeParts) {
175  	        throw new Error('Error trying to parse relative URL.');
176  	      }
177  	      if (relativeParts.scheme) {
178  	        // 2b) If the embedded URL starts with a scheme name, it is
179  	        // interpreted as an absolute URL and we are done.
180  	        if (!opts.alwaysNormalize) {
181  	          return relativeURL;
182  	        }
183  	        relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
184  	        return URLToolkit.buildURLFromParts(relativeParts);
185  	      }
186  	      var baseParts = URLToolkit.parseURL(baseURL);
187  	      if (!baseParts) {
188  	        throw new Error('Error trying to parse base URL.');
189  	      }
190  	      if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {
191  	        // If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc
192  	        // This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'
193  	        var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
194  	        baseParts.netLoc = pathParts[1];
195  	        baseParts.path = pathParts[2];
196  	      }
197  	      if (baseParts.netLoc && !baseParts.path) {
198  	        baseParts.path = '/';
199  	      }
200  	      var builtParts = {
201  	        // 2c) Otherwise, the embedded URL inherits the scheme of
202  	        // the base URL.
203  	        scheme: baseParts.scheme,
204  	        netLoc: relativeParts.netLoc,
205  	        path: null,
206  	        params: relativeParts.params,
207  	        query: relativeParts.query,
208  	        fragment: relativeParts.fragment,
209  	      };
210  	      if (!relativeParts.netLoc) {
211  	        // 3) If the embedded URL's <net_loc> is non-empty, we skip to
212  	        // Step 7.  Otherwise, the embedded URL inherits the <net_loc>
213  	        // (if any) of the base URL.
214  	        builtParts.netLoc = baseParts.netLoc;
215  	        // 4) If the embedded URL path is preceded by a slash "/", the
216  	        // path is not relative and we skip to Step 7.
217  	        if (relativeParts.path[0] !== '/') {
218  	          if (!relativeParts.path) {
219  	            // 5) If the embedded URL path is empty (and not preceded by a
220  	            // slash), then the embedded URL inherits the base URL path
221  	            builtParts.path = baseParts.path;
222  	            // 5a) if the embedded URL's <params> is non-empty, we skip to
223  	            // step 7; otherwise, it inherits the <params> of the base
224  	            // URL (if any) and
225  	            if (!relativeParts.params) {
226  	              builtParts.params = baseParts.params;
227  	              // 5b) if the embedded URL's <query> is non-empty, we skip to
228  	              // step 7; otherwise, it inherits the <query> of the base
229  	              // URL (if any) and we skip to step 7.
230  	              if (!relativeParts.query) {
231  	                builtParts.query = baseParts.query;
232  	              }
233  	            }
234  	          } else {
235  	            // 6) The last segment of the base URL's path (anything
236  	            // following the rightmost slash "/", or the entire path if no
237  	            // slash is present) is removed and the embedded URL's path is
238  	            // appended in its place.
239  	            var baseURLPath = baseParts.path;
240  	            var newPath =
241  	              baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) +
242  	              relativeParts.path;
243  	            builtParts.path = URLToolkit.normalizePath(newPath);
244  	          }
245  	        }
246  	      }
247  	      if (builtParts.path === null) {
248  	        builtParts.path = opts.alwaysNormalize
249  	          ? URLToolkit.normalizePath(relativeParts.path)
250  	          : relativeParts.path;
251  	      }
252  	      return URLToolkit.buildURLFromParts(builtParts);
253  	    },
254  	    parseURL: function (url) {
255  	      var parts = URL_REGEX.exec(url);
256  	      if (!parts) {
257  	        return null;
258  	      }
259  	      return {
260  	        scheme: parts[1] || '',
261  	        netLoc: parts[2] || '',
262  	        path: parts[3] || '',
263  	        params: parts[4] || '',
264  	        query: parts[5] || '',
265  	        fragment: parts[6] || '',
266  	      };
267  	    },
268  	    normalizePath: function (path) {
269  	      // The following operations are
270  	      // then applied, in order, to the new path:
271  	      // 6a) All occurrences of "./", where "." is a complete path
272  	      // segment, are removed.
273  	      // 6b) If the path ends with "." as a complete path segment,
274  	      // that "." is removed.
275  	      path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, '');
276  	      // 6c) All occurrences of "<segment>/../", where <segment> is a
277  	      // complete path segment not equal to "..", are removed.
278  	      // Removal of these path segments is performed iteratively,
279  	      // removing the leftmost matching pattern on each iteration,
280  	      // until no matching pattern remains.
281  	      // 6d) If the path ends with "<segment>/..", where <segment> is a
282  	      // complete path segment not equal to "..", that
283  	      // "<segment>/.." is removed.
284  	      while (
285  	        path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length
286  	      ) {}
287  	      return path.split('').reverse().join('');
288  	    },
289  	    buildURLFromParts: function (parts) {
290  	      return (
291  	        parts.scheme +
292  	        parts.netLoc +
293  	        parts.path +
294  	        parts.params +
295  	        parts.query +
296  	        parts.fragment
297  	      );
298  	    },
299  	  };
300
301  	  module.exports = URLToolkit;
302  	})(); 
303  } (urlToolkit));
304
305  var urlToolkitExports = urlToolkit.exports;
306
307  // https://caniuse.com/mdn-javascript_builtins_number_isfinite
308  var isFiniteNumber = Number.isFinite || function (value) {
309    return typeof value === 'number' && isFinite(value);
310  };
311
312  // https://caniuse.com/mdn-javascript_builtins_number_issafeinteger
313  var isSafeInteger = Number.isSafeInteger || function (value) {
314    return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
315  };
316  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
317
318  var Events = /*#__PURE__*/function (Events) {

420    ErrorDetails["REMUX_ALLOC_ERROR"] = "remuxAllocError";
421    ErrorDetails["KEY_LOAD_ERROR"] = "keyLoadError";
422    ErrorDetails["KEY_LOAD_TIMEOUT"] = "keyLoadTimeOut";
423    ErrorDetails["BUFFER_ADD_CODEC_ERROR"] = "bufferAddCodecError";
424    ErrorDetails["BUFFER_INCOMPATIBLE_CODECS_ERROR"] = "bufferIncompatibleCodecsError";
425    ErrorDetails["BUFFER_APPEND_ERROR"] = "bufferAppendError";
426    ErrorDetails["BUFFER_APPENDING_ERROR"] = "bufferAppendingError";
427    ErrorDetails["BUFFER_STALLED_ERROR"] = "bufferStalledError";
428    ErrorDetails["BUFFER_FULL_ERROR"] = "bufferFullError";
429    ErrorDetails["BUFFER_SEEK_OVER_HOLE"] = "bufferSeekOverHole";
430    ErrorDetails["BUFFER_NUDGE_ON_STALL"] = "bufferNudgeOnStall";
431    ErrorDetails["INTERNAL_EXCEPTION"] = "internalException";
432    ErrorDetails["INTERNAL_ABORTED"] = "aborted";
433    ErrorDetails["ATTACH_MEDIA_ERROR"] = "attachMediaError";
434    ErrorDetails["UNKNOWN"] = "unknown";
435    return ErrorDetails;
436  }({});
437
438  var Logger = function Logger(label, logger) {
439    this.trace = void 0;
440    this.debug = void 0;
441    this.log = void 0;
442    this.warn = void 0;
443    this.info = void 0;
444    this.error = void 0;
445    var lb = "[" + label + "]:";
446    this.trace = noop;
447    this.debug = logger.debug.bind(null, lb);
448    this.log = logger.log.bind(null, lb);
449    this.warn = logger.warn.bind(null, lb);
450    this.info = logger.info.bind(null, lb);
451    this.error = logger.error.bind(null, lb);
452  };
453  var noop = function noop() {};
454  var fakeLogger = {
455    trace: noop,
456    debug: noop,
457    log: noop,
458    warn: noop,
459    info: noop,
460    error: noop
461  };
462  function createLogger() {
463    return _extends({}, fakeLogger);
464  }
465
466  // let lastCallTime;
467  // function formatMsgWithTimeInfo(type, msg) {
468  //   const now = Date.now();
469  //   const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
470  //   lastCallTime = now;
471  //   msg = (new Date(now)).toISOString() + ' | [' +  type + '] > ' + msg + ' ( ' + diff + ' ms )';
472  //   return msg;
473  // }
474
475  function consolePrintFn(type, id) {
476    var func = self.console[type];
477    return func ? func.bind(self.console, ('') + "[" + type + "] >") : noop;
478  }
479  function getLoggerFn(key, debugConfig, id) {
480    return debugConfig[key] ? debugConfig[key].bind(debugConfig) : consolePrintFn(key);
481  }
482  var exportedLogger = createLogger();
483  function enableLogs(debugConfig, context, id) {
484    // check that console is available
485    var newLogger = createLogger();
486    if (typeof console === 'object' && debugConfig === true || typeof debugConfig === 'object') {
487      var keys = [
488      // Remove out from list here to hard-disable a log-level
489      // 'trace',
490      'debug', 'log', 'info', 'warn', 'error'];
491      keys.forEach(function (key) {
492        newLogger[key] = getLoggerFn(key, debugConfig);
493      });
494      // Some browsers don't allow to use bind on console object anyway
495      // fallback to default if needed
496      try {
497        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + undefined);
498      } catch (e) {
499        /* log fn threw an exception. All logger methods are no-ops. */
500        return createLogger();
501      }
502      // global exported logger uses the same functions as new logger without `id`
503      keys.forEach(function (key) {
504        exportedLogger[key] = getLoggerFn(key, debugConfig);
505      });
506    } else {
507      // Reset global exported logger
508      _extends(exportedLogger, newLogger);
509    }
510    return newLogger;
511  }
512  var logger = exportedLogger;
513
514  var DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
515  var ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
516
517  // adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
518  var AttrList = /*#__PURE__*/function () {
519    function AttrList(attrs, parsed) {
520      if (typeof attrs === 'string') {
521        attrs = AttrList.parseAttrList(attrs, parsed);
522      }
523      _extends(this, attrs);
524    }
525    var _proto = AttrList.prototype;
526    _proto.decimalInteger = function decimalInteger(attrName) {
527      var intValue = parseInt(this[attrName], 10);
528      if (intValue > Number.MAX_SAFE_INTEGER) {
529        return Infinity;
530      }
531      return intValue;
532    };
533    _proto.hexadecimalInteger = function hexadecimalInteger(attrName) {
534      if (this[attrName]) {
535        var stringValue = (this[attrName] || '0x').slice(2);

536        stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;
537        var value = new Uint8Array(stringValue.length / 2);
538        for (var i = 0; i < stringValue.length / 2; i++) {
539          value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
540        }
541        return value;
542      } else {
543        return null;
544      }
545    };
546    _proto.hexadecimalIntegerAsNumber = function hexadecimalIntegerAsNumber(attrName) {
547      var intValue = parseInt(this[attrName], 16);
548      if (intValue > Number.MAX_SAFE_INTEGER) {
549        return Infinity;
550      }
551      return intValue;
552    };
553    _proto.decimalFloatingPoint = function decimalFloatingPoint(attrName) {
554      return parseFloat(this[attrName]);
555    };
556    _proto.optionalFloat = function optionalFloat(attrName, defaultValue) {
557      var value = this[attrName];
558      return value ? parseFloat(value) : defaultValue;
559    };
560    _proto.enumeratedString = function enumeratedString(attrName) {
561      return this[attrName];
562    };
563    _proto.enumeratedStringList = function enumeratedStringList(attrName, dict) {
564      var attrValue = this[attrName];
565      return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce(function (result, identifier) {
566        result[identifier.toLowerCase()] = true;
567        return result;
568      }, dict);
569    };
570    _proto.bool = function bool(attrName) {
571      return this[attrName] === 'YES';
572    };
573    _proto.decimalResolution = function decimalResolution(attrName) {
574      var res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
575      if (res === null) {
576        return undefined;
577      }
578      return {
579        width: parseInt(res[1], 10),
580        height: parseInt(res[2], 10)
581      };
582    };
583    AttrList.parseAttrList = function parseAttrList(input, parsed) {
584      var match;
585      var attrs = {};
586      var quote = '"';
587      ATTR_LIST_REGEX.lastIndex = 0;
588      while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
589        var name = match[1].trim();
590        var value = match[2];
591        var quotedString = value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1;
592        var hexadecimalSequence = false;
593        if (quotedString) {
594          value = value.slice(1, -1);
595        } else {
596          switch (name) {
597            case 'IV':
598            case 'SCTE35-CMD':
599            case 'SCTE35-IN':
600            case 'SCTE35-OUT':
601              hexadecimalSequence = true;
602          }
603        }
604        if (parsed && (quotedString || hexadecimalSequence)) ; else if (!hexadecimalSequence && !quotedString) {
605          switch (name) {
606            case 'CLOSED-CAPTIONS':
607              if (value === 'NONE') {
608                break;
609              }
610            // falls through
611            case 'ALLOWED-CPC':
612            case 'CLASS':
613            case 'ASSOC-LANGUAGE':
614            case 'AUDIO':
615            case 'BYTERANGE':
616            case 'CHANNELS':
617            case 'CHARACTERISTICS':
618            case 'CODECS':
619            case 'DATA-ID':
620            case 'END-DATE':
621            case 'GROUP-ID':
622            case 'ID':
623            case 'IMPORT':
624            case 'INSTREAM-ID':
625            case 'KEYFORMAT':
626            case 'KEYFORMATVERSIONS':
627            case 'LANGUAGE':
628            case 'NAME':
629            case 'PATHWAY-ID':
630            case 'QUERYPARAM':
631            case 'RECENTLY-REMOVED-DATERANGES':
632            case 'SERVER-URI':
633            case 'STABLE-RENDITION-ID':
634            case 'STABLE-VARIANT-ID':
635            case 'START-DATE':
636            case 'SUBTITLES':
637            case 'SUPPLEMENTAL-CODECS':
638            case 'URI':
639            case 'VALUE':
640            case 'VIDEO':
641            case 'X-ASSET-LIST':
642            case 'X-ASSET-URI':
643              // Since we are not checking tag:attribute combination, just warn rather than ignoring attribute

644              logger.warn(input + ": attribute " + name + " is missing quotes");
645            // continue;
646          }
647        }
648        attrs[name] = value;
649      }
650      return attrs;
651    };
652    return _createClass(AttrList, [{
653      key: "clientAttrs",
654      get: function get() {
655        return Object.keys(this).filter(function (attr) {
656          return attr.substring(0, 2) === 'X-';
657        });
658      }
659    }]);
660  }();
661
662  // Avoid exporting const enum so that these values can be inlined
663
664  var CLASS_INTERSTITIAL = 'com.apple.hls.interstitial';
665  function isDateRangeCueAttribute(attrName) {
666    return attrName !== "ID" && attrName !== "CLASS" && attrName !== "CUE" && attrName !== "START-DATE" && attrName !== "DURATION" && attrName !== "END-DATE" && attrName !== "END-ON-NEXT";
667  }
668  function isSCTE35Attribute(attrName) {
669    return attrName === "SCTE35-OUT" || attrName === "SCTE35-IN" || attrName === "SCTE35-CMD";
670  }
671  var DateRange = /*#__PURE__*/function () {
672    function DateRange(dateRangeAttr, dateRangeWithSameId, tagCount) {
673      var _dateRangeWithSameId$;
674      if (tagCount === void 0) {
675        tagCount = 0;
676      }
677      this.attr = void 0;
678      this.tagAnchor = void 0;
679      this.tagOrder = void 0;
680      this._startDate = void 0;
681      this._endDate = void 0;
682      this._cue = void 0;
683      this._badValueForSameId = void 0;
684      this.tagAnchor = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagAnchor) || null;
685      this.tagOrder = (_dateRangeWithSameId$ = dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.tagOrder) != null ? _dateRangeWithSameId$ : tagCount;
686      if (dateRangeWithSameId) {
687        var previousAttr = dateRangeWithSameId.attr;
688        for (var key in previousAttr) {
689          if (Object.prototype.hasOwnProperty.call(dateRangeAttr, key) && dateRangeAttr[key] !== previousAttr[key]) {
690            logger.warn("DATERANGE tag attribute: \"" + key + "\" does not match for tags with ID: \"" + dateRangeAttr.ID + "\"");
691            this._badValueForSameId = key;
692            break;
693          }
694        }
695        // Merge DateRange tags with the same ID
696        dateRangeAttr = _extends(new AttrList({}), previousAttr, dateRangeAttr);
697      }
698      this.attr = dateRangeAttr;
699      this._startDate = dateRangeWithSameId ? dateRangeWithSameId.startDate : new Date(dateRangeAttr["START-DATE"]);
700      if ("END-DATE" in this.attr) {
701        var endDate = (dateRangeWithSameId == null ? void 0 : dateRangeWithSameId.endDate) || new Date(this.attr["END-DATE"]);
702        if (isFiniteNumber(endDate.getTime())) {
703          this._endDate = endDate;
704        }
705      }
706    }
707    return _createClass(DateRange, [{
708      key: "id",
709      get: function get() {
710        return this.attr.ID;
711      }
712    }, {
713      key: "class",
714      get: function get() {
715        return this.attr.CLASS;
716      }
717    }, {
718      key: "cue",
719      get: function get() {
720        var _cue = this._cue;
721        if (_cue === undefined) {
722          return this._cue = this.attr.enumeratedStringList(this.attr.CUE ? 'CUE' : 'X-CUE', {
723            pre: false,
724            post: false,
725            once: false
726          });
727        }
728        return _cue;
729      }
730    }, {
731      key: "startTime",
732      get: function get() {
733        var tagAnchor = this.tagAnchor;
734        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
735        if (tagAnchor === null || tagAnchor.programDateTime === null) {
736          logger.warn("Expected tagAnchor Fragment with PDT set for DateRange \"" + this.id + "\": " + tagAnchor);
737          return NaN;
738        }
739        return tagAnchor.start + (this.startDate.getTime() - tagAnchor.programDateTime) / 1000;
740      }
741    }, {
742      key: "startDate",
743      get: function get() {
744        return this._startDate;
745      }
746    }, {
747      key: "endDate",
748      get: function get() {
749        if (this._endDate) {
750          return this._endDate;
751        }
752        var duration = this.duration;
753        if (duration !== null) {
754          return new Date(this._startDate.getTime() + duration * 1000);
755        }
756        return null;
757      }
758    }, {
759      key: "duration",
760      get: function get() {
761        if ("DURATION" in this.attr) {
762          var duration = this.attr.decimalFloatingPoint("DURATION");
763          if (isFiniteNumber(duration)) {
764            return duration;
765          }
766        } else if (this._endDate) {
767          return (this._endDate.getTime() - this._startDate.getTime()) / 1000;
768        }
769        return null;
770      }
771    }, {
772      key: "plannedDuration",
773      get: function get() {
774        if ("PLANNED-DURATION" in this.attr) {
775          return this.attr.decimalFloatingPoint("PLANNED-DURATION");
776        }
777        return null;
778      }
779    }, {
780      key: "endOnNext",
781      get: function get() {
782        return this.attr.bool("END-ON-NEXT");
783      }
784    }, {
785      key: "isInterstitial",
786      get: function get() {
787        return this.class === CLASS_INTERSTITIAL;
788      }
789    }, {
790      key: "isValid",
791      get: function get() {
792        return !!this.id && !this._badValueForSameId && isFiniteNumber(this.startDate.getTime()) && (this.duration === null || this.duration >= 0) && (!this.endOnNext || !!this.class) && (!this.attr.CUE || !this.cue.pre && !this.cue.post || this.cue.pre !== this.cue.post) && (!this.isInterstitial || 'X-ASSET-URI' in this.attr || 'X-ASSET-LIST' in this.attr);
793      }
794    }]);
795  }();
796
797  var LoadStats = function LoadStats() {
798    this.aborted = false;
799    this.loaded = 0;
800    this.retry = 0;
801    this.total = 0;
802    this.chunkCount = 0;
803    this.bwEstimate = 0;
804    this.loading = {
805      start: 0,
806      first: 0,
807      end: 0
808    };
809    this.parsing = {
810      start: 0,
811      end: 0
812    };
813    this.buffering = {
814      start: 0,
815      first: 0,
816      end: 0
817    };
818  };
819
820  var ElementaryStreamTypes = {
821    AUDIO: "audio",
822    VIDEO: "video",
823    AUDIOVIDEO: "audiovideo"
824  };
825  var BaseSegment = /*#__PURE__*/function () {
826    function BaseSegment(baseurl) {
827      var _this$elementaryStrea;
828      this._byteRange = null;
829      this._url = null;
830      // baseurl is the URL to the playlist
831      this.baseurl = void 0;
832      // relurl is the portion of the URL that comes from inside the playlist.
833      this.relurl = void 0;
834      // Holds the types of data this fragment supports
835      this.elementaryStreams = (_this$elementaryStrea = {}, _this$elementaryStrea[ElementaryStreamTypes.AUDIO] = null, _this$elementaryStrea[ElementaryStreamTypes.VIDEO] = null, _this$elementaryStrea[ElementaryStreamTypes.AUDIOVIDEO] = null, _this$elementaryStrea);
836      this.baseurl = baseurl;
837    }
838
839    // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
840    var _proto = BaseSegment.prototype;
841    _proto.setByteRange = function setByteRange(value, previous) {
842      var params = value.split('@', 2);
843      var start;
844      if (params.length === 1) {
845        start = (previous == null ? void 0 : previous.byteRangeEndOffset) || 0;
846      } else {
847        start = parseInt(params[1]);
848      }
849      this._byteRange = [start, parseInt(params[0]) + start];
850    };
851    return _createClass(BaseSegment, [{
852      key: "byteRange",
853      get: function get() {
854        if (!this._byteRange) {
855          return [];
856        }
857        return this._byteRange;
858      }
859    }, {
860      key: "byteRangeStartOffset",
861      get: function get() {
862        return this.byteRange[0];
863      }
864    }, {
865      key: "byteRangeEndOffset",
866      get: function get() {
867        return this.byteRange[1];
868      }
869    }, {
870      key: "url",
871      get: function get() {
872        if (!this._url && this.baseurl && this.relurl) {
873          this._url = urlToolkitExports.buildAbsoluteURL(this.baseurl, this.relurl, {
874            alwaysNormalize: true
875          });
876        }
877        return this._url || '';
878      },
879      set: function set(value) {
880        this._url = value;
881      }
882    }]);
883  }();
884  /**
885   * Object representing parsed data from an HLS Segment. Found in {@link hls.js#LevelDetails.fragments}.
886   */
887  var Fragment = /*#__PURE__*/function (_BaseSegment2) {
888    function Fragment(type, baseurl) {
889      var _this;
890      _this = _BaseSegment2.call(this, baseurl) || this;
891      _this._decryptdata = null;
892      _this.rawProgramDateTime = null;
893      _this.programDateTime = null;
894      _this.tagList = [];
895      // EXTINF has to be present for a m3u8 to be considered valid
896      _this.duration = 0;
897      // sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
898      _this.sn = 0;
899      // levelkeys are the EXT-X-KEY tags that apply to this segment for decryption
900      // core difference from the private field _decryptdata is the lack of the initialized IV
901      // _decryptdata will set the IV for this segment based on the segment number in the fragment
902      _this.levelkeys = void 0;
903      // A string representing the fragment type
904      _this.type = void 0;
905      // A reference to the loader. Set while the fragment is loading, and removed afterwards. Used to abort fragment loading
906      _this.loader = null;
907      // A reference to the key loader. Set while the key is loading, and removed afterwards. Used to abort key loading
908      _this.keyLoader = null;
909      // The level/track index to which the fragment belongs
910      _this.level = -1;
911      // The continuity counter of the fragment
912      _this.cc = 0;
913      // The starting Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
914      _this.startPTS = void 0;
915      // The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
916      _this.endPTS = void 0;
917      // The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
918      _this.startDTS = void 0;
919      // The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
920      _this.endDTS = void 0;
921      // The start time of the fragment, as listed in the manifest. Updated after transmux complete.
922      _this.start = 0;
923      // Set by `updateFragPTSDTS` in level-helper
924      _this.deltaPTS = void 0;
925      // The maximum starting Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
926      _this.maxStartPTS = void 0;
927      // The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
928      _this.minEndPTS = void 0;

1044      }
1045    }]);
1046  }(BaseSegment);
1047
1048  /**
1049   * Object representing parsed data from an HLS Partial Segment. Found in {@link hls.js#LevelDetails.partList}.
1050   */
1051  var Part = /*#__PURE__*/function (_BaseSegment3) {
1052    function Part(partAttrs, frag, baseurl, index, previous) {
1053      var _this2;
1054      _this2 = _BaseSegment3.call(this, baseurl) || this;
1055      _this2.fragOffset = 0;
1056      _this2.duration = 0;
1057      _this2.gap = false;
1058      _this2.independent = false;
1059      _this2.relurl = void 0;
1060      _this2.fragment = void 0;
1061      _this2.index = void 0;
1062      _this2.stats = new LoadStats();
1063      _this2.duration = partAttrs.decimalFloatingPoint('DURATION');
1064      _this2.gap = partAttrs.bool('GAP');
1065      _this2.independent = partAttrs.bool('INDEPENDENT');
1066      _this2.relurl = partAttrs.enumeratedString('URI');
1067      _this2.fragment = frag;
1068      _this2.index = index;
1069      var byteRange = partAttrs.enumeratedString('BYTERANGE');
1070      if (byteRange) {
1071        _this2.setByteRange(byteRange, previous);
1072      }
1073      if (previous) {
1074        _this2.fragOffset = previous.fragOffset + previous.duration;
1075      }
1076      return _this2;
1077    }
1078    _inheritsLoose(Part, _BaseSegment3);
1079    return _createClass(Part, [{
1080      key: "start",
1081      get: function get() {
1082        return this.fragment.start + this.fragOffset;
1083      }
1084    }, {
1085      key: "end",
1086      get: function get() {
1087        return this.start + this.duration;
1088      }
1089    }, {
1090      key: "loaded",
1091      get: function get() {
1092        var elementaryStreams = this.elementaryStreams;
1093        return !!(elementaryStreams.audio || elementaryStreams.video || elementaryStreams.audiovideo);
1094      }
1095    }]);
1096  }(BaseSegment);
1097
1098  var DEFAULT_TARGET_DURATION = 10;
1099
1100  /**
1101   * Object representing parsed data from an HLS Media Playlist. Found in {@link hls.js#Level.details}.
1102   */
1103  var LevelDetails = /*#__PURE__*/function () {
1104    function LevelDetails(baseUrl) {
1105      this.PTSKnown = false;
1106      this.alignedSliding = false;
1107      this.averagetargetduration = void 0;
1108      this.endCC = 0;
1109      this.endSN = 0;
1110      this.fragments = void 0;
1111      this.fragmentHint = void 0;
1112      this.partList = null;
1113      this.dateRanges = void 0;
1114      this.dateRangeTagCount = 0;
1115      this.live = true;
1116      this.ageHeader = 0;
1117      this.advancedDateTime = void 0;
1118      this.updated = true;
1119      this.advanced = true;
1120      this.availabilityDelay = void 0;
1121      // Manifest reload synchronization
1122      this.misses = 0;
1123      this.startCC = 0;
1124      this.startSN = 0;
1125      this.startTimeOffset = null;
1126      this.targetduration = 0;
1127      this.totalduration = 0;
1128      this.type = null;
1129      this.url = void 0;
1130      this.m3u8 = '';
1131      this.version = null;
1132      this.canBlockReload = false;
1133      this.canSkipUntil = 0;
1134      this.canSkipDateRanges = false;
1135      this.skippedSegments = 0;
1136      this.recentlyRemovedDateranges = void 0;
1137      this.partHoldBack = 0;
1138      this.holdBack = 0;
1139      this.partTarget = 0;
1140      this.preloadHint = void 0;
1141      this.renditionReports = void 0;
1142      this.tuneInGoal = 0;
1143      this.deltaUpdateFailed = void 0;
1144      this.driftStartTime = 0;
1145      this.driftEndTime = 0;
1146      this.driftStart = 0;
1147      this.driftEnd = 0;
1148      this.encryptedFragments = void 0;
1149      this.playlistParsingError = null;
1150      this.variableList = null;
1151      this.hasVariableRefs = false;
1152      this.fragments = [];
1153      this.encryptedFragments = [];
1154      this.dateRanges = {};
1155      this.url = baseUrl;
1156    }
1157    var _proto = LevelDetails.prototype;
1158    _proto.reloaded = function reloaded(previous) {
1159      if (!previous) {
1160        this.advanced = true;
1161        this.updated = true;
1162        return;
1163      }
1164      var partSnDiff = this.lastPartSn - previous.lastPartSn;
1165      var partIndexDiff = this.lastPartIndex - previous.lastPartIndex;
1166      this.updated = this.endSN !== previous.endSN || !!partIndexDiff || !!partSnDiff || !this.live;
1167      this.advanced = this.endSN > previous.endSN || partSnDiff > 0 || partSnDiff === 0 && partIndexDiff > 0;
1168      if (this.updated || this.advanced) {
1169        this.misses = Math.floor(previous.misses * 0.6);
1170      } else {
1171        this.misses = previous.misses + 1;
1172      }
1173      this.availabilityDelay = previous.availabilityDelay;
1174    };
1175    return _createClass(LevelDetails, [{
1176      key: "hasProgramDateTime",
1177      get: function get() {
1178        if (this.fragments.length) {
1179          return isFiniteNumber(this.fragments[this.fragments.length - 1].programDateTime);
1180        }
1181        return false;

1182      }
1183    }, {
1184      key: "levelTargetDuration",
1185      get: function get() {
1186        return this.averagetargetduration || this.targetduration || DEFAULT_TARGET_DURATION;
1187      }
1188    }, {
1189      key: "drift",
1190      get: function get() {
1191        var runTime = this.driftEndTime - this.driftStartTime;
1192        if (runTime > 0) {
1193          var runDuration = this.driftEnd - this.driftStart;
1194          return runDuration * 1000 / runTime;
1195        }
1196        return 1;
1197      }
1198    }, {
1199      key: "edge",
1200      get: function get() {
1201        return this.partEnd || this.fragmentEnd;
1202      }
1203    }, {
1204      key: "partEnd",
1205      get: function get() {
1206        var _this$partList;
1207        if ((_this$partList = this.partList) != null && _this$partList.length) {
1208          return this.partList[this.partList.length - 1].end;
1209        }
1210        return this.fragmentEnd;
1211      }
1212    }, {
1213      key: "fragmentEnd",
1214      get: function get() {
1215        var _this$fragments;
1216        if ((_this$fragments = this.fragments) != null && _this$fragments.length) {
1217          return this.fragments[this.fragments.length - 1].end;
1218        }
1219        return 0;
1220      }
1221    }, {
1222      key: "age",
1223      get: function get() {
1224        if (this.advancedDateTime) {
1225          return Math.max(Date.now() - this.advancedDateTime, 0) / 1000;
1226        }
1227        return 0;
1228      }
1229    }, {
1230      key: "lastPartIndex",
1231      get: function get() {
1232        var _this$partList2;
1233        if ((_this$partList2 = this.partList) != null && _this$partList2.length) {
1234          return this.partList[this.partList.length - 1].index;
1235        }
1236        return -1;
1237      }
1238    }, {
1239      key: "lastPartSn",
1240      get: function get() {
1241        var _this$partList3;
1242        if ((_this$partList3 = this.partList) != null && _this$partList3.length) {
1243          return this.partList[this.partList.length - 1].fragment.sn;
1244        }
1245        return this.endSN;
1246      }
1247    }]);
1248  }();
1249
1250  var DecrypterAesMode = {
1251    cbc: 0,
1252    ctr: 1
1253  };
1254
1255  function isFullSegmentEncryption(method) {
1256    return method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR';
1257  }
1258  function getAesModeFromFullSegmentMethod(method) {
1259    switch (method) {
1260      case 'AES-128':
1261      case 'AES-256':
1262        return DecrypterAesMode.cbc;
1263      case 'AES-256-CTR':
1264        return DecrypterAesMode.ctr;
1265      default:
1266        throw new Error("invalid full segment method " + method);
1267    }
1268  }
1269
1270  // This file is inserted as a shim for modules which we do not want to include into the distro.
1271  // This replacement is done in the "alias" plugin of the rollup config.
1272  var empty = undefined;
1273  var HevcVideoParser = /*@__PURE__*/getDefaultExportFromCjs(empty);
1274
1275  function sliceUint8(array, start, end) {
1276    // @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
1277    // It always exists in the TypeScript definition so fails, but it fails at runtime on IE11.
1278    return Uint8Array.prototype.slice ? array.slice(start, end) : new Uint8Array(Array.prototype.slice.call(array, start, end));
1279  }
1280
1281  // http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
1282  // http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
1283  /* utf.js - UTF-8 <=> UTF-16 convertion
1284   *
1285   * Copyright (C) 1999 Masanao Izumo <[email protected]>
1286   * Version: 1.0
1287   * LastModified: Dec 25 1999
1288   * This library is free.  You can redistribute it and/or modify it.
1289   */
1290  /**
1291   * Converts a UTF-8 array to a string.
1292   *
1293   * @param array - The UTF-8 array to convert
1294   *
1295   * @returns The string
1296   *
1297   * @group Utils
1298   *
1299   * @beta
1300   */
1301  function utf8ArrayToStr(array, exitOnNull) {
1302    if (exitOnNull === void 0) {
1303      exitOnNull = false;
1304    }
1305    if (typeof TextDecoder !== 'undefined') {
1306      var decoder = new TextDecoder('utf-8');
1307      var decoded = decoder.decode(array);
1308      if (exitOnNull) {
1309        // grab up to the first null
1310        var idx = decoded.indexOf('\0');
1311        return idx !== -1 ? decoded.substring(0, idx) : decoded;
1312      }
1313      // remove any null characters
1314      return decoded.replace(/\0/g, '');
1315    }
1316    var len = array.length;
1317    var c;
1318    var char2;
1319    var char3;
1320    var out = '';
1321    var i = 0;
1322    while (i < len) {
1323      c = array[i++];
1324      if (c === 0x00 && exitOnNull) {
1325        return out;
1326      } else if (c === 0x00 || c === 0x03) {
1327        // If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
1328        continue;
1329      }
1330      switch (c >> 4) {
1331        case 0:
1332        case 1:
1333        case 2:
1334        case 3:
1335        case 4:
1336        case 5:
1337        case 6:
1338        case 7:
1339          // 0xxxxxxx
1340          out += String.fromCharCode(c);
1341          break;
1342        case 12:
1343        case 13:
1344          // 110x xxxx   10xx xxxx
1345          char2 = array[i++];
1346          out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
1347          break;
1348        case 14:

1349          // 1110 xxxx  10xx xxxx  10xx xxxx
1350          char2 = array[i++];
1351          char3 = array[i++];
1352          out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
1353          break;
1354      }
1355    }
1356    return out;
1357  }
1358
1359  /**
1360   *  hex dump helper class
1361   */
1362
1363  var Hex = {
1364    hexDump: function hexDump(array) {
1365      var str = '';
1366      for (var i = 0; i < array.length; i++) {
1367        var h = array[i].toString(16);
1368        if (h.length < 2) {
1369          h = '0' + h;
1370        }
1371        str += h;
1372      }
1373      return str;
1374    }
1375  };
1376
1377  var UINT32_MAX$1 = Math.pow(2, 32) - 1;
1378  var push = [].push;
1379
1380  // We are using fixed track IDs for driving the MP4 remuxer
1381  // instead of following the TS PIDs.
1382  // There is no reason not to do this and some browsers/SourceBuffer-demuxers
1383  // may not like if there are TrackID "switches"
1384  // See https://github.com/video-dev/hls.js/issues/1331
1385  // Here we are mapping our internal track types to constant MP4 track IDs
1386  // With MSE currently one can only have one track of each, and we are muxing
1387  // whatever video/audio rendition in them.
1388  var RemuxerTrackIdConfig = {
1389    video: 1,
1390    audio: 2,
1391    id3: 3,
1392    text: 4
1393  };
1394  function bin2str(data) {
1395    return String.fromCharCode.apply(null, data);
1396  }
1397  function readUint16(buffer, offset) {
1398    var val = buffer[offset] << 8 | buffer[offset + 1];
1399    return val < 0 ? 65536 + val : val;
1400  }
1401  function readUint32(buffer, offset) {
1402    var val = readSint32(buffer, offset);
1403    return val < 0 ? 4294967296 + val : val;
1404  }
1405  function readUint64(buffer, offset) {
1406    var result = readUint32(buffer, offset);
1407    result *= Math.pow(2, 32);
1408    result += readUint32(buffer, offset + 4);
1409    return result;
1410  }
1411  function readSint32(buffer, offset) {
1412    return buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
1413  }
1414  function writeUint32(buffer, offset, value) {
1415    buffer[offset] = value >> 24;
1416    buffer[offset + 1] = value >> 16 & 0xff;
1417    buffer[offset + 2] = value >> 8 & 0xff;
1418    buffer[offset + 3] = value & 0xff;
1419  }
1420
1421  // Find "moof" box
1422  function hasMoofData(data) {
1423    var end = data.byteLength;
1424    for (var i = 0; i < end;) {
1425      var size = readUint32(data, i);
1426      if (size > 8 && data[i + 4] === 0x6d && data[i + 5] === 0x6f && data[i + 6] === 0x6f && data[i + 7] === 0x66) {
1427        return true;
1428      }
1429      i = size > 1 ? i + size : end;
1430    }
1431    return false;
1432  }
1433
1434  // Find the data for a box specified by its path
1435  function findBox(data, path) {
1436    var results = [];
1437    if (!path.length) {
1438      // short-circuit the search for empty paths
1439      return results;
1440    }
1441    var end = data.byteLength;
1442    for (var i = 0; i < end;) {
1443      var size = readUint32(data, i);
1444      var type = bin2str(data.subarray(i + 4, i + 8));
1445      var endbox = size > 1 ? i + size : end;
1446      if (type === path[0]) {
1447        if (path.length === 1) {
1448          // this is the end of the path and we've found the box we were
1449          // looking for
1450          results.push(data.subarray(i + 8, endbox));
1451        } else {
1452          // recursively search for the next box along the path
1453          var subresults = findBox(data.subarray(i + 8, endbox), path.slice(1));
1454          if (subresults.length) {
1455            push.apply(results, subresults);
1456          }
1457        }
1458      }
1459      i = endbox;
1460    }
1461
1462    // we've finished searching all of data
1463    return results;
1464  }
1465  function parseSegmentIndex(sidx) {
1466    var references = [];
1467    var version = sidx[0];
1468
1469    // set initial offset, we skip the reference ID (not needed)
1470    var index = 8;
1471    var timescale = readUint32(sidx, index);
1472    index += 4;
1473    var earliestPresentationTime = 0;
1474    var firstOffset = 0;
1475    if (version === 0) {
1476      earliestPresentationTime = readUint32(sidx, index);
1477      firstOffset = readUint32(sidx, index + 4);
1478      index += 8;
1479    } else {
1480      earliestPresentationTime = readUint64(sidx, index);
1481      firstOffset = readUint64(sidx, index + 8);
1482      index += 16;
1483    }
1484
1485    // skip reserved
1486    index += 2;
1487    var startByte = sidx.length + firstOffset;
1488    var referencesCount = readUint16(sidx, index);
1489    index += 2;
1490    for (var i = 0; i < referencesCount; i++) {
1491      var referenceIndex = index;
1492      var referenceInfo = readUint32(sidx, referenceIndex);
1493      referenceIndex += 4;
1494      var referenceSize = referenceInfo & 0x7fffffff;
1495      var referenceType = (referenceInfo & 0x80000000) >>> 31;
1496      if (referenceType === 1) {
1497        logger.warn('SIDX has hierarchical references (not supported)');
1498        return null;
1499      }
1500      var subsegmentDuration = readUint32(sidx, referenceIndex);
1501      referenceIndex += 4;
1502      references.push({
1503        referenceSize: referenceSize,
1504        subsegmentDuration: subsegmentDuration,
1505        // unscaled
1506        info: {
1507          duration: subsegmentDuration / timescale,
1508          start: startByte,
1509          end: startByte + referenceSize - 1
1510        }
1511      });
1512      startByte += referenceSize;
1513
1514      // Skipping 1 bit for |startsWithSap|, 3 bits for |sapType|, and 28 bits
1515      // for |sapDelta|.
1516      referenceIndex += 4;
1517
1518      // skip to next ref
1519      index = referenceIndex;
1520    }
1521    return {
1522      earliestPresentationTime: earliestPresentationTime,
1523      timescale: timescale,
1524      version: version,
1525      referencesCount: referencesCount,
1526      references: references
1527    };
1528  }
1529
1530  /**
1531   * Parses an MP4 initialization segment and extracts stream type and
1532   * timescale values for any declared tracks. Timescale values indicate the

1610      sinfs.forEach(function (sinf) {
1611        var schm = findBox(sinf, ['schm'])[0];
1612        if (schm) {
1613          var scheme = bin2str(schm.subarray(4, 8));
1614          if (scheme === 'cbcs' || scheme === 'cenc') {
1615            var frma = findBox(sinf, ['frma'])[0];
1616            if (frma) {
1617              // for encrypted content codec fourCC will be in frma
1618              codec = bin2str(frma);
1619            }
1620          }
1621        }
1622      });
1623    }
1624    switch (codec) {
1625      case 'avc1':
1626      case 'avc2':
1627      case 'avc3':
1628      case 'avc4':
1629        {
1630          // extract profile + compatibility + level out of avcC box
1631          var avcCBox = findBox(sampleEntriesEnd, ['avcC'])[0];
1632          codec += '.' + toHex(avcCBox[1]) + toHex(avcCBox[2]) + toHex(avcCBox[3]);
1633          break;
1634        }
1635      case 'mp4a':
1636        {
1637          var codecBox = findBox(sampleEntries, [fourCC])[0];
1638          var esdsBox = findBox(codecBox.subarray(28), ['esds'])[0];
1639          if (esdsBox && esdsBox.length > 7) {
1640            var i = 4;
1641            // ES Descriptor tag
1642            if (esdsBox[i++] !== 0x03) {
1643              break;
1644            }
1645            i = skipBERInteger(esdsBox, i);
1646            i += 2; // skip es_id;
1647            var flags = esdsBox[i++];
1648            if (flags & 0x80) {
1649              i += 2; // skip dependency es_id
1650            }
1651            if (flags & 0x40) {
1652              i += esdsBox[i++]; // skip URL
1653            }
1654            // Decoder config descriptor
1655            if (esdsBox[i++] !== 0x04) {
1656              break;
1657            }
1658            i = skipBERInteger(esdsBox, i);
1659            var objectType = esdsBox[i++];
1660            if (objectType === 0x40) {
1661              codec += '.' + toHex(objectType);
1662            } else {
1663              break;
1664            }
1665            i += 12;
1666            // Decoder specific info
1667            if (esdsBox[i++] !== 0x05) {
1668              break;
1669            }
1670            i = skipBERInteger(esdsBox, i);
1671            var firstByte = esdsBox[i++];
1672            var audioObjectType = (firstByte & 0xf8) >> 3;
1673            if (audioObjectType === 31) {
1674              audioObjectType += 1 + ((firstByte & 0x7) << 3) + ((esdsBox[i] & 0xe0) >> 5);
1675            }
1676            codec += '.' + audioObjectType;
1677          }
1678          break;
1679        }
1680      case 'hvc1':
1681      case 'hev1':
1682        {
1683          var hvcCBox = findBox(sampleEntriesEnd, ['hvcC'])[0];
1684          var profileByte = hvcCBox[1];
1685          var profileSpace = ['', 'A', 'B', 'C'][profileByte >> 6];
1686          var generalProfileIdc = profileByte & 0x1f;
1687          var profileCompat = readUint32(hvcCBox, 2);
1688          var tierFlag = (profileByte & 0x20) >> 5 ? 'H' : 'L';
1689          var levelIDC = hvcCBox[12];
1690          var constraintIndicator = hvcCBox.subarray(6, 12);
1691          codec += '.' + profileSpace + generalProfileIdc;
1692          codec += '.' + profileCompat.toString(16).toUpperCase();
1693          codec += '.' + tierFlag + levelIDC;
1694          var constraintString = '';
1695          for (var _i = constraintIndicator.length; _i--;) {
1696            var _byte = constraintIndicator[_i];
1697            if (_byte || constraintString) {
1698              var encodedByte = _byte.toString(16).toUpperCase();
1699              constraintString = '.' + encodedByte + constraintString;
1700            }
1701          }
1702          codec += constraintString;
1703          break;
1704        }
1705      case 'dvh1':
1706      case 'dvhe':
1707        {
1708          var dvcCBox = findBox(sampleEntriesEnd, ['dvcC'])[0];
1709          var profile = dvcCBox[2] >> 1 & 0x7f;
1710          var level = dvcCBox[2] << 5 & 0x20 | dvcCBox[3] >> 3 & 0x1f;
1711          codec += '.' + addLeadingZero(profile) + '.' + addLeadingZero(level);
1712          break;
1713        }
1714      case 'vp09':
1715        {
1716          var vpcCBox = findBox(sampleEntriesEnd, ['vpcC'])[0];
1717          var _profile = vpcCBox[4];
1718          var _level = vpcCBox[5];
1719          var bitDepth = vpcCBox[6] >> 4 & 0x0f;
1720          codec += '.' + addLeadingZero(_profile) + '.' + addLeadingZero(_level) + '.' + addLeadingZero(bitDepth);
1721          break;
1722        }
1723      case 'av01':
1724        {
1725          var av1CBox = findBox(sampleEntriesEnd, ['av1C'])[0];
1726          var _profile2 = av1CBox[1] >>> 5;
1727          var _level2 = av1CBox[1] & 0x1f;
1728          var _tierFlag = av1CBox[2] >>> 7 ? 'H' : 'M';
1729          var highBitDepth = (av1CBox[2] & 0x40) >> 6;
1730          var twelveBit = (av1CBox[2] & 0x20) >> 5;
1731          var _bitDepth = _profile2 === 2 && highBitDepth ? twelveBit ? 12 : 10 : highBitDepth ? 10 : 8;
1732          var monochrome = (av1CBox[2] & 0x10) >> 4;
1733          var chromaSubsamplingX = (av1CBox[2] & 0x08) >> 3;
1734          var chromaSubsamplingY = (av1CBox[2] & 0x04) >> 2;
1735          var chromaSamplePosition = av1CBox[2] & 0x03;
1736          // TODO: parse color_description_present_flag
1737          // default it to BT.709/limited range for now
1738          // more info https://aomediacodec.github.io/av1-isobmff/#av1codecconfigurationbox-syntax
1739          var colorPrimaries = 1;
1740          var transferCharacteristics = 1;
1741          var matrixCoefficients = 1;
1742          var videoFullRangeFlag = 0;
1743          codec += '.' + _profile2 + '.' + addLeadingZero(_level2) + _tierFlag + '.' + addLeadingZero(_bitDepth) + '.' + monochrome + '.' + chromaSubsamplingX + chromaSubsamplingY + chromaSamplePosition + '.' + addLeadingZero(colorPrimaries) + '.' + addLeadingZero(transferCharacteristics) + '.' + addLeadingZero(matrixCoefficients) + '.' + videoFullRangeFlag;
1744          break;
1745        }
1746    }
1747    return {
1748      codec: codec,
1749      encrypted: encrypted
1750    };
1751  }
1752  function skipBERInteger(bytes, i) {
1753    var limit = i + 5;
1754    while (bytes[i++] & 0x80 && i < limit) {
1755      /* do nothing */
1756    }
1757    return i;
1758  }
1759  function toHex(x) {
1760    return ('0' + x.toString(16).toUpperCase()).slice(-2);
1761  }
1762  function addLeadingZero(num) {
1763    return (num < 10 ? '0' : '') + num;
1764  }
1765  function patchEncyptionData(initSegment, decryptdata) {
1766    if (!initSegment || !decryptdata) {
1767      return initSegment;
1768    }
1769    var keyId = decryptdata.keyId;
1770    if (keyId && decryptdata.isCommonEncryption) {
1771      var traks = findBox(initSegment, ['moov', 'trak']);
1772      traks.forEach(function (trak) {
1773        var stsd = findBox(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];
1774
1775        // skip the sample entry count
1776        var sampleEntries = stsd.subarray(8);
1777        var encBoxes = findBox(sampleEntries, ['enca']);
1778        var isAudio = encBoxes.length > 0;
1779        if (!isAudio) {
1780          encBoxes = findBox(sampleEntries, ['encv']);
1781        }

2017      findBox(traf, ['tfhd']).forEach(function (tfhd) {
2018        // get the track id from the tfhd
2019        var id = readUint32(tfhd, 4);
2020        var track = initData[id];
2021        if (!track) {
2022          return;
2023        }
2024        // assume a 90kHz clock if no timescale was specified
2025        var timescale = track.timescale || 90e3;
2026        // get the base media decode time from the tfdt
2027        findBox(traf, ['tfdt']).forEach(function (tfdt) {
2028          var version = tfdt[0];
2029          var offset = timeOffset * timescale;
2030          if (offset) {
2031            var baseMediaDecodeTime = readUint32(tfdt, 4);
2032            if (version === 0) {
2033              baseMediaDecodeTime -= offset;
2034              baseMediaDecodeTime = Math.max(baseMediaDecodeTime, 0);
2035              writeUint32(tfdt, 4, baseMediaDecodeTime);
2036            } else {
2037              baseMediaDecodeTime *= Math.pow(2, 32);
2038              baseMediaDecodeTime += readUint32(tfdt, 8);
2039              baseMediaDecodeTime -= offset;
2040              baseMediaDecodeTime = Math.max(baseMediaDecodeTime, 0);
2041              var upper = Math.floor(baseMediaDecodeTime / (UINT32_MAX$1 + 1));
2042              var lower = Math.floor(baseMediaDecodeTime % (UINT32_MAX$1 + 1));
2043              writeUint32(tfdt, 4, upper);
2044              writeUint32(tfdt, 8, lower);
2045            }
2046          }
2047        });
2048      });
2049    });
2050  }
2051
2052  // TODO: Check if the last moof+mdat pair is part of the valid range
2053  function segmentValidRange(data) {
2054    var segmentedRange = {
2055      valid: null,
2056      remainder: null
2057    };
2058    var moofs = findBox(data, ['moof']);
2059    if (moofs.length < 2) {
2060      segmentedRange.remainder = data;
2061      return segmentedRange;
2062    }
2063    var last = moofs[moofs.length - 1];
2064    // Offset by 8 bytes; findBox offsets the start by as much
2065    segmentedRange.valid = sliceUint8(data, 0, last.byteOffset - 8);
2066    segmentedRange.remainder = sliceUint8(data, last.byteOffset - 8);
2067    return segmentedRange;
2068  }
2069  function appendUint8Array(data1, data2) {
2070    var temp = new Uint8Array(data1.length + data2.length);
2071    temp.set(data1);
2072    temp.set(data2, data1.length);
2073    return temp;
2074  }
2075  function parseSamples(timeOffset, track) {
2076    var seiSamples = [];
2077    var videoData = track.samples;
2078    var timescale = track.timescale;
2079    var trackId = track.id;
2080    var isHEVCFlavor = false;
2081    var moofs = findBox(videoData, ['moof']);
2082    moofs.map(function (moof) {
2083      var moofOffset = moof.byteOffset - 8;
2084      var trafs = findBox(moof, ['traf']);
2085      trafs.map(function (traf) {
2086        // get the base media decode time from the tfdt
2087        var baseTime = findBox(traf, ['tfdt']).map(function (tfdt) {
2088          var version = tfdt[0];
2089          var result = readUint32(tfdt, 4);
2090          if (version === 1) {
2091            result *= Math.pow(2, 32);
2092            result += readUint32(tfdt, 8);
2093          }
2094          return result / timescale;
2095        })[0];
2096        if (baseTime !== undefined) {
2097          timeOffset = baseTime;
2098        }
2099        return findBox(traf, ['tfhd']).map(function (tfhd) {
2100          var id = readUint32(tfhd, 4);
2101          var tfhdFlags = readUint32(tfhd, 0) & 0xffffff;
2102          var baseDataOffsetPresent = (tfhdFlags & 0x000001) !== 0;
2103          var sampleDescriptionIndexPresent = (tfhdFlags & 0x000002) !== 0;
2104          var defaultSampleDurationPresent = (tfhdFlags & 0x000008) !== 0;
2105          var defaultSampleDuration = 0;
2106          var defaultSampleSizePresent = (tfhdFlags & 0x000010) !== 0;
2107          var defaultSampleSize = 0;
2108          var defaultSampleFlagsPresent = (tfhdFlags & 0x000020) !== 0;
2109          var tfhdOffset = 8;
2110          if (id === trackId) {
2111            if (baseDataOffsetPresent) {
2112              tfhdOffset += 8;
2113            }
2114            if (sampleDescriptionIndexPresent) {
2115              tfhdOffset += 4;
2116            }
2117            if (defaultSampleDurationPresent) {
2118              defaultSampleDuration = readUint32(tfhd, tfhdOffset);
2119              tfhdOffset += 4;
2120            }
2121            if (defaultSampleSizePresent) {
2122              defaultSampleSize = readUint32(tfhd, tfhdOffset);
2123              tfhdOffset += 4;
2124            }
2125            if (defaultSampleFlagsPresent) {
2126              tfhdOffset += 4;
2127            }
2128            if (track.type === 'video') {
2129              isHEVCFlavor = isHEVC(track.codec);
2130            }
2131            findBox(traf, ['trun']).map(function (trun) {
2132              var version = trun[0];
2133              var flags = readUint32(trun, 0) & 0xffffff;
2134              var dataOffsetPresent = (flags & 0x000001) !== 0;
2135              var dataOffset = 0;
2136              var firstSampleFlagsPresent = (flags & 0x000004) !== 0;
2137              var sampleDurationPresent = (flags & 0x000100) !== 0;
2138              var sampleDuration = 0;
2139              var sampleSizePresent = (flags & 0x000200) !== 0;
2140              var sampleSize = 0;
2141              var sampleFlagsPresent = (flags & 0x000400) !== 0;
2142              var sampleCompositionOffsetsPresent = (flags & 0x000800) !== 0;
2143              var compositionOffset = 0;
2144              var sampleCount = readUint32(trun, 4);
2145              var trunOffset = 8; // past version, flags, and sample count
2146
2147              if (dataOffsetPresent) {
2148                dataOffset = readUint32(trun, trunOffset);
2149                trunOffset += 4;
2150              }
2151              if (firstSampleFlagsPresent) {
2152                trunOffset += 4;
2153              }
2154              var sampleOffset = dataOffset + moofOffset;
2155              for (var ix = 0;

2155 ix < sampleCount; ix++) {
2156                if (sampleDurationPresent) {
2157                  sampleDuration = readUint32(trun, trunOffset);
2158                  trunOffset += 4;
2159                } else {
2160                  sampleDuration = defaultSampleDuration;
2161                }
2162                if (sampleSizePresent) {
2163                  sampleSize = readUint32(trun, trunOffset);
2164                  trunOffset += 4;
2165                } else {
2166                  sampleSize = defaultSampleSize;
2167                }
2168                if (sampleFlagsPresent) {
2169                  trunOffset += 4;
2170                }
2171                if (sampleCompositionOffsetsPresent) {
2172                  if (version === 0) {
2173                    compositionOffset = readUint32(trun, trunOffset);
2174                  } else {
2175                    compositionOffset = readSint32(trun, trunOffset);
2176                  }
2177                  trunOffset += 4;
2178                }
2179                if (track.type === ElementaryStreamTypes.VIDEO) {
2180                  var naluTotalSize = 0;
2181                  while (naluTotalSize < sampleSize) {
2182                    var naluSize = readUint32(videoData, sampleOffset);
2183                    sampleOffset += 4;
2184                    if (isSEIMessage(isHEVCFlavor, videoData[sampleOffset])) {
2185                      var data = videoData.subarray(sampleOffset, sampleOffset + naluSize);
2186                      parseSEIMessageFromNALu(data, isHEVCFlavor ? 2 : 1, timeOffset + compositionOffset / timescale, seiSamples);
2187                    }
2188                    sampleOffset += naluSize;
2189                    naluTotalSize += naluSize + 4;
2190                  }
2191                }
2192                timeOffset += sampleDuration / timescale;
2193              }
2194            });
2195          }
2196        });
2197      });
2198    });
2199    return seiSamples;
2200  }
2201  function isHEVC(codec) {
2202    if (!codec) {
2203      return false;
2204    }
2205    var delimit = codec.indexOf('.');
2206    var baseCodec = delimit < 0 ? codec : codec.substring(0, delimit);
2207    return baseCodec === 'hvc1' || baseCodec === 'hev1' ||
2208    // Dolby Vision
2209    baseCodec === 'dvh1' || baseCodec === 'dvhe';
2210  }
2211  function isSEIMessage(isHEVCFlavor, naluHeader) {
2212    if (isHEVCFlavor) {
2213      var naluType = naluHeader >> 1 & 0x3f;
2214      return naluType === 39 || naluType === 40;
2215    } else {
2216      var _naluType = naluHeader & 0x1f;
2217      return _naluType === 6;
2218    }
2219  }
2220  function parseSEIMessageFromNALu(unescapedData, headerSize, pts, samples) {
2221    var data = discardEPB(unescapedData);
2222    var seiPtr = 0;
2223    // skip nal header
2224    seiPtr += headerSize;
2225    var payloadType = 0;
2226    var payloadSize = 0;
2227    var b = 0;
2228    while (seiPtr < data.length) {
2229      payloadType = 0;
2230      do {
2231        if (seiPtr >= data.length) {
2232          break;
2233        }
2234        b = data[seiPtr++];
2235        payloadType += b;
2236      } while (b === 0xff);
2237
2238      // Parse payload size.
2239      payloadSize = 0;
2240      do {
2241        if (seiPtr >= data.length) {
2242          break;
2243        }
2244        b = data[seiPtr++];
2245        payloadSize += b;
2246      } while (b === 0xff);
2247      var leftOver = data.length - seiPtr;
2248      // Create a variable to process the payload
2249      var payPtr = seiPtr;
2250
2251      // Increment the seiPtr to the end of the payload
2252      if (payloadSize < leftOver) {
2253        seiPtr += payloadSize;
2254      } else if (payloadSize > leftOver) {
2255        // Some type of corruption has happened?
2256        logger.error("Malformed SEI payload. " + payloadSize + " is too small, only " + leftOver + " bytes left to parse.");
2257        // We might be able to parse some data, but let's be safe and ignore it.
2258        break;
2259      }
2260      if (payloadType === 4) {
2261        var countryCode = data[payPtr++];
2262        if (countryCode === 181) {
2263          var providerCode = readUint16(data, payPtr);
2264          payPtr += 2;
2265          if (providerCode === 49) {
2266            var userStructure = readUint32(data, payPtr);
2267            payPtr += 4;
2268            if (userStructure === 0x47413934) {
2269              var userDataType = data[payPtr++];
2270
2271              // Raw CEA-608 bytes wrapped in CEA-708 packet
2272              if (userDataType === 3) {
2273                var firstByte = data[payPtr++];
2274                var totalCCs = 0x1f & firstByte;
2275                var enabled = 0x40 & firstByte;
2276                var totalBytes = enabled ? 2 + totalCCs * 3 : 0;
2277                var byteArray = new Uint8Array(totalBytes);
2278                if (enabled) {
2279                  byteArray[0] = firstByte;
2280                  for (var i = 1; i < totalBytes; i++) {
2281                    byteArray[i] = data[payPtr++];
2282                  }
2283                }
2284                samples.push({
2285                  type: userDataType,
2286                  payloadType: payloadType,
2287                  pts: pts,
2288                  bytes: byteArray
2289                });
2290              }
2291            }
2292          }
2293        }
2294      } else if (payloadType === 5) {
2295        if (payloadSize > 16) {
2296          var uuidStrArray = [];
2297          for (var _i3 = 0; _i3 < 16; _i3++) {
2298            var _b = data[payPtr++].toString(16);
2299            uuidStrArray.push(_b.length == 1 ? '0' + _b : _b);
2300            if (_i3 === 3 || _i3 === 5 || _i3 === 7 || _i3 === 9) {
2301              uuidStrArray.push('-');
2302            }
2303          }
2304          var length = payloadSize - 16;
2305          var userDataBytes = new Uint8Array(length);
2306          for (var _i4 = 0; _i4 < length; _i4++) {
2307            userDataBytes[_i4] = data[payPtr++];
2308          }
2309          samples.push({
2310            payloadType: payloadType,
2311            pts: pts,
2312            uuid: uuidStrArray.join(''),
2313            userData: utf8ArrayToStr(userDataBytes),
2314            userDataBytes: userDataBytes
2315          });
2316        }
2317      }
2318    }
2319  }
2320
2321  /**
2322   * remove Emulation Prevention bytes from a RBSP
2323   */
2324  function discardEPB(data) {
2325    var length = data.byteLength;
2326    var EPBPositions = [];
2327    var i = 1;
2328
2329    // Find all `Emulation Prevention Bytes`
2330    while (i < length - 2) {
2331      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
2332        EPBPositions.push(i + 2);
2333        i += 2;
2334      } else {
2335        i++;
2336      }
2337    }
2338
2339    // If no Emulation Prevention Bytes were found just return the original
2340    // array
2341    if (EPBPositions.length === 0) {
2342      return data;
2343    }
2344
2345    // Create a new array to hold the NAL unit data
2346    var newLength = length - EPBPositions.length;
2347    var newData = new Uint8Array(newLength);
2348    var sourceIndex = 0;
2349    for (i = 0; i < newLength; sourceIndex++, i++) {
2350      if (sourceIndex === EPBPositions[0]) {
2351        // Skip this byte
2352        sourceIndex++;
2353        // Remove this position index
2354        EPBPositions.shift();
2355      }
2356      newData[i] = data[sourceIndex];
2357    }
2358    return newData;
2359  }
2360  function parseEmsg(data) {
2361    var version = data[0];
2362    var schemeIdUri = '';
2363    var value = '';
2364    var timeScale = 0;
2365    var presentationTimeDelta = 0;
2366    var presentationTime = 0;
2367    var eventDuration = 0;
2368    var id = 0;
2369    var offset = 0;
2370    if (version === 0) {
2371      while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2372        schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2373        offset += 1;
2374      }
2375      schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2376      offset += 1;
2377      while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2378        value += bin2str(data.subarray(offset, offset + 1));
2379        offset += 1;
2380      }
2381      value += bin2str(data.subarray(offset, offset + 1));
2382      offset += 1;
2383      timeScale = readUint32(data, 12);
2384      presentationTimeDelta = readUint32(data, 16);
2385      eventDuration = readUint32(data, 20);
2386      id = readUint32(data, 24);
2387      offset = 28;
2388    } else if (version === 1) {
2389      offset += 4;
2390      timeScale = readUint32(data, offset);
2391      offset += 4;
2392      var leftPresentationTime = readUint32(data, offset);
2393      offset += 4;
2394      var rightPresentationTime = readUint32(data, offset);
2395      offset += 4;
2396      presentationTime = Math.pow(2, 32) * leftPresentationTime + rightPresentationTime;
2397      if (!isSafeInteger(presentationTime)) {
2398        presentationTime = Number.MAX_SAFE_INTEGER;
2399        logger.warn('Presentation time exceeds safe integer limit and wrapped to max safe integer in parsing emsg box');
2400      }
2401      eventDuration = readUint32(data, offset);
2402      offset += 4;
2403      id = readUint32(data, offset);
2404      offset += 4;
2405      while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2406        schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2407        offset += 1;
2408      }
2409      schemeIdUri += bin2str(data.subarray(offset, offset + 1));
2410      offset += 1;
2411      while (bin2str(data.subarray(offset, offset + 1)) !== '\0') {
2412        value += bin2str(data.subarray(offset, offset + 1));
2413        offset += 1;
2414      }
2415      value += bin2str(data.subarray(offset, offset + 1));
2416      offset += 1;
2417    }
2418    var payload = data.subarray(offset, data.byteLength);
2419    return {
2420      schemeIdUri: schemeIdUri,
2421      value: value,
2422      timeScale: timeScale,
2423      presentationTime: presentationTime,
2424      presentationTimeDelta: presentationTimeDelta,
2425      eventDuration: eventDuration,
2426      id: id,
2427      payload: payload
2428    };
2429  }
2430
2431  var LevelKey = /*#__PURE__*/function () {
2432    function LevelKey(method, uri, format, formatversions, iv) {
2433      if (formatversions === void 0) {
2434        formatversions = [1];
2435      }
2436      if (iv === void 0) {
2437        iv = null;
2438      }
2439      this.uri = void 0;
2440      this.method = void 0;
2441      this.keyFormat = void 0;
2442      this.keyFormatVersions = void 0;
2443      this.encrypted = void 0;
2444      this.isCommonEncryption = void 0;
2445      this.iv = null;
2446      this.key = null;
2447      this.keyId = null;