hls.js 1.5.14-0.canary.10429 → 1.5.14-0.canary.10432

package/dist/hls.light.js

@@ -493,7 +493,7 @@
       // Some browsers don't allow to use bind on console object anyway
       // fallback to default if needed
       try {
-        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.14-0.canary.10429");
+        newLogger.log("Debug logs enabled for \"" + context + "\" in hls.js version " + "1.5.14-0.canary.10432");
       } catch (e) {
         /* log fn threw an exception. All logger methods are no-ops. */
         return createLogger();
@@ -12154,30 +12154,14 @@
     }
     return null;
   }
-  function shouldAlignOnDiscontinuities(lastFrag, switchDetails, details) {
-    if (switchDetails) {
-      if (details.endCC > details.startCC || lastFrag && lastFrag.cc < details.startCC) {
+  function shouldAlignOnDiscontinuities(refDetails, details) {
+    if (refDetails) {
+      if (details.startCC < refDetails.endCC && details.endCC > refDetails.startCC) {
         return true;
       }
     }
     return false;
   }
-
-  // Find the first frag in the previous level which matches the CC of the first frag of the new level
-  function findDiscontinuousReferenceFrag(prevDetails, curDetails) {
-    var prevFrags = prevDetails.fragments;
-    var curFrags = curDetails.fragments;
-    if (!curFrags.length || !prevFrags.length) {
-      logger.log('No fragments to align');
-      return;
-    }
-    var prevStartFrag = findFirstFragWithCC(prevFrags, curFrags[0].cc);
-    if (!prevStartFrag || prevStartFrag && !prevStartFrag.startPTS) {
-      logger.log('No frag in previous level to align on');
-      return;
-    }
-    return prevStartFrag;
-  }
   function adjustFragmentStart(frag, sliding) {
     if (frag) {
       var start = frag.start + sliding;
@@ -12212,7 +12196,7 @@
     if (!switchDetails) {
       return;
     }
-    alignDiscontinuities(lastFrag, details, switchDetails);
+    alignDiscontinuities(details, switchDetails);
     if (!details.alignedSliding && switchDetails) {
       // If the PTS wasn't figured out via discontinuity sequence that means there was no CC increase within the level.
       // Aligning via Program Date Time should therefore be reliable, since PDT should be the same within the same
@@ -12228,20 +12212,24 @@
   }
 
   /**
-   * Computes the PTS if a new level's fragments using the PTS of a fragment in the last level which shares the same
-   * discontinuity sequence.
-   * @param lastFrag - The last Fragment which shares the same discontinuity sequence
+   * Ajust the start of fragments in `details` by the difference in time between fragments of the latest
+   * shared discontinuity sequence change.
    * @param lastLevel - The details of the last loaded level
    * @param details - The details of the new level
    */
-  function alignDiscontinuities(lastFrag, details, switchDetails) {
-    if (shouldAlignOnDiscontinuities(lastFrag, switchDetails, details)) {
-      var referenceFrag = findDiscontinuousReferenceFrag(switchDetails, details);
-      if (referenceFrag && isFiniteNumber(referenceFrag.start)) {
-        logger.log("Adjusting PTS using last level due to CC increase within current level " + details.url);
-        adjustSlidingStart(referenceFrag.start, details);
-      }
+  function alignDiscontinuities(details, refDetails) {
+    if (!shouldAlignOnDiscontinuities(refDetails, details)) {
+      return;
     }
+    var targetCC = Math.min(refDetails.endCC, details.endCC);
+    var refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
+    var frag = findFirstFragWithCC(details.fragments, targetCC);
+    if (!refFrag || !frag) {
+      return;
+    }
+    logger.log("Aligning playlist at start of dicontinuity sequence " + targetCC);
+    var delta = refFrag.start - frag.start;
+    adjustSlidingStart(delta, details);
   }
 
   /**
@@ -13022,6 +13010,10 @@
     };
     _proto.onHandlerDestroying = function onHandlerDestroying() {
       this.stopLoad();
+      if (this.transmuxer) {
+        this.transmuxer.destroy();
+        this.transmuxer = null;
+      }
       _TaskLoop.prototype.onHandlerDestroying.call(this);
       // @ts-ignore
       this.hls = this.onMediaSeeking = this.onMediaEnded = null;
@@ -13069,7 +13061,7 @@
           return;
         }
         if ('payload' in data) {
-          _this3.log("Loaded fragment " + frag.sn + " of level " + frag.level);
+          _this3.log("Loaded " + frag.type + " sn: " + frag.sn + " of " + _this3.playlistLabel() + " " + frag.level);
           _this3.hls.trigger(Events.FRAG_LOADED, data);
         }
 
@@ -13213,9 +13205,9 @@
       return !frag || !fragCurrent || frag.sn !== fragCurrent.sn || frag.level !== fragCurrent.level;
     };
     _proto.fragBufferedComplete = function fragBufferedComplete(frag, part) {
-      var _frag$startPTS, _frag$endPTS, _this$fragCurrent, _this$fragPrevious;
+      var _this$fragCurrent, _this$fragPrevious;
       var media = this.mediaBuffer ? this.mediaBuffer : this.media;
-      this.log("Buffered " + frag.type + " sn: " + frag.sn + (part ? ' part: ' + part.index : '') + " of " + (this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track') + " " + frag.level + " (frag:[" + ((_frag$startPTS = frag.startPTS) != null ? _frag$startPTS : NaN).toFixed(3) + "-" + ((_frag$endPTS = frag.endPTS) != null ? _frag$endPTS : NaN).toFixed(3) + "] > buffer:" + (media ? TimeRanges.toString(BufferHelper.getBuffered(media)) : '(detached)') + ")");
+      this.log("Buffered " + frag.type + " sn: " + frag.sn + (part ? ' part: ' + part.index : '') + " of " + this.fragInfo(frag) + " > buffer:" + (media ? TimeRanges.toString(BufferHelper.getBuffered(media)) : '(detached)') + ")");
       if (frag.sn !== 'initSegment') {
         var _this$levels;
         if (frag.type !== PlaylistLevelType.SUBTITLE) {
@@ -13277,7 +13269,7 @@
       }
       var keyLoadingPromise = null;
       if (frag.encrypted && !((_frag$decryptdata = frag.decryptdata) != null && _frag$decryptdata.key)) {
-        this.log("Loading key for " + frag.sn + " of [" + details.startSN + "-" + details.endSN + "], " + (this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track') + " " + frag.level);
+        this.log("Loading key for " + frag.sn + " of [" + details.startSN + "-" + details.endSN + "], " + this.playlistLabel() + " " + frag.level);
         this.state = State.KEY_LOADING;
         this.fragCurrent = frag;
         keyLoadingPromise = this.keyLoader.load(frag).then(function (keyLoadedData) {
@@ -13316,7 +13308,7 @@
           var partIndex = this.getNextPart(partList, frag, targetBufferTime);
           if (partIndex > -1) {
             var part = partList[partIndex];
-            this.log("Loading part sn: " + frag.sn + " p: " + part.index + " cc: " + frag.cc + " of playlist [" + details.startSN + "-" + details.endSN + "] parts [0-" + partIndex + "-" + (partList.length - 1) + "] " + (this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
+            this.log("Loading part sn: " + frag.sn + " p: " + part.index + " cc: " + frag.cc + " of playlist [" + details.startSN + "-" + details.endSN + "] parts [0-" + partIndex + "-" + (partList.length - 1) + "] " + this.playlistLabel() + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
             this.nextLoadPosition = part.start + part.duration;
             this.state = State.FRAG_LOADING;
             var _result;
@@ -13356,7 +13348,7 @@
         // Selected fragment hint for part but not loading parts
         return Promise.resolve(null);
       }
-      this.log("Loading fragment " + frag.sn + " cc: " + frag.cc + " " + (details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : '') + (this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
+      this.log("Loading " + frag.type + " sn: " + frag.sn + " of " + this.fragInfo(frag, false) + ") cc: " + frag.cc + " " + (details ? '[' + details.startSN + '-' + details.endSN + ']' : '') + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
       // Don't update nextLoadPosition for fragments which are not buffered
       if (isFiniteNumber(frag.sn) && !this.bitrateTest) {
         this.nextLoadPosition = frag.start + frag.duration;
@@ -14120,16 +14112,25 @@
         // For this error fallthrough. Marking parsed will allow advancing to next fragment.
       }
       this.state = State.PARSED;
+      this.log("Parsed " + frag.type + " sn: " + frag.sn + (part ? ' part: ' + part.index : '') + " of " + this.fragInfo(frag) + ")");
       this.hls.trigger(Events.FRAG_PARSED, {
         frag: frag,
         part: part
       });
     };
-    _proto.resetTransmuxer = function resetTransmuxer() {
-      if (this.transmuxer) {
-        this.transmuxer.destroy();
-        this.transmuxer = null;
+    _proto.playlistLabel = function playlistLabel() {
+      return this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track';
+    };
+    _proto.fragInfo = function fragInfo(frag, pts) {
+      var _ref3, _ref4;
+      if (pts === void 0) {
+        pts = true;
       }
+      return this.playlistLabel() + " " + frag.level + " (frag:[" + ((_ref3 = pts ? frag.startPTS : frag.start) != null ? _ref3 : NaN).toFixed(3) + "-" + ((_ref4 = pts ? frag.endPTS : frag.end) != null ? _ref4 : NaN).toFixed(3) + "]";
+    };
+    _proto.resetTransmuxer = function resetTransmuxer() {
+      var _this$transmuxer2;
+      (_this$transmuxer2 = this.transmuxer) == null ? void 0 : _this$transmuxer2.reset();
     };
     _proto.recoverWorkerError = function recoverWorkerError(data) {
       if (data.event === 'demuxerWorker') {
@@ -14867,7 +14868,7 @@
 
     // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
     ;
-    AACDemuxer.probe = function probe$2(data) {
+    AACDemuxer.probe = function probe$2(data, logger) {
       if (!data) {
         return false;
       }
@@ -15816,7 +15817,8 @@
 
   var PACKET_LENGTH = 188;
   var TSDemuxer = /*#__PURE__*/function () {
-    function TSDemuxer(observer, config, typeSupported) {
+    function TSDemuxer(observer, config, typeSupported, logger) {
+      this.logger = void 0;
       this.observer = void 0;
       this.config = void 0;
       this.typeSupported = void 0;
@@ -15836,9 +15838,10 @@
       this.observer = observer;
       this.config = config;
       this.typeSupported = typeSupported;
+      this.logger = logger;
       this.videoParser = null;
     }
-    TSDemuxer.probe = function probe(data) {
+    TSDemuxer.probe = function probe(data, logger) {
       var syncOffset = TSDemuxer.syncOffset(data);
       if (syncOffset > 0) {
         logger.warn("MPEG2-TS detected but first sync word found @ offset " + syncOffset);
@@ -16005,7 +16008,7 @@
           switch (pid) {
             case videoPid:
               if (stt) {
-                if (videoData && (pes = parsePES(videoData))) {
+                if (videoData && (pes = parsePES(videoData, this.logger))) {
                   if (this.videoParser === null) {
                     switch (videoTrack.segmentCodec) {
                       case 'avc':
@@ -16029,7 +16032,7 @@
               break;
             case audioPid:
               if (stt) {
-                if (audioData && (pes = parsePES(audioData))) {
+                if (audioData && (pes = parsePES(audioData, this.logger))) {
                   switch (audioTrack.segmentCodec) {
                     case 'aac':
                       this.parseAACPES(audioTrack, pes);
@@ -16051,7 +16054,7 @@
               break;
             case id3Pid:
               if (stt) {
-                if (id3Data && (pes = parsePES(id3Data))) {
+                if (id3Data && (pes = parsePES(id3Data, this.logger))) {
                   this.parseID3PES(id3Track, pes);
                 }
                 id3Data = {
@@ -16069,14 +16072,14 @@
                 offset += data[offset] + 1;
               }
               pmtId = this._pmtId = parsePAT(data, offset);
-              // logger.log('PMT PID:'  + this._pmtId);
+              // this.logger.log('PMT PID:'  + this._pmtId);
               break;
             case pmtId:
               {
                 if (stt) {
                   offset += data[offset] + 1;
                 }
-                var parsedPIDs = parsePMT(data, offset, this.typeSupported, isSampleAes, this.observer);
+                var parsedPIDs = parsePMT(data, offset, this.typeSupported, isSampleAes, this.observer, this.logger);
 
                 // only update track id if track PID found while parsing PMT
                 // this is to avoid resetting the PID to -1 in case
@@ -16099,7 +16102,7 @@
                   id3Track.pid = id3Pid;
                 }
                 if (unknownPID !== null && !pmtParsed) {
-                  logger.warn("MPEG-TS PMT found at " + start + " after unknown PID '" + unknownPID + "'. Backtracking to sync byte @" + syncOffset + " to parse all TS packets.");
+                  this.logger.warn("MPEG-TS PMT found at " + start + " after unknown PID '" + unknownPID + "'. Backtracking to sync byte @" + syncOffset + " to parse all TS packets.");
                   unknownPID = null;
                   // we set it to -188, the += 188 in the for loop will reset start to 0
                   start = syncOffset - 188;
@@ -16119,7 +16122,7 @@
         }
       }
       if (tsPacketErrors > 0) {
-        emitParsingError(this.observer, new Error("Found " + tsPacketErrors + " TS packet/s that do not start with 0x47"));
+        emitParsingError(this.observer, new Error("Found " + tsPacketErrors + " TS packet/s that do not start with 0x47"), undefined, this.logger);
       }
       videoTrack.pesData = videoData;
       audioTrack.pesData = audioData;
@@ -16165,7 +16168,7 @@
       var id3Data = id3Track.pesData;
       // try to parse last PES packets
       var pes;
-      if (videoData && (pes = parsePES(videoData))) {
+      if (videoData && (pes = parsePES(videoData, this.logger))) {
         if (this.videoParser === null) {
           switch (videoTrack.segmentCodec) {
             case 'avc':
@@ -16181,7 +16184,7 @@
         // either avcData null or PES truncated, keep it for next frag parsing
         videoTrack.pesData = videoData;
       }
-      if (audioData && (pes = parsePES(audioData))) {
+      if (audioData && (pes = parsePES(audioData, this.logger))) {
         switch (audioTrack.segmentCodec) {
           case 'aac':
             this.parseAACPES(audioTrack, pes);
@@ -16193,13 +16196,13 @@
         audioTrack.pesData = null;
       } else {
         if (audioData != null && audioData.size) {
-          logger.log('last AAC PES packet truncated,might overlap between fragments');
+          this.logger.log('last AAC PES packet truncated,might overlap between fragments');
         }
 
         // either audioData null or PES truncated, keep it for next frag parsing
         audioTrack.pesData = audioData;
       }
-      if (id3Data && (pes = parsePES(id3Data))) {
+      if (id3Data && (pes = parsePES(id3Data, this.logger))) {
         this.parseID3PES(id3Track, pes);
         id3Track.pesData = null;
       } else {
@@ -16271,7 +16274,7 @@
         } else {
           reason = 'No ADTS header found in AAC PES';
         }
-        emitParsingError(this.observer, new Error(reason), recoverable);
+        emitParsingError(this.observer, new Error(reason), recoverable, this.logger);
         if (!recoverable) {
           return;
         }
@@ -16286,7 +16289,7 @@
         var frameDuration = getFrameDuration(track.samplerate);
         pts = aacOverFlow.sample.pts + frameDuration;
       } else {
-        logger.warn('[tsdemuxer]: AAC PES unknown PTS');
+        this.logger.warn('[tsdemuxer]: AAC PES unknown PTS');
         return;
       }
 
@@ -16316,7 +16319,7 @@
       var offset = 0;
       var pts = pes.pts;
       if (pts === undefined) {
-        logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
+        this.logger.warn('[tsdemuxer]: MPEG PES unknown PTS');
         return;
       }
       while (offset < length) {
@@ -16339,7 +16342,7 @@
     };
     _proto.parseID3PES = function parseID3PES(id3Track, pes) {
       if (pes.pts === undefined) {
-        logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
+        this.logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
         return;
       }
       var id3Sample = _extends({}, pes, {
@@ -16358,7 +16361,7 @@
     // skip the PSI header and parse the first PMT entry
     return (data[offset + 10] & 0x1f) << 8 | data[offset + 11];
   }
-  function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
+  function parsePMT(data, offset, typeSupported, isSampleAes, observer, logger) {
     var result = {
       audioPid: -1,
       videoPid: -1,
@@ -16380,7 +16383,7 @@
         case 0xcf:
           // SAMPLE-AES AAC
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC');
+            logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC', this.logger);
             break;
           }
         /* falls through */
@@ -16402,7 +16405,7 @@
         case 0xdb:
           // SAMPLE-AES AVC
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('H.264');
+            logEncryptedSamplesFoundInUnencryptedStream('H.264', this.logger);
             break;
           }
         /* falls through */
@@ -16430,7 +16433,7 @@
         case 0xc1:
           // SAMPLE-AES AC3
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('AC-3');
+            logEncryptedSamplesFoundInUnencryptedStream('AC-3', this.logger);
             break;
           }
         /* falls through */
@@ -16466,12 +16469,12 @@
         case 0xc2: // SAMPLE-AES EC3
         /* falls through */
         case 0x87:
-          emitParsingError(observer, new Error('Unsupported EC-3 in M2TS found'));
+          emitParsingError(observer, new Error('Unsupported EC-3 in M2TS found'), undefined, this.logger);
           return result;
         case 0x24:
           // ITU-T Rec. H.265 and ISO/IEC 23008-2 (HEVC)
           {
-            emitParsingError(observer, new Error('Unsupported HEVC in M2TS found'));
+            emitParsingError(observer, new Error('Unsupported HEVC in M2TS found'), undefined, this.logger);
             return result;
           }
       }
@@ -16481,7 +16484,7 @@
     }
     return result;
   }
-  function emitParsingError(observer, error, levelRetry) {
+  function emitParsingError(observer, error, levelRetry, logger) {
     logger.warn("parsing error: " + error.message);
     observer.emit(Events.ERROR, Events.ERROR, {
       type: ErrorTypes.MEDIA_ERROR,
@@ -16492,10 +16495,10 @@
       reason: error.message
     });
   }
-  function logEncryptedSamplesFoundInUnencryptedStream(type) {
+  function logEncryptedSamplesFoundInUnencryptedStream(type, logger) {
     logger.log(type + " with AES-128-CBC encryption found in unencrypted stream");
   }
-  function parsePES(stream) {
+  function parsePES(stream, logger) {
     var i = 0;
     var frag;
     var pesLen;
@@ -17392,7 +17395,8 @@
   var chromeVersion = null;
   var safariWebkitVersion = null;
   var MP4Remuxer = /*#__PURE__*/function () {
-    function MP4Remuxer(observer, config, typeSupported, vendor) {
+    function MP4Remuxer(observer, config, typeSupported, logger) {
+      this.logger = void 0;
       this.observer = void 0;
       this.config = void 0;
       this.typeSupported = void 0;
@@ -17408,6 +17412,7 @@
       this.observer = observer;
       this.config = config;
       this.typeSupported = typeSupported;
+      this.logger = logger;
       this.ISGenerated = false;
       if (chromeVersion === null) {
         var userAgent = navigator.userAgent || '';
@@ -17425,16 +17430,16 @@
       this.config = this.videoTrackConfig = this._initPTS = this._initDTS = null;
     };
     _proto.resetTimeStamp = function resetTimeStamp(defaultTimeStamp) {
-      logger.log('[mp4-remuxer]: initPTS & initDTS reset');
+      this.logger.log('[mp4-remuxer]: initPTS & initDTS reset');
       this._initPTS = this._initDTS = defaultTimeStamp;
     };
     _proto.resetNextTimestamp = function resetNextTimestamp() {
-      logger.log('[mp4-remuxer]: reset next timestamp');
+      this.logger.log('[mp4-remuxer]: reset next timestamp');
       this.isVideoContiguous = false;
       this.isAudioContiguous = false;
     };
     _proto.resetInitSegment = function resetInitSegment() {
-      logger.log('[mp4-remuxer]: ISGenerated flag reset');
+      this.logger.log('[mp4-remuxer]: ISGenerated flag reset');
       this.ISGenerated = false;
       this.videoTrackConfig = undefined;
     };
@@ -17453,7 +17458,7 @@
         }
       }, videoSamples[0].pts);
       if (rolloverDetected) {
-        logger.debug('PTS rollover detected');
+        this.logger.debug('PTS rollover detected');
       }
       return startPTS;
     };
@@ -17497,14 +17502,14 @@
           if (!isVideoContiguous && this.config.forceKeyFrameOnDiscontinuity) {
             independent = true;
             if (firstKeyFrameIndex > 0) {
-              logger.warn("[mp4-remuxer]: Dropped " + firstKeyFrameIndex + " out of " + length + " video samples due to a missing keyframe");
+              this.logger.warn("[mp4-remuxer]: Dropped " + firstKeyFrameIndex + " out of " + length + " video samples due to a missing keyframe");
               var startPTS = this.getVideoStartPts(videoTrack.samples);
               videoTrack.samples = videoTrack.samples.slice(firstKeyFrameIndex);
               videoTrack.dropped += firstKeyFrameIndex;
               videoTimeOffset += (videoTrack.samples[0].pts - startPTS) / videoTrack.inputTimeScale;
               firstKeyFramePTS = videoTimeOffset;
             } else if (firstKeyFrameIndex === -1) {
-              logger.warn("[mp4-remuxer]: No keyframe found out of " + length + " video samples");
+              this.logger.warn("[mp4-remuxer]: No keyframe found out of " + length + " video samples");
               independent = false;
             }
           }
@@ -17526,7 +17531,7 @@
           if (enoughAudioSamples) {
             // if initSegment was generated without audio samples, regenerate it again
             if (!audioTrack.samplerate) {
-              logger.warn('[mp4-remuxer]: regenerate InitSegment as audio detected');
+              this.logger.warn('[mp4-remuxer]: regenerate InitSegment as audio detected');
               initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
             }
             audio = this.remuxAudio(audioTrack, audioTimeOffset, this.isAudioContiguous, accurateTimeOffset, hasVideo || enoughVideoSamples || playlistType === PlaylistLevelType.AUDIO ? videoTimeOffset : undefined);
@@ -17534,7 +17539,7 @@
               var audioTrackLength = audio ? audio.endPTS - audio.startPTS : 0;
               // if initSegment was generated without video samples, regenerate it again
               if (!videoTrack.inputTimeScale) {
-                logger.warn('[mp4-remuxer]: regenerate InitSegment as video detected');
+                this.logger.warn('[mp4-remuxer]: regenerate InitSegment as video detected');
                 initSegment = this.generateIS(audioTrack, videoTrack, timeOffset, accurateTimeOffset);
               }
               video = this.remuxVideo(videoTrack, videoTimeOffset, isVideoContiguous, audioTrackLength);
@@ -17740,9 +17745,9 @@
         var foundOverlap = delta < -1;
         if (foundHole || foundOverlap) {
           if (foundHole) {
-            logger.warn((track.segmentCodec || '').toUpperCase() + ": " + toMsFromMpegTsClock(delta, true) + " ms (" + delta + "dts) hole between fragments detected at " + timeOffset.toFixed(3));
+            this.logger.warn((track.segmentCodec || '').toUpperCase() + ": " + toMsFromMpegTsClock(delta, true) + " ms (" + delta + "dts) hole between fragments detected at " + timeOffset.toFixed(3));
           } else {
-            logger.warn((track.segmentCodec || '').toUpperCase() + ": " + toMsFromMpegTsClock(-delta, true) + " ms (" + delta + "dts) overlapping between fragments detected at " + timeOffset.toFixed(3));
+            this.logger.warn((track.segmentCodec || '').toUpperCase() + ": " + toMsFromMpegTsClock(-delta, true) + " ms (" + delta + "dts) overlapping between fragments detected at " + timeOffset.toFixed(3));
           }
           if (!foundOverlap || nextAvcDts >= inputSamples[0].pts || chromeVersion) {
             firstDTS = nextAvcDts;
@@ -17771,7 +17776,7 @@
                 }
               }
             }
-            logger.log("Video: Initial PTS/DTS adjusted: " + toMsFromMpegTsClock(firstPTS, true) + "/" + toMsFromMpegTsClock(firstDTS, true) + ", delta: " + toMsFromMpegTsClock(delta, true) + " ms");
+            this.logger.log("Video: Initial PTS/DTS adjusted: " + toMsFromMpegTsClock(firstPTS, true) + "/" + toMsFromMpegTsClock(firstDTS, true) + ", delta: " + toMsFromMpegTsClock(delta, true) + " ms");
           }
         }
       }
@@ -17871,7 +17876,7 @@
               } else {
                 stretchedLastFrame = true;
               }
-              logger.log("[mp4-remuxer]: It is approximately " + deltaToFrameEnd / 90 + " ms to the next segment; using duration " + mp4SampleDuration / 90 + " ms for the last video frame.");
+              this.logger.log("[mp4-remuxer]: It is approximately " + deltaToFrameEnd / 90 + " ms to the next segment; using duration " + mp4SampleDuration / 90 + " ms for the last video frame.");
             } else {
               mp4SampleDuration = lastFrameDuration;
             }
@@ -17899,7 +17904,7 @@
           // Fix for "CNN special report, with CC" in test-streams (Safari browser only)
           // Ignore DTS when frame durations are irregular. Safari MSE does not handle this leading to gaps.
           if (maxPtsDelta - minPtsDelta < maxDtsDelta - minDtsDelta && averageSampleDuration / maxDtsDelta < 0.025 && outputSamples[0].cts === 0) {
-            logger.warn('Found irregular gaps in sample duration. Using PTS instead of DTS to determine MP4 sample duration.');
+            this.logger.warn('Found irregular gaps in sample duration. Using PTS instead of DTS to determine MP4 sample duration.');
             var dts = firstDTS;
             for (var _i4 = 0, len = outputSamples.length; _i4 < len; _i4++) {
               var nextDts = dts + outputSamples[_i4].duration;
@@ -18026,7 +18031,7 @@
           // When remuxing with video, if we're overlapping by more than a duration, drop this sample to stay in sync
           if (delta <= -maxAudioFramesDrift * inputSampleDuration && alignedWithVideo) {
             if (i === 0) {
-              logger.warn("Audio frame @ " + (pts / inputTimeScale).toFixed(3) + "s overlaps nextAudioPts by " + Math.round(1000 * delta / inputTimeScale) + " ms.");
+              this.logger.warn("Audio frame @ " + (pts / inputTimeScale).toFixed(3) + "s overlaps nextAudioPts by " + Math.round(1000 * delta / inputTimeScale) + " ms.");
               this.nextAudioPts = nextAudioPts = nextPts = pts;
             }
           } // eslint-disable-line brace-style
@@ -18048,12 +18053,12 @@
             if (i === 0) {
               this.nextAudioPts = nextAudioPts = nextPts;
             }
-            logger.warn("[mp4-remuxer]: Injecting " + missing + " audio frame @ " + (nextPts / inputTimeScale).toFixed(3) + "s due to " + Math.round(1000 * delta / inputTimeScale) + " ms gap.");
+            this.logger.warn("[mp4-remuxer]: Injecting " + missing + " audio frame @ " + (nextPts / inputTimeScale).toFixed(3) + "s due to " + Math.round(1000 * delta / inputTimeScale) + " ms gap.");
             for (var j = 0; j < missing; j++) {
               var newStamp = Math.max(nextPts, 0);
               var fillFrame = AAC.getSilentFrame(track.parsedCodec || track.manifestCodec || track.codec, track.channelCount);
               if (!fillFrame) {
-                logger.log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
+                this.logger.log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
                 fillFrame = sample.unit.subarray();
               }
               inputSamples.splice(i, 0, {
@@ -18253,7 +18258,8 @@
   };
 
   var PassThroughRemuxer = /*#__PURE__*/function () {
-    function PassThroughRemuxer() {
+    function PassThroughRemuxer(observer, config, typeSupported, logger) {
+      this.logger = void 0;
       this.emitInitSegment = false;
       this.audioCodec = void 0;
       this.videoCodec = void 0;
@@ -18261,6 +18267,7 @@
       this.initPTS = null;
       this.initTracks = void 0;
       this.lastEndTime = null;
+      this.logger = logger;
     }
     var _proto = PassThroughRemuxer.prototype;
     _proto.destroy = function destroy() {};
@@ -18317,7 +18324,7 @@
           id: 'main'
         };
       } else {
-        logger.warn('[passthrough-remuxer.ts]: initSegment does not contain moov or trak boxes.');
+        this.logger.warn('[passthrough-remuxer.ts]: initSegment does not contain moov or trak boxes.');
       }
       this.initTracks = tracks;
     };
@@ -18357,7 +18364,7 @@
       }
       if (!((_initData2 = initData) != null && _initData2.length)) {
         // We can't remux if the initSegment could not be generated
-        logger.warn('[passthrough-remuxer.ts]: Failed to generate initSegment.');
+        this.logger.warn('[passthrough-remuxer.ts]: Failed to generate initSegment.');
         return result;
       }
       if (this.emitInitSegment) {
@@ -18370,7 +18377,7 @@
       if (isInvalidInitPts(initPTS, decodeTime, timeOffset, duration) || initSegment.timescale !== initPTS.timescale && accurateTimeOffset) {
         initSegment.initPTS = decodeTime - timeOffset;
         if (initPTS && initPTS.timescale === 1) {
-          logger.warn("Adjusting initPTS @" + timeOffset + " from " + initPTS.baseTime / initPTS.timescale + " to " + initSegment.initPTS);
+          this.logger.warn("Adjusting initPTS @" + timeOffset + " from " + initPTS.baseTime / initPTS.timescale + " to " + initSegment.initPTS);
         }
         this.initPTS = initPTS = {
           baseTime: initSegment.initPTS,
@@ -18383,7 +18390,7 @@
       if (duration > 0) {
         this.lastEndTime = endTime;
       } else {
-        logger.warn('Duration parsed from mp4 should be greater than zero');
+        this.logger.warn('Duration parsed from mp4 should be greater than zero');
         this.resetNextTimestamp();
       }
       var hasAudio = !!initData.audio;
@@ -18442,12 +18449,12 @@
         return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
       }
       var result = 'mp4a.40.5';
-      logger.info("Parsed audio codec \"" + parsedCodec + "\" or audio object type not handled. Using \"" + result + "\"");
+      this.logger.info("Parsed audio codec \"" + parsedCodec + "\" or audio object type not handled. Using \"" + result + "\"");
       return result;
     }
     // Provide defaults based on codec type
     // This allows for some playback of some fmp4 playlists without CODECS defined in manifest
-    logger.warn("Unhandled video codec \"" + parsedCodec + "\"");
+    this.logger.warn("Unhandled video codec \"" + parsedCodec + "\"");
     if (parsedCodec === 'hvc1' || parsedCodec === 'hev1') {
       return 'hvc1.1.6.L120.90';
     }
@@ -18457,16 +18464,12 @@
     return 'avc1.42e01e';
   }
 
-  /** returns `undefined` is `self` is missing, e.g. in node */
-  var optionalSelf = typeof self !== 'undefined' ? self : undefined;
-
   var now;
   // performance.now() not available on WebWorker, at least on Safari Desktop
   try {
     now = self.performance.now.bind(self.performance);
   } catch (err) {
-    logger.debug('Unable to use Performance API on this environment');
-    now = optionalSelf == null ? void 0 : optionalSelf.Date.now;
+    now = Date.now;
   }
   var muxConfig = [{
     demux: MP4Demuxer,
@@ -18482,8 +18485,9 @@
     remux: MP4Remuxer
   }];
   var Transmuxer = /*#__PURE__*/function () {
-    function Transmuxer(observer, typeSupported, config, vendor, id) {
-      this.async = false;
+    function Transmuxer(observer, typeSupported, config, vendor, id, logger) {
+      this.asyncResult = false;
+      this.logger = void 0;
       this.observer = void 0;
       this.typeSupported = void 0;
       this.config = void 0;
@@ -18501,6 +18505,7 @@
       this.config = config;
       this.vendor = vendor;
       this.id = id;
+      this.logger = logger;
     }
     var _proto = Transmuxer.prototype;
     _proto.configure = function configure(transmuxConfig) {
@@ -18552,6 +18557,7 @@
           }
           uintData = new Uint8Array(decryptedData);
         } else {
+          this.asyncResult = true;
           this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(function (decryptedData) {
             // Calling push here is important; if flush() is called while this is still resolving, this ensures that
             // the decrypted data has been transmuxed
@@ -18566,7 +18572,7 @@
       if (resetMuxers) {
         var error = this.configureTransmuxer(uintData);
         if (error) {
-          logger.warn("[transmuxer] " + error.message);
+          this.logger.warn("[transmuxer] " + error.message);
           this.observer.emit(Events.ERROR, Events.ERROR, {
             type: ErrorTypes.MEDIA_ERROR,
             details: ErrorDetails.FRAG_PARSING_ERROR,
@@ -18588,6 +18594,7 @@
         this.resetContiguity();
       }
       var result = this.transmux(uintData, keyData, timeOffset, accurateTimeOffset, chunkMeta);
+      this.asyncResult = isPromise(result);
       var currentState = this.currentTransmuxState;
       currentState.contiguous = true;
       currentState.discontinuity = false;
@@ -18606,6 +18613,7 @@
         currentTransmuxState = this.currentTransmuxState,
         decryptionPromise = this.decryptionPromise;
       if (decryptionPromise) {
+        this.asyncResult = true;
         // Upon resolution, the decryption promise calls push() and returns its TransmuxerResult up the stack. Therefore
         // only flushing is required for async decryption
         return decryptionPromise.then(function () {
@@ -18629,10 +18637,15 @@
       if (!demuxer || !remuxer) {
         // If probing failed, then Hls.js has been given content its not able to handle
         stats.executeEnd = now();
-        return [emptyResult(chunkMeta)];
+        var emptyResults = [emptyResult(chunkMeta)];
+        if (this.asyncResult) {
+          return Promise.resolve(emptyResults);
+        }
+        return emptyResults;
       }
       var demuxResultOrPromise = demuxer.flush(timeOffset);
       if (isPromise(demuxResultOrPromise)) {
+        this.asyncResult = true;
         // Decrypt final SAMPLE-AES samples
         return demuxResultOrPromise.then(function (demuxResult) {
           _this2.flushRemux(transmuxResults, demuxResult, chunkMeta);
@@ -18640,6 +18653,9 @@
         });
       }
       this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
+      if (this.asyncResult) {
+        return Promise.resolve(transmuxResults);
+      }
       return transmuxResults;
     };
     _proto.flushRemux = function flushRemux(transmuxResults, demuxResult, chunkMeta) {
@@ -18650,7 +18666,7 @@
       var _this$currentTransmux = this.currentTransmuxState,
         accurateTimeOffset = _this$currentTransmux.accurateTimeOffset,
         timeOffset = _this$currentTransmux.timeOffset;
-      logger.log("[transmuxer.ts]: Flushed fragment " + chunkMeta.sn + (chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : '') + " of level " + chunkMeta.level);
+      this.logger.log("[transmuxer.ts]: Flushed " + this.id + " sn: " + chunkMeta.sn + (chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : '') + " of " + (this.id === PlaylistLevelType.MAIN ? 'level' : 'track') + " " + chunkMeta.level);
       var remuxResult = this.remuxer.remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, true, this.id);
       transmuxResults.push({
         remuxResult: remuxResult,
@@ -18729,13 +18745,13 @@
     _proto.configureTransmuxer = function configureTransmuxer(data) {
       var config = this.config,
         observer = this.observer,
-        typeSupported = this.typeSupported,
-        vendor = this.vendor;
+        typeSupported = this.typeSupported;
+        this.vendor;
       // probe for content type
       var mux;
       for (var i = 0, len = muxConfig.length; i < len; i++) {
         var _muxConfig$i$demux;
-        if ((_muxConfig$i$demux = muxConfig[i].demux) != null && _muxConfig$i$demux.probe(data)) {
+        if ((_muxConfig$i$demux = muxConfig[i].demux) != null && _muxConfig$i$demux.probe(data, this.logger)) {
           mux = muxConfig[i];
           break;
         }
@@ -18749,10 +18765,10 @@
       var Remuxer = mux.remux;
       var Demuxer = mux.demux;
       if (!remuxer || !(remuxer instanceof Remuxer)) {
-        this.remuxer = new Remuxer(observer, config, typeSupported, vendor);
+        this.remuxer = new Remuxer(observer, config, typeSupported, this.logger);
       }
       if (!demuxer || !(demuxer instanceof Demuxer)) {
-        this.demuxer = new Demuxer(observer, config, typeSupported);
+        this.demuxer = new Demuxer(observer, config, typeSupported, this.logger);
         this.probe = Demuxer.probe;
       }
     };
@@ -19156,63 +19172,54 @@
   var eventemitter3Exports = eventemitter3.exports;
   var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
+  var transmuxers = [];
   if (typeof __IN_WORKER__ !== 'undefined' && __IN_WORKER__) {
-    startWorker(self);
+    startWorker();
   }
-  function startWorker(self) {
-    var observer = new EventEmitter();
-    var forwardMessage = function forwardMessage(ev, data) {
-      self.postMessage({
-        event: ev,
-        data: data
-      });
-    };
-
-    // forward events to main thread
-    observer.on(Events.FRAG_DECRYPTED, forwardMessage);
-    observer.on(Events.ERROR, forwardMessage);
-
-    // forward logger events to main thread
-    var forwardWorkerLogs = function forwardWorkerLogs(logger) {
-      var _loop = function _loop(logFn) {
-        var func = function func(message) {
-          forwardMessage('workerLog', {
-            logType: logFn,
-            message: message
-          });
-        };
-        logger[logFn] = func;
-      };
-      for (var logFn in logger) {
-        _loop(logFn);
-      }
-    };
+  function startWorker() {
     self.addEventListener('message', function (ev) {
       var data = ev.data;
+      var instanceNo = data.instanceNo;
+      if (instanceNo === undefined) {
+        return;
+      }
+      var transmuxer = transmuxers[instanceNo];
+      if (data.cmd === 'reset') {
+        delete transmuxers[data.resetNo];
+        if (transmuxer) {
+          transmuxer.destroy();
+        }
+        data.cmd = 'init';
+      }
+      if (data.cmd === 'init') {
+        var config = JSON.parse(data.config);
+        var observer = new EventEmitter();
+        observer.on(Events.FRAG_DECRYPTED, forwardMessage);
+        observer.on(Events.ERROR, forwardMessage);
+        var logger = enableLogs(config.debug, data.id);
+        forwardWorkerLogs(logger, instanceNo);
+        transmuxers[instanceNo] = new Transmuxer(observer, data.typeSupported, config, '', data.id, logger);
+        forwardMessage('init', null, instanceNo);
+        return;
+      }
+      if (!transmuxer) {
+        return;
+      }
       switch (data.cmd) {
-        case 'init':
-          {
-            var config = JSON.parse(data.config);
-            self.transmuxer = new Transmuxer(observer, data.typeSupported, config, '', data.id);
-            var logger = enableLogs(config.debug, data.id);
-            forwardWorkerLogs(logger);
-            forwardMessage('init', null);
-            break;
-          }
         case 'configure':
           {
-            self.transmuxer.configure(data.config);
+            transmuxer.configure(data.config);
             break;
           }
         case 'demux':
           {
-            var transmuxResult = self.transmuxer.push(data.data, data.decryptdata, data.chunkMeta, data.state);
+            var transmuxResult = transmuxer.push(data.data, data.decryptdata, data.chunkMeta, data.state);
             if (isPromise(transmuxResult)) {
-              self.transmuxer.async = true;
               transmuxResult.then(function (data) {
-                emitTransmuxComplete(self, data);
+                emitTransmuxComplete(self, data, instanceNo);
               }).catch(function (error) {
                 forwardMessage(Events.ERROR, {
+                  instanceNo: instanceNo,
                   type: ErrorTypes.MEDIA_ERROR,
                   details: ErrorDetails.FRAG_PARSING_ERROR,
                   chunkMeta: data.chunkMeta,
@@ -19220,25 +19227,20 @@
                   error: error,
                   err: error,
                   reason: "transmuxer-worker push error"
-                });
+                }, instanceNo);
               });
             } else {
-              self.transmuxer.async = false;
-              emitTransmuxComplete(self, transmuxResult);
+              emitTransmuxComplete(self, transmuxResult, instanceNo);
             }
             break;
           }
         case 'flush':
           {
-            var id = data.chunkMeta;
-            var _transmuxResult = self.transmuxer.flush(id);
-            var asyncFlush = isPromise(_transmuxResult);
-            if (asyncFlush || self.transmuxer.async) {
-              if (!isPromise(_transmuxResult)) {
-                _transmuxResult = Promise.resolve(_transmuxResult);
-              }
+            var chunkMeta = data.chunkMeta;
+            var _transmuxResult = transmuxer.flush(chunkMeta);
+            if (isPromise(_transmuxResult)) {
               _transmuxResult.then(function (results) {
-                handleFlushResult(self, results, id);
+                handleFlushResult(self, results, chunkMeta, instanceNo);
               }).catch(function (error) {
                 forwardMessage(Events.ERROR, {
                   type: ErrorTypes.MEDIA_ERROR,
@@ -19248,17 +19250,17 @@
                   error: error,
                   err: error,
                   reason: "transmuxer-worker flush error"
-                });
+                }, instanceNo);
               });
             } else {
-              handleFlushResult(self, _transmuxResult, id);
+              handleFlushResult(self, _transmuxResult, chunkMeta, instanceNo);
             }
             break;
           }
       }
     });
   }
-  function emitTransmuxComplete(self, transmuxResult) {
+  function emitTransmuxComplete(self, transmuxResult, instanceNo) {
     if (isEmptyResult(transmuxResult.remuxResult)) {
       return false;
     }
@@ -19274,7 +19276,8 @@
     }
     self.postMessage({
       event: 'transmuxComplete',
-      data: transmuxResult
+      data: transmuxResult,
+      instanceNo: instanceNo
     }, transferable);
     return true;
   }
@@ -19289,77 +19292,200 @@
       transferable.push(track.data2.buffer);
     }
   }
-  function handleFlushResult(self, results, chunkMeta) {
+  function handleFlushResult(self, results, chunkMeta, instanceNo) {
     var parsed = results.reduce(function (parsed, result) {
-      return emitTransmuxComplete(self, result) || parsed;
+      return emitTransmuxComplete(self, result, instanceNo) || parsed;
     }, false);
     if (!parsed) {
       // Emit at least one "transmuxComplete" message even if media is not found to update stream-controller state to PARSING
       self.postMessage({
         event: 'transmuxComplete',
-        data: results[0]
+        data: results[0],
+        instanceNo: instanceNo
       });
     }
     self.postMessage({
       event: 'flush',
-      data: chunkMeta
+      data: chunkMeta,
+      instanceNo: instanceNo
     });
   }
+  function forwardMessage(event, data, instanceNo) {
+    self.postMessage({
+      event: event,
+      data: data,
+      instanceNo: instanceNo
+    });
+  }
+  function forwardWorkerLogs(logger, instanceNo) {
+    var _loop = function _loop(logFn) {
+      var func = function func(message) {
+        forwardMessage('workerLog', {
+          logType: logFn,
+          message: message
+        }, instanceNo);
+      };
+      logger[logFn] = func;
+    };
+    for (var logFn in logger) {
+      _loop(logFn);
+    }
+  }
   function isEmptyResult(remuxResult) {
     return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
   }
 
+  var version = "1.5.14-0.canary.10432";
+
   // ensure the worker ends up in the bundle
   // If the worker should not be included this gets aliased to empty.js
+  var workerStore = {};
   function hasUMDWorker() {
     return typeof __HLS_WORKER_BUNDLE__ === 'function';
   }
   function injectWorker() {
+    var workerContext = workerStore[version];
+    if (workerContext) {
+      workerContext.clientCount++;
+      return workerContext;
+    }
     var blob = new self.Blob(["var exports={};var module={exports:exports};function define(f){f()};define.amd=true;(" + __HLS_WORKER_BUNDLE__.toString() + ")(true);"], {
       type: 'text/javascript'
     });
     var objectURL = self.URL.createObjectURL(blob);
     var worker = new self.Worker(objectURL);
-    return {
+    var result = {
       worker: worker,
-      objectURL: objectURL
+      objectURL: objectURL,
+      clientCount: 1
     };
+    workerStore[version] = result;
+    return result;
   }
   function loadWorker(path) {
+    var workerContext = workerStore[path];
+    if (workerContext) {
+      workerContext.clientCount++;
+      return workerContext;
+    }
     var scriptURL = new self.URL(path, self.location.href).href;
     var worker = new self.Worker(scriptURL);
-    return {
+    var result = {
       worker: worker,
-      scriptURL: scriptURL
+      scriptURL: scriptURL,
+      clientCount: 1
     };
+    workerStore[path] = result;
+    return result;
+  }
+  function removeWorkerFromStore(path) {
+    var workerContext = workerStore[path || version];
+    if (workerContext) {
+      var clientCount = workerContext.clientCount--;
+      if (clientCount === 1) {
+        var worker = workerContext.worker,
+          objectURL = workerContext.objectURL;
+        delete workerStore[path || version];
+        if (objectURL) {
+          // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
+          self.URL.revokeObjectURL(objectURL);
+        }
+        worker.terminate();
+      }
+    }
   }
 
+  var transmuxerInstanceCount = 0;
   var TransmuxerInterface = /*#__PURE__*/function () {
-    function TransmuxerInterface(hls, id, onTransmuxComplete, onFlush) {
+    function TransmuxerInterface(_hls, id, onTransmuxComplete, onFlush) {
       var _this = this;
       this.error = null;
       this.hls = void 0;
       this.id = void 0;
+      this.instanceNo = transmuxerInstanceCount++;
       this.observer = void 0;
       this.frag = null;
       this.part = null;
       this.useWorker = void 0;
       this.workerContext = null;
-      this.onwmsg = void 0;
       this.transmuxer = null;
       this.onTransmuxComplete = void 0;
       this.onFlush = void 0;
-      var config = hls.config;
-      this.hls = hls;
+      this.onWorkerMessage = function (event) {
+        var data = event.data;
+        var hls = _this.hls;
+        if (!hls || !(data != null && data.event) || data.instanceNo !== _this.instanceNo) {
+          return;
+        }
+        switch (data.event) {
+          case 'init':
+            {
+              var _this$workerContext;
+              var objectURL = (_this$workerContext = _this.workerContext) == null ? void 0 : _this$workerContext.objectURL;
+              if (objectURL) {
+                // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
+                self.URL.revokeObjectURL(objectURL);
+              }
+              break;
+            }
+          case 'transmuxComplete':
+            {
+              _this.handleTransmuxComplete(data.data);
+              break;
+            }
+          case 'flush':
+            {
+              _this.onFlush(data.data);
+              break;
+            }
+
+          // pass logs from the worker thread to the main logger
+          case 'workerLog':
+            {
+              if (hls.logger[data.data.logType]) {
+                hls.logger[data.data.logType](data.data.message);
+              }
+              break;
+            }
+          default:
+            {
+              data.data = data.data || {};
+              data.data.frag = _this.frag;
+              data.data.part = _this.part;
+              data.data.id = _this.id;
+              hls.trigger(data.event, data.data);
+              break;
+            }
+        }
+      };
+      this.onWorkerError = function (event) {
+        if (!_this.hls) {
+          return;
+        }
+        var error = new Error(event.message + "  (" + event.filename + ":" + event.lineno + ")");
+        _this.hls.config.enableWorker = false;
+        _this.hls.logger.warn("Error in \"" + _this.id + "\" Web Worker, fallback to inline");
+        _this.hls.trigger(Events.ERROR, {
+          type: ErrorTypes.OTHER_ERROR,
+          details: ErrorDetails.INTERNAL_EXCEPTION,
+          fatal: false,
+          event: 'demuxerWorker',
+          error: error
+        });
+      };
+      var config = _hls.config;
+      this.hls = _hls;
       this.id = id;
       this.useWorker = !!config.enableWorker;
       this.onTransmuxComplete = onTransmuxComplete;
       this.onFlush = onFlush;
       var forwardMessage = function forwardMessage(ev, data) {
         data = data || {};
-        data.frag = _this.frag;
-        data.id = _this.id;
+        data.frag = _this.frag || undefined;
         if (ev === Events.ERROR) {
+          data = data;
+          data.parent = _this.id;
+          data.part = _this.part;
           _this.error = data.error;
         }
         _this.hls.trigger(ev, data);
@@ -19371,6 +19497,7 @@
       this.observer.on(Events.ERROR, forwardMessage);
       var m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
       if (this.useWorker && typeof Worker !== 'undefined') {
+        var logger = this.hls.logger;
         var canCreateWorker = config.workerPath || hasUMDWorker();
         if (canCreateWorker) {
           try {
@@ -19381,61 +19508,60 @@
               logger.log("injecting Web Worker for \"" + id + "\"");
               this.workerContext = injectWorker();
             }
-            this.onwmsg = function (event) {
-              return _this.onWorkerMessage(event);
-            };
             var worker = this.workerContext.worker;
-            worker.addEventListener('message', this.onwmsg);
-            worker.onerror = function (event) {
-              var error = new Error(event.message + "  (" + event.filename + ":" + event.lineno + ")");
-              config.enableWorker = false;
-              logger.warn("Error in \"" + id + "\" Web Worker, fallback to inline");
-              _this.hls.trigger(Events.ERROR, {
-                type: ErrorTypes.OTHER_ERROR,
-                details: ErrorDetails.INTERNAL_EXCEPTION,
-                fatal: false,
-                event: 'demuxerWorker',
-                error: error
-              });
-            };
+            worker.addEventListener('message', this.onWorkerMessage);
+            worker.addEventListener('error', this.onWorkerError);
             worker.postMessage({
+              instanceNo: this.instanceNo,
               cmd: 'init',
               typeSupported: m2tsTypeSupported,
-              vendor: '',
               id: id,
               config: JSON.stringify(config)
             });
           } catch (err) {
             logger.warn("Error setting up \"" + id + "\" Web Worker, fallback to inline", err);
-            this.resetWorker();
+            this.terminateWorker();
             this.error = null;
-            this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, '', id);
+            this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, '', id, _hls.logger);
           }
           return;
         }
       }
-      this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, '', id);
+      this.transmuxer = new Transmuxer(this.observer, m2tsTypeSupported, config, '', id, _hls.logger);
     }
     var _proto = TransmuxerInterface.prototype;
-    _proto.resetWorker = function resetWorker() {
+    _proto.reset = function reset() {
+      this.frag = null;
+      this.part = null;
       if (this.workerContext) {
-        var _this$workerContext = this.workerContext,
-          worker = _this$workerContext.worker,
-          objectURL = _this$workerContext.objectURL;
-        if (objectURL) {
-          // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
-          self.URL.revokeObjectURL(objectURL);
-        }
-        worker.removeEventListener('message', this.onwmsg);
-        worker.onerror = null;
-        worker.terminate();
+        var instanceNo = this.instanceNo;
+        this.instanceNo = transmuxerInstanceCount++;
+        var config = this.hls.config;
+        var m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
+        this.workerContext.worker.postMessage({
+          instanceNo: this.instanceNo,
+          cmd: 'reset',
+          resetNo: instanceNo,
+          typeSupported: m2tsTypeSupported,
+          id: this.id,
+          config: JSON.stringify(config)
+        });
+      }
+    };
+    _proto.terminateWorker = function terminateWorker() {
+      if (this.workerContext) {
+        var worker = this.workerContext.worker;
         this.workerContext = null;
+        worker.removeEventListener('message', this.onWorkerMessage);
+        worker.removeEventListener('error', this.onWorkerError);
+        removeWorkerFromStore(this.hls.config.workerPath);
       }
     };
     _proto.destroy = function destroy() {
       if (this.workerContext) {
-        this.resetWorker();
-        this.onwmsg = undefined;
+        this.terminateWorker();
+        // @ts-ignore
+        this.onWorkerMessage = this.onWorkerError = null;
       } else {
         var transmuxer = this.transmuxer;
         if (transmuxer) {
@@ -19448,6 +19574,7 @@
         observer.removeAllListeners();
       }
       this.frag = null;
+      this.part = null;
       // @ts-ignore
       this.observer = null;
       // @ts-ignore
@@ -19458,7 +19585,8 @@
         _lastFrag$initSegment,
         _this2 = this;
       chunkMeta.transmuxing.start = self.performance.now();
-      var transmuxer = this.transmuxer;
+      var instanceNo = this.instanceNo,
+        transmuxer = this.transmuxer;
       var timeOffset = part ? part.start : frag.start;
       // TODO: push "clear-lead" decrypt data for unencrypted fragments in streams with encrypted ones
       var decryptdata = frag.decryptdata;
@@ -19479,7 +19607,7 @@
       var initSegmentChange = !(lastFrag && ((_frag$initSegment = frag.initSegment) == null ? void 0 : _frag$initSegment.url) === ((_lastFrag$initSegment = lastFrag.initSegment) == null ? void 0 : _lastFrag$initSegment.url));
       var state = new TransmuxState(discontinuity, contiguous, accurateTimeOffset, trackSwitch, timeOffset, initSegmentChange);
       if (!contiguous || discontinuity || initSegmentChange) {
-        logger.log("[transmuxer-interface, " + frag.type + "]: Starting new transmux session for sn: " + chunkMeta.sn + " p: " + chunkMeta.part + " level: " + chunkMeta.level + " id: " + chunkMeta.id + "\n        discontinuity: " + discontinuity + "\n        trackSwitch: " + trackSwitch + "\n        contiguous: " + contiguous + "\n        accurateTimeOffset: " + accurateTimeOffset + "\n        timeOffset: " + timeOffset + "\n        initSegmentChange: " + initSegmentChange);
+        this.hls.logger.log("[transmuxer-interface, " + frag.type + "]: Starting new transmux session for sn: " + chunkMeta.sn + " p: " + chunkMeta.part + " level: " + chunkMeta.level + " id: " + chunkMeta.id + "\n        discontinuity: " + discontinuity + "\n        trackSwitch: " + trackSwitch + "\n        contiguous: " + contiguous + "\n        accurateTimeOffset: " + accurateTimeOffset + "\n        timeOffset: " + timeOffset + "\n        initSegmentChange: " + initSegmentChange);
         var config = new TransmuxConfig(audioCodec, videoCodec, initSegmentData, duration, defaultInitPTS);
         this.configureTransmuxer(config);
       }
@@ -19490,6 +19618,7 @@
       if (this.workerContext) {
         // post fragment payload as transferable objects for ArrayBuffer (no copy)
         this.workerContext.worker.postMessage({
+          instanceNo: instanceNo,
           cmd: 'demux',
           data: data,
           decryptdata: decryptdata,
@@ -19499,14 +19628,12 @@
       } else if (transmuxer) {
         var transmuxResult = transmuxer.push(data, decryptdata, chunkMeta, state);
         if (isPromise(transmuxResult)) {
-          transmuxer.async = true;
           transmuxResult.then(function (data) {
             _this2.handleTransmuxComplete(data);
           }).catch(function (error) {
             _this2.transmuxerError(error, chunkMeta, 'transmuxer-interface push error');
           });
         } else {
-          transmuxer.async = false;
           this.handleTransmuxComplete(transmuxResult);
         }
       }
@@ -19514,19 +19641,17 @@
     _proto.flush = function flush(chunkMeta) {
       var _this3 = this;
       chunkMeta.transmuxing.start = self.performance.now();
-      var transmuxer = this.transmuxer;
+      var instanceNo = this.instanceNo,
+        transmuxer = this.transmuxer;
       if (this.workerContext) {
         this.workerContext.worker.postMessage({
+          instanceNo: instanceNo,
           cmd: 'flush',
           chunkMeta: chunkMeta
         });
       } else if (transmuxer) {
         var transmuxResult = transmuxer.flush(chunkMeta);
-        var asyncFlush = isPromise(transmuxResult);
-        if (asyncFlush || transmuxer.async) {
-          if (!isPromise(transmuxResult)) {
-            transmuxResult = Promise.resolve(transmuxResult);
-          }
+        if (isPromise(transmuxResult)) {
           transmuxResult.then(function (data) {
             _this3.handleFlushResult(data, chunkMeta);
           }).catch(function (error) {
@@ -19547,6 +19672,7 @@
         details: ErrorDetails.FRAG_PARSING_ERROR,
         chunkMeta: chunkMeta,
         frag: this.frag || undefined,
+        part: this.part || undefined,
         fatal: false,
         error: error,
         err: error,
@@ -19560,58 +19686,12 @@
       });
       this.onFlush(chunkMeta);
     };
-    _proto.onWorkerMessage = function onWorkerMessage(event) {
-      var data = event.data;
-      if (!(data != null && data.event)) {
-        logger.warn("worker message received with no " + (data ? 'event name' : 'data'));
-        return;
-      }
-      var hls = this.hls;
-      if (!this.hls) {
-        return;
-      }
-      switch (data.event) {
-        case 'init':
-          {
-            var _this$workerContext2;
-            var objectURL = (_this$workerContext2 = this.workerContext) == null ? void 0 : _this$workerContext2.objectURL;
-            if (objectURL) {
-              // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
-              self.URL.revokeObjectURL(objectURL);
-            }
-            break;
-          }
-        case 'transmuxComplete':
-          {
-            this.handleTransmuxComplete(data.data);
-            break;
-          }
-        case 'flush':
-          {
-            this.onFlush(data.data);
-            break;
-          }
-
-        // pass logs from the worker thread to the main logger
-        case 'workerLog':
-          if (logger[data.data.logType]) {
-            logger[data.data.logType](data.data.message);
-          }
-          break;
-        default:
-          {
-            data.data = data.data || {};
-            data.data.frag = this.frag;
-            data.data.id = this.id;
-            hls.trigger(data.event, data.data);
-            break;
-          }
-      }
-    };
     _proto.configureTransmuxer = function configureTransmuxer(config) {
-      var transmuxer = this.transmuxer;
+      var instanceNo = this.instanceNo,
+        transmuxer = this.transmuxer;
       if (this.workerContext) {
         this.workerContext.worker.postMessage({
+          instanceNo: instanceNo,
           cmd: 'configure',
           config: config
         });
@@ -21987,7 +22067,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.14-0.canary.10429";
+        return version;
       }
     }, {
       key: "Events",