@srgssr/pillarbox-web 1.21.1 → 1.22.0

package/dist/pillarbox.umd.js

@@ -4,6 +4,39 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Pillarbox = factory());
 })(this, (function () { 'use strict';
 
+  function asyncGeneratorStep(n, t, e, r, o, a, c) {
+    try {
+      var i = n[a](c),
+        u = i.value;
+    } catch (n) {
+      return void e(n);
+    }
+    i.done ? t(u) : Promise.resolve(u).then(r, o);
+  }
+  function _asyncToGenerator(n) {
+    return function () {
+      var t = this,
+        e = arguments;
+      return new Promise(function (r, o) {
+        var a = n.apply(t, e);
+        function _next(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+        }
+        function _throw(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+        }
+        _next(void 0);
+      });
+    };
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
   function ownKeys(e, r) {
     var t = Object.keys(e);
     if (Object.getOwnPropertySymbols) {
@@ -17,7 +50,7 @@
   function _objectSpread2(e) {
     for (var r = 1; r < arguments.length; r++) {
       var t = null != arguments[r] ? arguments[r] : {};
-      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
         _defineProperty(e, r, t[r]);
       }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
         Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
@@ -25,11 +58,31 @@
     }
     return e;
   }
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o,
+      r,
+      i = _objectWithoutPropertiesLoose(e, t);
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    }
+    return i;
+  }
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (-1 !== e.indexOf(n)) continue;
+      t[n] = r[n];
+    }
+    return t;
+  }
   function _toPrimitive(t, r) {
     if ("object" != typeof t || !t) return t;
     var e = t[Symbol.toPrimitive];
     if (void 0 !== e) {
-      var i = e.call(t, r || "default");
+      var i = e.call(t, r);
       if ("object" != typeof i) return i;
       throw new TypeError("@@toPrimitive must return a primitive value.");
     }
@@ -39,78 +92,8 @@
     var i = _toPrimitive(t, "string");
     return "symbol" == typeof i ? i : i + "";
   }
-  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-      var info = gen[key](arg);
-      var value = info.value;
-    } catch (error) {
-      reject(error);
-      return;
-    }
-    if (info.done) {
-      resolve(value);
-    } else {
-      Promise.resolve(value).then(_next, _throw);
-    }
-  }
-  function _asyncToGenerator(fn) {
-    return function () {
-      var self = this,
-        args = arguments;
-      return new Promise(function (resolve, reject) {
-        var gen = fn.apply(self, args);
-        function _next(value) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-        }
-        function _throw(err) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-        }
-        _next(undefined);
-      });
-    };
-  }
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    for (var key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-      }
-    }
-    return target;
-  }
-  function _objectWithoutProperties(source, excluded) {
-    if (source == null) return {};
-    var target = _objectWithoutPropertiesLoose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-      for (i = 0; i < sourceSymbolKeys.length; i++) {
-        key = sourceSymbolKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-      }
-    }
-    return target;
-  }
 
-  const version$8 = "1.21.0";
+  const version$8 = "1.21.2";
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -191,23 +174,18 @@
   var lib = {exports: {}};
 
   function _extends$2() {
-    _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
+    return _extends$2 = Object.assign ? Object.assign.bind() : function (n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
       }
-      return target;
-    };
-    return _extends$2.apply(this, arguments);
+      return n;
+    }, _extends$2.apply(null, arguments);
   }
 
   const _extends$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
-    default: _extends$2
+    get default () { return _extends$2; }
   }, Symbol.toStringTag, { value: 'Module' }));
 
   const require$$1 = /*@__PURE__*/getAugmentedNamespace(_extends$3);
@@ -10543,11 +10521,9 @@
 
   var errors = {
     INVALID_NUMBER_OF_PERIOD: 'INVALID_NUMBER_OF_PERIOD',
-    INVALID_NUMBER_OF_CONTENT_STEERING: 'INVALID_NUMBER_OF_CONTENT_STEERING',
     DASH_EMPTY_MANIFEST: 'DASH_EMPTY_MANIFEST',
     DASH_INVALID_XML: 'DASH_INVALID_XML',
     NO_BASE_URL: 'NO_BASE_URL',
-    MISSING_SEGMENT_INFORMATION: 'MISSING_SEGMENT_INFORMATION',
     SEGMENT_TIME_UNSPECIFIED: 'SEGMENT_TIME_UNSPECIFIED',
     UNSUPPORTED_UTC_TIMING_SCHEME: 'UNSUPPORTED_UTC_TIMING_SCHEME'
   };
@@ -13210,9 +13186,7 @@
   };
 
   var numbers = {
-    getUint64: getUint64$1,
-    MAX_UINT32: MAX_UINT32
-  };
+    getUint64: getUint64$1};
 
   var getUint64 = numbers.getUint64;
 
@@ -13888,58 +13862,8 @@
    * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
    */
 
-  var
-    ONE_SECOND_IN_TS = 90000, // 90kHz clock
-    secondsToVideoTs,
-    secondsToAudioTs,
-    videoTsToSeconds,
-    audioTsToSeconds,
-    audioTsToVideoTs,
-    videoTsToAudioTs,
-    metadataTsToSeconds;
-
-  secondsToVideoTs = function(seconds) {
-    return seconds * ONE_SECOND_IN_TS;
-  };
-
-  secondsToAudioTs = function(seconds, sampleRate) {
-    return seconds * sampleRate;
-  };
-
-  videoTsToSeconds = function(timestamp) {
-    return timestamp / ONE_SECOND_IN_TS;
-  };
-
-  audioTsToSeconds = function(timestamp, sampleRate) {
-    return timestamp / sampleRate;
-  };
-
-  audioTsToVideoTs = function(timestamp, sampleRate) {
-    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));
-  };
-
-  videoTsToAudioTs = function(timestamp, sampleRate) {
-    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);
-  };
-
-  /**
-   * Adjust ID3 tag or caption timing information by the timeline pts values
-   * (if keepOriginalTimestamps is false) and convert to seconds
-   */
-  metadataTsToSeconds = function(timestamp, timelineStartPts, keepOriginalTimestamps) {
-    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);
-  };
-
   var clock = {
-    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS,
-    secondsToVideoTs: secondsToVideoTs,
-    secondsToAudioTs: secondsToAudioTs,
-    videoTsToSeconds: videoTsToSeconds,
-    audioTsToSeconds: audioTsToSeconds,
-    audioTsToVideoTs: audioTsToVideoTs,
-    videoTsToAudioTs: videoTsToAudioTs,
-    metadataTsToSeconds: metadataTsToSeconds
-  };
+    };
 
   /**
    * @license
@@ -49861,11 +49785,6 @@
       // Frames that allow different types of text encoding contain a text
       // encoding description byte [ID3v2.4.0 section 4.]
       textEncodingDescriptionByte = {
-        Iso88591: 0x00,
-        // ISO-8859-1, terminated with \0.
-        Utf16: 0x01,
-        // UTF-16 encoded Unicode BOM, terminated with \0\0
-        Utf16be: 0x02,
         // UTF-16BE encoded Unicode, without BOM, terminated with \0\0
         Utf8: 0x03 // UTF-8 encoded Unicode, terminated with \0
       },
@@ -51484,9 +51403,7 @@
     };
     H264Stream$1.prototype = new Stream$2();
     var h264 = {
-      H264Stream: H264Stream$1,
-      NalByteStream: NalByteStream
-    };
+      H264Stream: H264Stream$1};
     /**
      * mux.js
      *
@@ -52120,8 +52037,6 @@
 
       this.getGopForFusion_ = function (nalUnit) {
         var halfSecond = 45000,
-          // Half-a-second in a 90khz clock
-          allowableOverlap = 10000,
           // About 3 frames @ 30fps
           nearestDistance = Infinity,
           dtsDistance,
@@ -52145,7 +52060,7 @@
           dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration; // Only consider GOPS that start before the nal unit and end within
           // a half-second of the nal unit
 
-          if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {
+          if (dtsDistance >= -1e4 && dtsDistance <= halfSecond) {
             // Always use the closest GOP we found if there is more than
             // one candidate
             if (!nearestGopObj || nearestDistance > dtsDistance) {
@@ -52702,14 +52617,7 @@
     };
     Transmuxer.prototype = new Stream();
     var transmuxer = {
-      Transmuxer: Transmuxer,
-      VideoSegmentStream: VideoSegmentStream,
-      AudioSegmentStream: AudioSegmentStream,
-      AUDIO_PROPERTIES: AUDIO_PROPERTIES,
-      VIDEO_PROPERTIES: VIDEO_PROPERTIES,
-      // exported for testing
-      generateSegmentTimingInfo: generateSegmentTimingInfo
-    };
+      Transmuxer: Transmuxer};
     /**
      * mux.js
      *
@@ -52834,45 +52742,6 @@
       return result;
     };
     var parseTfhd$2 = tfhd;
-    var getUint64$3 = numbers.getUint64;
-    var parseSidx = function (data) {
-      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-        result = {
-          version: data[0],
-          flags: new Uint8Array(data.subarray(1, 4)),
-          references: [],
-          referenceId: view.getUint32(4),
-          timescale: view.getUint32(8)
-        },
-        i = 12;
-      if (result.version === 0) {
-        result.earliestPresentationTime = view.getUint32(i);
-        result.firstOffset = view.getUint32(i + 4);
-        i += 8;
-      } else {
-        // read 64 bits
-        result.earliestPresentationTime = getUint64$3(data.subarray(i));
-        result.firstOffset = getUint64$3(data.subarray(i + 8));
-        i += 16;
-      }
-      i += 2; // reserved
-
-      var referenceCount = view.getUint16(i);
-      i += 2; // start of references
-
-      for (; referenceCount > 0; i += 12, referenceCount--) {
-        result.references.push({
-          referenceType: (data[i] & 0x80) >>> 7,
-          referencedSize: view.getUint32(i) & 0x7FFFFFFF,
-          subsegmentDuration: view.getUint32(i + 4),
-          startsWithSap: !!(data[i + 8] & 0x80),
-          sapType: (data[i + 8] & 0x70) >>> 4,
-          sapDeltaTime: view.getUint32(i + 8) & 0x0FFFFFFF
-        });
-      }
-      return result;
-    };
-    var parseSidx_1 = parseSidx;
     var parseSampleFlags$1 = function (flags) {
       return {
         isLeading: (flags[0] & 0x0c) >>> 2,
@@ -52967,707 +52836,13 @@
       return result;
     };
     var parseTrun$2 = trun;
-    /**
-     * mux.js
-     *
-     * Copyright (c) Brightcove
-     * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE
-     *
-     * Parse the internal MP4 structure into an equivalent javascript
-     * object.
-     */
-
-    var numberHelpers = numbers;
-    var getUint64$2 = numberHelpers.getUint64;
-    var inspectMp4,
-      textifyMp4,
-      parseMp4Date = function (seconds) {
-        return new Date(seconds * 1000 - 2082844800000);
-      },
-      parseType$2 = parseType_1,
-      findBox$4 = findBox_1,
-      nalParse = function (avcStream) {
-        var avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),
-          result = [],
-          i,
-          length;
-        for (i = 0; i + 4 < avcStream.length; i += length) {
-          length = avcView.getUint32(i);
-          i += 4; // bail if this doesn't appear to be an H264 stream
-
-          if (length <= 0) {
-            result.push('<span style=\'color:red;\'>MALFORMED DATA</span>');
-            continue;
-          }
-          switch (avcStream[i] & 0x1F) {
-            case 0x01:
-              result.push('slice_layer_without_partitioning_rbsp');
-              break;
-            case 0x05:
-              result.push('slice_layer_without_partitioning_rbsp_idr');
-              break;
-            case 0x06:
-              result.push('sei_rbsp');
-              break;
-            case 0x07:
-              result.push('seq_parameter_set_rbsp');
-              break;
-            case 0x08:
-              result.push('pic_parameter_set_rbsp');
-              break;
-            case 0x09:
-              result.push('access_unit_delimiter_rbsp');
-              break;
-            default:
-              result.push('UNKNOWN NAL - ' + avcStream[i] & 0x1F);
-              break;
-          }
-        }
-        return result;
-      },
-      // registry of handlers for individual mp4 box types
+    var // registry of handlers for individual mp4 box types
       parse = {
-        // codingname, not a first-class box type. stsd entries share the
-        // same format as real boxes so the parsing infrastructure can be
-        // shared
-        avc1: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-          return {
-            dataReferenceIndex: view.getUint16(6),
-            width: view.getUint16(24),
-            height: view.getUint16(26),
-            horizresolution: view.getUint16(28) + view.getUint16(30) / 16,
-            vertresolution: view.getUint16(32) + view.getUint16(34) / 16,
-            frameCount: view.getUint16(40),
-            depth: view.getUint16(74),
-            config: inspectMp4(data.subarray(78, data.byteLength))
-          };
-        },
-        avcC: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              configurationVersion: data[0],
-              avcProfileIndication: data[1],
-              profileCompatibility: data[2],
-              avcLevelIndication: data[3],
-              lengthSizeMinusOne: data[4] & 0x03,
-              sps: [],
-              pps: []
-            },
-            numOfSequenceParameterSets = data[5] & 0x1f,
-            numOfPictureParameterSets,
-            nalSize,
-            offset,
-            i; // iterate past any SPSs
-
-          offset = 6;
-          for (i = 0; i < numOfSequenceParameterSets; i++) {
-            nalSize = view.getUint16(offset);
-            offset += 2;
-            result.sps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));
-            offset += nalSize;
-          } // iterate past any PPSs
-
-          numOfPictureParameterSets = data[offset];
-          offset++;
-          for (i = 0; i < numOfPictureParameterSets; i++) {
-            nalSize = view.getUint16(offset);
-            offset += 2;
-            result.pps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));
-            offset += nalSize;
-          }
-          return result;
-        },
-        btrt: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-          return {
-            bufferSizeDB: view.getUint32(0),
-            maxBitrate: view.getUint32(4),
-            avgBitrate: view.getUint32(8)
-          };
-        },
-        edts: function edts(data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        elst: function elst(data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4)),
-              edits: []
-            },
-            entryCount = view.getUint32(4),
-            i;
-          for (i = 8; entryCount; entryCount--) {
-            if (result.version === 0) {
-              result.edits.push({
-                segmentDuration: view.getUint32(i),
-                mediaTime: view.getInt32(i + 4),
-                mediaRate: view.getUint16(i + 8) + view.getUint16(i + 10) / (256 * 256)
-              });
-              i += 12;
-            } else {
-              result.edits.push({
-                segmentDuration: getUint64$2(data.subarray(i)),
-                mediaTime: getUint64$2(data.subarray(i + 8)),
-                mediaRate: view.getUint16(i + 16) + view.getUint16(i + 18) / (256 * 256)
-              });
-              i += 20;
-            }
-          }
-          return result;
-        },
-        esds: function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            esId: data[6] << 8 | data[7],
-            streamPriority: data[8] & 0x1f,
-            decoderConfig: {
-              objectProfileIndication: data[11],
-              streamType: data[12] >>> 2 & 0x3f,
-              bufferSize: data[13] << 16 | data[14] << 8 | data[15],
-              maxBitrate: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],
-              avgBitrate: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23],
-              decoderConfigDescriptor: {
-                tag: data[24],
-                length: data[25],
-                audioObjectType: data[26] >>> 3 & 0x1f,
-                samplingFrequencyIndex: (data[26] & 0x07) << 1 | data[27] >>> 7 & 0x01,
-                channelConfiguration: data[27] >>> 3 & 0x0f
-              }
-            }
-          };
-        },
-        ftyp: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              majorBrand: parseType$2(data.subarray(0, 4)),
-              minorVersion: view.getUint32(4),
-              compatibleBrands: []
-            },
-            i = 8;
-          while (i < data.byteLength) {
-            result.compatibleBrands.push(parseType$2(data.subarray(i, i + 4)));
-            i += 4;
-          }
-          return result;
-        },
-        dinf: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        dref: function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            dataReferences: inspectMp4(data.subarray(8))
-          };
-        },
-        hdlr: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4)),
-              handlerType: parseType$2(data.subarray(8, 12)),
-              name: ''
-            },
-            i = 8; // parse out the name field
-
-          for (i = 24; i < data.byteLength; i++) {
-            if (data[i] === 0x00) {
-              // the name field is null-terminated
-              i++;
-              break;
-            }
-            result.name += String.fromCharCode(data[i]);
-          } // decode UTF-8 to javascript's internal representation
-          // see http://ecmanaut.blogspot.com/2006/07/encoding-decoding-utf8-in-javascript.html
-
-          result.name = decodeURIComponent(escape(result.name));
-          return result;
-        },
-        mdat: function (data) {
-          return {
-            byteLength: data.byteLength,
-            nals: nalParse(data)
-          };
-        },
-        mdhd: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            i = 4,
-            language,
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4)),
-              language: ''
-            };
-          if (result.version === 1) {
-            i += 4;
-            result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 8;
-            result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 4;
-            result.timescale = view.getUint32(i);
-            i += 8;
-            result.duration = view.getUint32(i); // truncating top 4 bytes
-          } else {
-            result.creationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.modificationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.timescale = view.getUint32(i);
-            i += 4;
-            result.duration = view.getUint32(i);
-          }
-          i += 4; // language is stored as an ISO-639-2/T code in an array of three 5-bit fields
-          // each field is the packed difference between its ASCII value and 0x60
-
-          language = view.getUint16(i);
-          result.language += String.fromCharCode((language >> 10) + 0x60);
-          result.language += String.fromCharCode(((language & 0x03e0) >> 5) + 0x60);
-          result.language += String.fromCharCode((language & 0x1f) + 0x60);
-          return result;
-        },
-        mdia: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        mfhd: function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            sequenceNumber: data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]
-          };
-        },
-        minf: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        // codingname, not a first-class box type. stsd entries share the
-        // same format as real boxes so the parsing infrastructure can be
-        // shared
-        mp4a: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              // 6 bytes reserved
-              dataReferenceIndex: view.getUint16(6),
-              // 4 + 4 bytes reserved
-              channelcount: view.getUint16(16),
-              samplesize: view.getUint16(18),
-              // 2 bytes pre_defined
-              // 2 bytes reserved
-              samplerate: view.getUint16(24) + view.getUint16(26) / 65536
-            }; // if there are more bytes to process, assume this is an ISO/IEC
-          // 14496-14 MP4AudioSampleEntry and parse the ESDBox
-
-          if (data.byteLength > 28) {
-            result.streamDescriptor = inspectMp4(data.subarray(28))[0];
-          }
-          return result;
-        },
-        moof: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        moov: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        mvex: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        mvhd: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            i = 4,
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4))
-            };
-          if (result.version === 1) {
-            i += 4;
-            result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 8;
-            result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 4;
-            result.timescale = view.getUint32(i);
-            i += 8;
-            result.duration = view.getUint32(i); // truncating top 4 bytes
-          } else {
-            result.creationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.modificationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.timescale = view.getUint32(i);
-            i += 4;
-            result.duration = view.getUint32(i);
-          }
-          i += 4; // convert fixed-point, base 16 back to a number
-
-          result.rate = view.getUint16(i) + view.getUint16(i + 2) / 16;
-          i += 4;
-          result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;
-          i += 2;
-          i += 2;
-          i += 2 * 4;
-          result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));
-          i += 9 * 4;
-          i += 6 * 4;
-          result.nextTrackId = view.getUint32(i);
-          return result;
-        },
-        pdin: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-          return {
-            version: view.getUint8(0),
-            flags: new Uint8Array(data.subarray(1, 4)),
-            rate: view.getUint32(4),
-            initialDelay: view.getUint32(8)
-          };
-        },
-        sdtp: function (data) {
-          var result = {
-              version: data[0],
-              flags: new Uint8Array(data.subarray(1, 4)),
-              samples: []
-            },
-            i;
-          for (i = 4; i < data.byteLength; i++) {
-            result.samples.push({
-              dependsOn: (data[i] & 0x30) >> 4,
-              isDependedOn: (data[i] & 0x0c) >> 2,
-              hasRedundancy: data[i] & 0x03
-            });
-          }
-          return result;
-        },
-        sidx: parseSidx_1,
-        smhd: function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            balance: data[4] + data[5] / 256
-          };
-        },
-        stbl: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        ctts: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4)),
-              compositionOffsets: []
-            },
-            entryCount = view.getUint32(4),
-            i;
-          for (i = 8; entryCount; i += 8, entryCount--) {
-            result.compositionOffsets.push({
-              sampleCount: view.getUint32(i),
-              sampleOffset: view[result.version === 0 ? 'getUint32' : 'getInt32'](i + 4)
-            });
-          }
-          return result;
-        },
-        stss: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4)),
-              syncSamples: []
-            },
-            entryCount = view.getUint32(4),
-            i;
-          for (i = 8; entryCount; i += 4, entryCount--) {
-            result.syncSamples.push(view.getUint32(i));
-          }
-          return result;
-        },
-        stco: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: data[0],
-              flags: new Uint8Array(data.subarray(1, 4)),
-              chunkOffsets: []
-            },
-            entryCount = view.getUint32(4),
-            i;
-          for (i = 8; entryCount; i += 4, entryCount--) {
-            result.chunkOffsets.push(view.getUint32(i));
-          }
-          return result;
-        },
-        stsc: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            entryCount = view.getUint32(4),
-            result = {
-              version: data[0],
-              flags: new Uint8Array(data.subarray(1, 4)),
-              sampleToChunks: []
-            },
-            i;
-          for (i = 8; entryCount; i += 12, entryCount--) {
-            result.sampleToChunks.push({
-              firstChunk: view.getUint32(i),
-              samplesPerChunk: view.getUint32(i + 4),
-              sampleDescriptionIndex: view.getUint32(i + 8)
-            });
-          }
-          return result;
-        },
-        stsd: function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            sampleDescriptions: inspectMp4(data.subarray(8))
-          };
-        },
-        stsz: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: data[0],
-              flags: new Uint8Array(data.subarray(1, 4)),
-              sampleSize: view.getUint32(4),
-              entries: []
-            },
-            i;
-          for (i = 12; i < data.byteLength; i += 4) {
-            result.entries.push(view.getUint32(i));
-          }
-          return result;
-        },
-        stts: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            result = {
-              version: data[0],
-              flags: new Uint8Array(data.subarray(1, 4)),
-              timeToSamples: []
-            },
-            entryCount = view.getUint32(4),
-            i;
-          for (i = 8; entryCount; i += 8, entryCount--) {
-            result.timeToSamples.push({
-              sampleCount: view.getUint32(i),
-              sampleDelta: view.getUint32(i + 4)
-            });
-          }
-          return result;
-        },
-        styp: function (data) {
-          return parse.ftyp(data);
-        },
         tfdt: parseTfdt$3,
-        tfhd: parseTfhd$2,
-        tkhd: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
-            i = 4,
-            result = {
-              version: view.getUint8(0),
-              flags: new Uint8Array(data.subarray(1, 4))
-            };
-          if (result.version === 1) {
-            i += 4;
-            result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 8;
-            result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes
-
-            i += 4;
-            result.trackId = view.getUint32(i);
-            i += 4;
-            i += 8;
-            result.duration = view.getUint32(i); // truncating top 4 bytes
-          } else {
-            result.creationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.modificationTime = parseMp4Date(view.getUint32(i));
-            i += 4;
-            result.trackId = view.getUint32(i);
-            i += 4;
-            i += 4;
-            result.duration = view.getUint32(i);
-          }
-          i += 4;
-          i += 2 * 4;
-          result.layer = view.getUint16(i);
-          i += 2;
-          result.alternateGroup = view.getUint16(i);
-          i += 2; // convert fixed-point, base 16 back to a number
-
-          result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;
-          i += 2;
-          i += 2;
-          result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));
-          i += 9 * 4;
-          result.width = view.getUint16(i) + view.getUint16(i + 2) / 65536;
-          i += 4;
-          result.height = view.getUint16(i) + view.getUint16(i + 2) / 65536;
-          return result;
-        },
-        traf: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        trak: function (data) {
-          return {
-            boxes: inspectMp4(data)
-          };
-        },
-        trex: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            trackId: view.getUint32(4),
-            defaultSampleDescriptionIndex: view.getUint32(8),
-            defaultSampleDuration: view.getUint32(12),
-            defaultSampleSize: view.getUint32(16),
-            sampleDependsOn: data[20] & 0x03,
-            sampleIsDependedOn: (data[21] & 0xc0) >> 6,
-            sampleHasRedundancy: (data[21] & 0x30) >> 4,
-            samplePaddingValue: (data[21] & 0x0e) >> 1,
-            sampleIsDifferenceSample: !!(data[21] & 0x01),
-            sampleDegradationPriority: view.getUint16(22)
-          };
-        },
-        trun: parseTrun$2,
-        'url ': function (data) {
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4))
-          };
-        },
-        vmhd: function (data) {
-          var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-          return {
-            version: data[0],
-            flags: new Uint8Array(data.subarray(1, 4)),
-            graphicsmode: view.getUint16(4),
-            opcolor: new Uint16Array([view.getUint16(6), view.getUint16(8), view.getUint16(10)])
-          };
-        }
-      };
-    /**
-     * Return a javascript array of box objects parsed from an ISO base
-     * media file.
-     * @param data {Uint8Array} the binary data of the media to be inspected
-     * @return {array} a javascript array of potentially nested box objects
-     */
-
-    inspectMp4 = function (data) {
-      var i = 0,
-        result = [],
-        view,
-        size,
-        type,
-        end,
-        box; // Convert data from Uint8Array to ArrayBuffer, to follow Dataview API
-
-      var ab = new ArrayBuffer(data.length);
-      var v = new Uint8Array(ab);
-      for (var z = 0; z < data.length; ++z) {
-        v[z] = data[z];
-      }
-      view = new DataView(ab);
-      while (i < data.byteLength) {
-        // parse box data
-        size = view.getUint32(i);
-        type = parseType$2(data.subarray(i + 4, i + 8));
-        end = size > 1 ? i + size : data.byteLength; // parse type-specific data
-
-        box = (parse[type] || function (data) {
-          return {
-            data: data
-          };
-        })(data.subarray(i + 8, end));
-        box.size = size;
-        box.type = type; // store this box and move to the next
-
-        result.push(box);
-        i = end;
-      }
-      return result;
-    };
-    /**
-     * Returns a textual representation of the javascript represtentation
-     * of an MP4 file. You can use it as an alternative to
-     * JSON.stringify() to compare inspected MP4s.
-     * @param inspectedMp4 {array} the parsed array of boxes in an MP4
-     * file
-     * @param depth {number} (optional) the number of ancestor boxes of
-     * the elements of inspectedMp4. Assumed to be zero if unspecified.
-     * @return {string} a text representation of the parsed MP4
-     */
-
-    textifyMp4 = function (inspectedMp4, depth) {
-      var indent;
-      depth = depth || 0;
-      indent = new Array(depth * 2 + 1).join(' '); // iterate over all the boxes
-
-      return inspectedMp4.map(function (box, index) {
-        // list the box type first at the current indentation level
-        return indent + box.type + '\n' +
-        // the type is already included and handle child boxes separately
-        Object.keys(box).filter(function (key) {
-          return key !== 'type' && key !== 'boxes'; // output all the box properties
-        }).map(function (key) {
-          var prefix = indent + '  ' + key + ': ',
-            value = box[key]; // print out raw bytes as hexademical
-
-          if (value instanceof Uint8Array || value instanceof Uint32Array) {
-            var bytes = Array.prototype.slice.call(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)).map(function (byte) {
-              return ' ' + ('00' + byte.toString(16)).slice(-2);
-            }).join('').match(/.{1,24}/g);
-            if (!bytes) {
-              return prefix + '<>';
-            }
-            if (bytes.length === 1) {
-              return prefix + '<' + bytes.join('').slice(1) + '>';
-            }
-            return prefix + '<\n' + bytes.map(function (line) {
-              return indent + '  ' + line;
-            }).join('\n') + '\n' + indent + '  >';
-          } // stringify generic objects
-
-          return prefix + JSON.stringify(value, null, 2).split('\n').map(function (line, index) {
-            if (index === 0) {
-              return line;
-            }
-            return indent + '  ' + line;
-          }).join('\n');
-        }).join('\n') + (
-        // recursively textify the child boxes
-        box.boxes ? '\n' + textifyMp4(box.boxes, depth + 1) : '');
-      }).join('\n');
-    };
+        trun: parseTrun$2};
     var mp4Inspector = {
-      inspect: inspectMp4,
-      textify: textifyMp4,
-      parseType: parseType$2,
-      findBox: findBox$4,
-      parseTraf: parse.traf,
       parseTfdt: parse.tfdt,
-      parseHdlr: parse.hdlr,
-      parseTfhd: parse.tfhd,
-      parseTrun: parse.trun,
-      parseSidx: parse.sidx
-    };
+      parseTrun: parse.trun};
     /**
      * Returns the first string in the data array ending with a null char '\0'
      * @param {UInt8} data 
@@ -75159,15 +74334,15 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
      *
      * @returns {Promise<Array.<MainResourceWithKeySystems>>}
      */
-    static composeAkamaiResources(resources = []) {
-      return _asyncToGenerator(function* () {
+    static composeAkamaiResources() {
+      return _asyncToGenerator(function* (resources = []) {
         if (!AkamaiTokenService.hasToken(resources)) {
           return Promise.resolve(resources);
         }
 
         // TODO allow to modify the Akamai URL
         return AkamaiTokenService.tokenizeSources(resources);
-      })();
+      }).apply(this, arguments);
     }
 
     /**
@@ -75389,11 +74564,11 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
      *
      * @returns {Promise<MediaComposition>}
      */
-    static getMediaComposition(urn, handleRequest = new DataProvider().handleRequest()) {
-      return _asyncToGenerator(function* () {
+    static getMediaComposition(_x) {
+      return _asyncToGenerator(function* (urn, handleRequest = new DataProvider().handleRequest()) {
         const data = yield handleRequest(urn);
         return Object.assign(new MediaComposition(), data);
-      })();
+      }).apply(this, arguments);
     }
 
     /**
@@ -75616,7 +74791,7 @@ ${segmentInfoString(segmentInfo)}`); // If there's an init segment associated wi
           var _ref = _asyncToGenerator(function* (srcObj, next) {
             return SrgSsr.handleSetSource(player, srcObj, next);
           });
-          return function setSource(_x, _x2) {
+          return function setSource(_x2, _x3) {
             return _ref.apply(this, arguments);
           };
         }()