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

package/dist/hls.js

@@ -522,7 +522,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.10431");
+        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();
@@ -10188,6 +10188,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;
@@ -11303,10 +11307,8 @@
       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() {
-      if (this.transmuxer) {
-        this.transmuxer.destroy();
-        this.transmuxer = null;
-      }
+      var _this$transmuxer2;
+      (_this$transmuxer2 = this.transmuxer) == null ? void 0 : _this$transmuxer2.reset();
     };
     _proto.recoverWorkerError = function recoverWorkerError(data) {
       if (data.event === 'demuxerWorker') {
@@ -12054,7 +12056,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;
       }
@@ -13723,7 +13725,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;
@@ -13743,9 +13746,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);
@@ -13912,7 +13916,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':
@@ -13941,7 +13945,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);
@@ -13968,7 +13972,7 @@
               break;
             case id3Pid:
               if (stt) {
-                if (id3Data && (pes = parsePES(id3Data))) {
+                if (id3Data && (pes = parsePES(id3Data, this.logger))) {
                   this.parseID3PES(id3Track, pes);
                 }
                 id3Data = {
@@ -13986,14 +13990,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
@@ -14016,7 +14020,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;
@@ -14036,7 +14040,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;
@@ -14082,7 +14086,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':
@@ -14103,7 +14107,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);
@@ -14120,13 +14124,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 {
@@ -14198,7 +14202,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;
         }
@@ -14213,7 +14217,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;
       }
 
@@ -14243,7 +14247,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) {
@@ -14267,7 +14271,7 @@
         var data = pes.data;
         var pts = pes.pts;
         if (pts === undefined) {
-          logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
+          this.logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
           return;
         }
         var length = data.length;
@@ -14281,7 +14285,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, {
@@ -14300,7 +14304,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,
@@ -14322,7 +14326,7 @@
         case 0xcf:
           // SAMPLE-AES AAC
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC');
+            logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC', this.logger);
             break;
           }
         /* falls through */
@@ -14344,7 +14348,7 @@
         case 0xdb:
           // SAMPLE-AES AVC
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('H.264');
+            logEncryptedSamplesFoundInUnencryptedStream('H.264', this.logger);
             break;
           }
         /* falls through */
@@ -14372,7 +14376,7 @@
         case 0xc1:
           // SAMPLE-AES AC3
           if (!isSampleAes) {
-            logEncryptedSamplesFoundInUnencryptedStream('AC-3');
+            logEncryptedSamplesFoundInUnencryptedStream('AC-3', this.logger);
             break;
           }
         /* falls through */
@@ -14418,7 +14422,7 @@
         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)
@@ -14437,7 +14441,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,
@@ -14448,10 +14452,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;
@@ -15366,7 +15370,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;
@@ -15382,6 +15387,7 @@
       this.observer = observer;
       this.config = config;
       this.typeSupported = typeSupported;
+      this.logger = logger;
       this.ISGenerated = false;
       if (chromeVersion === null) {
         var userAgent = navigator.userAgent || '';
@@ -15399,16 +15405,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;
     };
@@ -15427,7 +15433,7 @@
         }
       }, videoSamples[0].pts);
       if (rolloverDetected) {
-        logger.debug('PTS rollover detected');
+        this.logger.debug('PTS rollover detected');
       }
       return startPTS;
     };
@@ -15471,14 +15477,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;
             }
           }
@@ -15500,7 +15506,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);
@@ -15508,7 +15514,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);
@@ -15714,9 +15720,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;
@@ -15745,7 +15751,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");
           }
         }
       }
@@ -15845,7 +15851,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;
             }
@@ -15873,7 +15879,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;
@@ -16000,7 +16006,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
@@ -16022,12 +16028,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, {
@@ -16227,7 +16233,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;
@@ -16235,6 +16242,7 @@
       this.initPTS = null;
       this.initTracks = void 0;
       this.lastEndTime = null;
+      this.logger = logger;
     }
     var _proto = PassThroughRemuxer.prototype;
     _proto.destroy = function destroy() {};
@@ -16291,7 +16299,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;
     };
@@ -16331,7 +16339,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) {
@@ -16344,7 +16352,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,
@@ -16357,7 +16365,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;
@@ -16416,12 +16424,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';
     }
@@ -16436,8 +16444,7 @@
   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,
@@ -16459,8 +16466,9 @@
     });
   }
   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;
@@ -16478,6 +16486,7 @@
       this.config = config;
       this.vendor = vendor;
       this.id = id;
+      this.logger = logger;
     }
     var _proto = Transmuxer.prototype;
     _proto.configure = function configure(transmuxConfig) {
@@ -16529,6 +16538,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
@@ -16543,7 +16553,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,
@@ -16565,6 +16575,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;
@@ -16583,6 +16594,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 () {
@@ -16606,10 +16618,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);
@@ -16617,6 +16634,9 @@
         });
       }
       this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
+      if (this.asyncResult) {
+        return Promise.resolve(transmuxResults);
+      }
       return transmuxResults;
     };
     _proto.flushRemux = function flushRemux(transmuxResults, demuxResult, chunkMeta) {
@@ -16627,7 +16647,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,
@@ -16706,13 +16726,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;
         }
@@ -16726,10 +16746,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;
       }
     };
@@ -17133,63 +17153,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,
@@ -17197,25 +17208,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,
@@ -17225,17 +17231,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;
     }
@@ -17251,7 +17257,8 @@
     }
     self.postMessage({
       event: 'transmuxComplete',
-      data: transmuxResult
+      data: transmuxResult,
+      instanceNo: instanceNo
     }, transferable);
     return true;
   }
@@ -17266,77 +17273,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);
@@ -17348,6 +17478,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 {
@@ -17358,61 +17489,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) {
@@ -17425,6 +17555,7 @@
         observer.removeAllListeners();
       }
       this.frag = null;
+      this.part = null;
       // @ts-ignore
       this.observer = null;
       // @ts-ignore
@@ -17435,7 +17566,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;
@@ -17456,7 +17588,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);
       }
@@ -17467,6 +17599,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,
@@ -17476,14 +17609,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);
         }
       }
@@ -17491,19 +17622,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) {
@@ -17524,6 +17653,7 @@
         details: ErrorDetails.FRAG_PARSING_ERROR,
         chunkMeta: chunkMeta,
         frag: this.frag || undefined,
+        part: this.part || undefined,
         fatal: false,
         error: error,
         err: error,
@@ -17537,58 +17667,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
         });
@@ -30787,7 +30871,7 @@
        * Get the video-dev/hls.js package version.
        */
       function get() {
-        return "1.5.14-0.canary.10431";
+        return version;
       }
     }, {
       key: "Events",