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

package/dist/hls.mjs

@@ -420,7 +420,7 @@ function enableLogs(debugConfig, context, id) {
     // 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();
@@ -8674,30 +8674,14 @@ function findFirstFragWithCC(fragments, cc) {
   }
   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) {
-  const prevFrags = prevDetails.fragments;
-  const curFrags = curDetails.fragments;
-  if (!curFrags.length || !prevFrags.length) {
-    logger.log('No fragments to align');
-    return;
-  }
-  const 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) {
     const start = frag.start + sliding;
@@ -8732,7 +8716,7 @@ function alignStream(lastFrag, switchDetails, details) {
   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
@@ -8748,20 +8732,24 @@ function alignStream(lastFrag, switchDetails, details) {
 }
 
 /**
- * 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)) {
-    const 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;
+  }
+  const targetCC = Math.min(refDetails.endCC, details.endCC);
+  const refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
+  const frag = findFirstFragWithCC(details.fragments, targetCC);
+  if (!refFrag || !frag) {
+    return;
   }
+  logger.log(`Aligning playlist at start of dicontinuity sequence ${targetCC}`);
+  const delta = refFrag.start - frag.start;
+  adjustSlidingStart(delta, details);
 }
 
 /**
@@ -9850,6 +9838,10 @@ class BaseStreamController extends TaskLoop {
   }
   onHandlerDestroying() {
     this.stopLoad();
+    if (this.transmuxer) {
+      this.transmuxer.destroy();
+      this.transmuxer = null;
+    }
     super.onHandlerDestroying();
     // @ts-ignore
     this.hls = this.onMediaSeeking = this.onMediaEnded = null;
@@ -9896,7 +9888,7 @@ class BaseStreamController extends TaskLoop {
         return;
       }
       if ('payload' in data) {
-        this.log(`Loaded fragment ${frag.sn} of level ${frag.level}`);
+        this.log(`Loaded ${frag.type} sn: ${frag.sn} of ${this.playlistLabel()} ${frag.level}`);
         this.hls.trigger(Events.FRAG_LOADED, data);
       }
 
@@ -10046,9 +10038,9 @@ class BaseStreamController extends TaskLoop {
     return !frag || !fragCurrent || frag.sn !== fragCurrent.sn || frag.level !== fragCurrent.level;
   }
   fragBufferedComplete(frag, part) {
-    var _frag$startPTS, _frag$endPTS, _this$fragCurrent, _this$fragPrevious;
+    var _this$fragCurrent, _this$fragPrevious;
     const 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) {
@@ -10105,7 +10097,7 @@ class BaseStreamController extends TaskLoop {
     }
     let 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(keyLoadedData => {
@@ -10144,7 +10136,7 @@ class BaseStreamController extends TaskLoop {
         const partIndex = this.getNextPart(partList, frag, targetBufferTime);
         if (partIndex > -1) {
           const 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;
           let _result;
@@ -10180,7 +10172,7 @@ class BaseStreamController extends TaskLoop {
       // 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;
@@ -10959,16 +10951,22 @@ class BaseStreamController extends TaskLoop {
       // 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,
       part
     });
   }
+  playlistLabel() {
+    return this.playlistType === PlaylistLevelType.MAIN ? 'level' : 'track';
+  }
+  fragInfo(frag, pts = true) {
+    var _ref, _ref2;
+    return `${this.playlistLabel()} ${frag.level} (frag:[${((_ref = pts ? frag.startPTS : frag.start) != null ? _ref : NaN).toFixed(3)}-${((_ref2 = pts ? frag.endPTS : frag.end) != null ? _ref2 : NaN).toFixed(3)}]`;
+  }
   resetTransmuxer() {
-    if (this.transmuxer) {
-      this.transmuxer.destroy();
-      this.transmuxer = null;
-    }
+    var _this$transmuxer2;
+    (_this$transmuxer2 = this.transmuxer) == null ? void 0 : _this$transmuxer2.reset();
   }
   recoverWorkerError(data) {
     if (data.event === 'demuxerWorker') {
@@ -11031,29 +11029,66 @@ function concatUint8Arrays(chunks, dataLength) {
   return result;
 }
 
+const 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
+const workerStore = {};
 function hasUMDWorker() {
   return typeof __HLS_WORKER_BUNDLE__ === 'function';
 }
 function injectWorker() {
+  const workerContext = workerStore[version];
+  if (workerContext) {
+    workerContext.clientCount++;
+    return workerContext;
+  }
   const 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'
   });
   const objectURL = self.URL.createObjectURL(blob);
   const worker = new self.Worker(objectURL);
-  return {
+  const result = {
     worker,
-    objectURL
+    objectURL,
+    clientCount: 1
   };
+  workerStore[version] = result;
+  return result;
 }
 function loadWorker(path) {
+  const workerContext = workerStore[path];
+  if (workerContext) {
+    workerContext.clientCount++;
+    return workerContext;
+  }
   const scriptURL = new self.URL(path, self.location.href).href;
   const worker = new self.Worker(scriptURL);
-  return {
+  const result = {
     worker,
-    scriptURL
+    scriptURL,
+    clientCount: 1
   };
+  workerStore[path] = result;
+  return result;
+}
+function removeWorkerFromStore(path) {
+  const workerContext = workerStore[path || version];
+  if (workerContext) {
+    const clientCount = workerContext.clientCount--;
+    if (clientCount === 1) {
+      const {
+        worker,
+        objectURL
+      } = workerContext;
+      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();
+    }
+  }
 }
 
 function dummyTrack(type = '', inputTimeScale = 90000) {
@@ -11730,7 +11765,7 @@ class AACDemuxer extends BaseAudioDemuxer {
   }
 
   // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
-  static probe(data) {
+  static probe(data, logger) {
     if (!data) {
       return false;
     }
@@ -13356,7 +13391,8 @@ class SampleAesDecrypter {
 
 const PACKET_LENGTH = 188;
 class TSDemuxer {
-  constructor(observer, config, typeSupported) {
+  constructor(observer, config, typeSupported, logger) {
+    this.logger = void 0;
     this.observer = void 0;
     this.config = void 0;
     this.typeSupported = void 0;
@@ -13376,9 +13412,10 @@ class TSDemuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
+    this.logger = logger;
     this.videoParser = null;
   }
-  static probe(data) {
+  static probe(data, logger) {
     const syncOffset = TSDemuxer.syncOffset(data);
     if (syncOffset > 0) {
       logger.warn(`MPEG2-TS detected but first sync word found @ offset ${syncOffset}`);
@@ -13540,7 +13577,7 @@ class TSDemuxer {
         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':
@@ -13569,7 +13606,7 @@ class TSDemuxer {
             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);
@@ -13596,7 +13633,7 @@ class TSDemuxer {
             break;
           case id3Pid:
             if (stt) {
-              if (id3Data && (pes = parsePES(id3Data))) {
+              if (id3Data && (pes = parsePES(id3Data, this.logger))) {
                 this.parseID3PES(id3Track, pes);
               }
               id3Data = {
@@ -13614,14 +13651,14 @@ class TSDemuxer {
               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;
               }
-              const parsedPIDs = parsePMT(data, offset, this.typeSupported, isSampleAes, this.observer);
+              const 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
@@ -13644,7 +13681,7 @@ class TSDemuxer {
                 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;
@@ -13664,7 +13701,7 @@ class TSDemuxer {
       }
     }
     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;
@@ -13714,7 +13751,7 @@ class TSDemuxer {
     const id3Data = id3Track.pesData;
     // try to parse last PES packets
     let pes;
-    if (videoData && (pes = parsePES(videoData))) {
+    if (videoData && (pes = parsePES(videoData, this.logger))) {
       if (this.videoParser === null) {
         switch (videoTrack.segmentCodec) {
           case 'avc':
@@ -13735,7 +13772,7 @@ class TSDemuxer {
       // 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);
@@ -13752,13 +13789,13 @@ class TSDemuxer {
       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 {
@@ -13832,7 +13869,7 @@ class TSDemuxer {
       } 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;
       }
@@ -13847,7 +13884,7 @@ class TSDemuxer {
       const 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;
     }
 
@@ -13877,7 +13914,7 @@ class TSDemuxer {
     let offset = 0;
     const 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) {
@@ -13901,7 +13938,7 @@ class TSDemuxer {
       const data = pes.data;
       const pts = pes.pts;
       if (pts === undefined) {
-        logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
+        this.logger.warn('[tsdemuxer]: AC3 PES unknown PTS');
         return;
       }
       const length = data.length;
@@ -13915,7 +13952,7 @@ class TSDemuxer {
   }
   parseID3PES(id3Track, pes) {
     if (pes.pts === undefined) {
-      logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
+      this.logger.warn('[tsdemuxer]: ID3 PES unknown PTS');
       return;
     }
     const id3Sample = _extends({}, pes, {
@@ -13933,7 +13970,7 @@ function parsePAT(data, offset) {
   // 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) {
   const result = {
     audioPid: -1,
     videoPid: -1,
@@ -13955,7 +13992,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
       case 0xcf:
         // SAMPLE-AES AAC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC');
+          logEncryptedSamplesFoundInUnencryptedStream('ADTS AAC', this.logger);
           break;
         }
       /* falls through */
@@ -13977,7 +14014,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
       case 0xdb:
         // SAMPLE-AES AVC
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('H.264');
+          logEncryptedSamplesFoundInUnencryptedStream('H.264', this.logger);
           break;
         }
       /* falls through */
@@ -14005,7 +14042,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
       case 0xc1:
         // SAMPLE-AES AC3
         if (!isSampleAes) {
-          logEncryptedSamplesFoundInUnencryptedStream('AC-3');
+          logEncryptedSamplesFoundInUnencryptedStream('AC-3', this.logger);
           break;
         }
       /* falls through */
@@ -14051,7 +14088,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
       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)
@@ -14070,7 +14107,7 @@ function parsePMT(data, offset, typeSupported, isSampleAes, observer) {
   }
   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,
@@ -14081,10 +14118,10 @@ function emitParsingError(observer, error, levelRetry) {
     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) {
   let i = 0;
   let frag;
   let pesLen;
@@ -14975,7 +15012,8 @@ const AC3_SAMPLES_PER_FRAME = 1536;
 let chromeVersion = null;
 let safariWebkitVersion = null;
 class MP4Remuxer {
-  constructor(observer, config, typeSupported, vendor = '') {
+  constructor(observer, config, typeSupported, logger) {
+    this.logger = void 0;
     this.observer = void 0;
     this.config = void 0;
     this.typeSupported = void 0;
@@ -14991,6 +15029,7 @@ class MP4Remuxer {
     this.observer = observer;
     this.config = config;
     this.typeSupported = typeSupported;
+    this.logger = logger;
     this.ISGenerated = false;
     if (chromeVersion === null) {
       const userAgent = navigator.userAgent || '';
@@ -15007,16 +15046,16 @@ class MP4Remuxer {
     this.config = this.videoTrackConfig = this._initPTS = this._initDTS = null;
   }
   resetTimeStamp(defaultTimeStamp) {
-    logger.log('[mp4-remuxer]: initPTS & initDTS reset');
+    this.logger.log('[mp4-remuxer]: initPTS & initDTS reset');
     this._initPTS = this._initDTS = defaultTimeStamp;
   }
   resetNextTimestamp() {
-    logger.log('[mp4-remuxer]: reset next timestamp');
+    this.logger.log('[mp4-remuxer]: reset next timestamp');
     this.isVideoContiguous = false;
     this.isAudioContiguous = false;
   }
   resetInitSegment() {
-    logger.log('[mp4-remuxer]: ISGenerated flag reset');
+    this.logger.log('[mp4-remuxer]: ISGenerated flag reset');
     this.ISGenerated = false;
     this.videoTrackConfig = undefined;
   }
@@ -15035,7 +15074,7 @@ class MP4Remuxer {
       }
     }, videoSamples[0].pts);
     if (rolloverDetected) {
-      logger.debug('PTS rollover detected');
+      this.logger.debug('PTS rollover detected');
     }
     return startPTS;
   }
@@ -15079,14 +15118,14 @@ class MP4Remuxer {
         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`);
             const 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;
           }
         }
@@ -15108,7 +15147,7 @@ class MP4Remuxer {
         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);
@@ -15116,7 +15155,7 @@ class MP4Remuxer {
             const 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);
@@ -15322,9 +15361,9 @@ class MP4Remuxer {
       const 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;
@@ -15353,7 +15392,7 @@ class MP4Remuxer {
               }
             }
           }
-          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`);
         }
       }
     }
@@ -15453,7 +15492,7 @@ class MP4Remuxer {
             } 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;
           }
@@ -15481,7 +15520,7 @@ class MP4Remuxer {
         // 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.');
           let dts = firstDTS;
           for (let i = 0, len = outputSamples.length; i < len; i++) {
             const nextDts = dts + outputSamples[i].duration;
@@ -15606,7 +15645,7 @@ class MP4Remuxer {
         // 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
@@ -15628,12 +15667,12 @@ class MP4Remuxer {
           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 (let j = 0; j < missing; j++) {
             const newStamp = Math.max(nextPts, 0);
             let 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, {
@@ -15832,7 +15871,8 @@ class Mp4Sample {
 }
 
 class PassThroughRemuxer {
-  constructor() {
+  constructor(observer, config, typeSupported, logger) {
+    this.logger = void 0;
     this.emitInitSegment = false;
     this.audioCodec = void 0;
     this.videoCodec = void 0;
@@ -15840,6 +15880,7 @@ class PassThroughRemuxer {
     this.initPTS = null;
     this.initTracks = void 0;
     this.lastEndTime = null;
+    this.logger = logger;
   }
   destroy() {}
   resetTimeStamp(defaultInitPTS) {
@@ -15897,7 +15938,7 @@ class PassThroughRemuxer {
         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;
   }
@@ -15939,7 +15980,7 @@ class PassThroughRemuxer {
     }
     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) {
@@ -15952,7 +15993,7 @@ class PassThroughRemuxer {
     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,
@@ -15965,7 +16006,7 @@ class PassThroughRemuxer {
     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();
     }
     const hasAudio = !!initData.audio;
@@ -16023,12 +16064,12 @@ function getParsedTrackCodec(track, type) {
       return getCodecCompatibleName(parsedCodec, preferManagedMediaSource);
     }
     const 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';
   }
@@ -16043,8 +16084,7 @@ let now;
 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;
 }
 const muxConfig = [{
   demux: MP4Demuxer,
@@ -16066,8 +16106,9 @@ const muxConfig = [{
   });
 }
 class Transmuxer {
-  constructor(observer, typeSupported, config, vendor, id) {
-    this.async = false;
+  constructor(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;
@@ -16085,6 +16126,7 @@ class Transmuxer {
     this.config = config;
     this.vendor = vendor;
     this.id = id;
+    this.logger = logger;
   }
   configure(transmuxConfig) {
     this.transmuxConfig = transmuxConfig;
@@ -16139,6 +16181,7 @@ class Transmuxer {
         }
         uintData = new Uint8Array(decryptedData);
       } else {
+        this.asyncResult = true;
         this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer, aesMode).then(decryptedData => {
           // Calling push here is important; if flush() is called while this is still resolving, this ensures that
           // the decrypted data has been transmuxed
@@ -16153,7 +16196,7 @@ class Transmuxer {
     if (resetMuxers) {
       const 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,
@@ -16175,6 +16218,7 @@ class Transmuxer {
       this.resetContiguity();
     }
     const result = this.transmux(uintData, keyData, timeOffset, accurateTimeOffset, chunkMeta);
+    this.asyncResult = isPromise(result);
     const currentState = this.currentTransmuxState;
     currentState.contiguous = true;
     currentState.discontinuity = false;
@@ -16193,6 +16237,7 @@ class Transmuxer {
       decryptionPromise
     } = this;
     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(() => {
@@ -16220,10 +16265,15 @@ class Transmuxer {
     if (!demuxer || !remuxer) {
       // If probing failed, then Hls.js has been given content its not able to handle
       stats.executeEnd = now();
-      return [emptyResult(chunkMeta)];
+      const emptyResults = [emptyResult(chunkMeta)];
+      if (this.asyncResult) {
+        return Promise.resolve(emptyResults);
+      }
+      return emptyResults;
     }
     const demuxResultOrPromise = demuxer.flush(timeOffset);
     if (isPromise(demuxResultOrPromise)) {
+      this.asyncResult = true;
       // Decrypt final SAMPLE-AES samples
       return demuxResultOrPromise.then(demuxResult => {
         this.flushRemux(transmuxResults, demuxResult, chunkMeta);
@@ -16231,6 +16281,9 @@ class Transmuxer {
       });
     }
     this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
+    if (this.asyncResult) {
+      return Promise.resolve(transmuxResults);
+    }
     return transmuxResults;
   }
   flushRemux(transmuxResults, demuxResult, chunkMeta) {
@@ -16244,7 +16297,7 @@ class Transmuxer {
       accurateTimeOffset,
       timeOffset
     } = this.currentTransmuxState;
-    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}`);
     const remuxResult = this.remuxer.remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, true, this.id);
     transmuxResults.push({
       remuxResult,
@@ -16337,7 +16390,7 @@ class Transmuxer {
     let mux;
     for (let 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;
       }
@@ -16351,10 +16404,10 @@ class Transmuxer {
     const Remuxer = mux.remux;
     const 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;
     }
   }
@@ -16759,31 +16812,96 @@ var eventemitter3 = {exports: {}};
 var eventemitter3Exports = eventemitter3.exports;
 var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
+let transmuxerInstanceCount = 0;
 class TransmuxerInterface {
-  constructor(hls, id, onTransmuxComplete, onFlush) {
+  constructor(_hls, id, onTransmuxComplete, onFlush) {
     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;
-    const config = hls.config;
-    this.hls = hls;
+    this.onWorkerMessage = event => {
+      const data = event.data;
+      const hls = this.hls;
+      if (!hls || !(data != null && data.event) || data.instanceNo !== this.instanceNo) {
+        return;
+      }
+      switch (data.event) {
+        case 'init':
+          {
+            var _this$workerContext;
+            const 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 = event => {
+      if (!this.hls) {
+        return;
+      }
+      const 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
+      });
+    };
+    const config = _hls.config;
+    this.hls = _hls;
     this.id = id;
     this.useWorker = !!config.enableWorker;
     this.onTransmuxComplete = onTransmuxComplete;
     this.onFlush = onFlush;
     const 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);
@@ -16795,6 +16913,7 @@ class TransmuxerInterface {
     this.observer.on(Events.ERROR, forwardMessage);
     const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
     if (this.useWorker && typeof Worker !== 'undefined') {
+      const logger = this.hls.logger;
       const canCreateWorker = config.workerPath || hasUMDWorker();
       if (canCreateWorker) {
         try {
@@ -16805,61 +16924,63 @@ class TransmuxerInterface {
             logger.log(`injecting Web Worker for "${id}"`);
             this.workerContext = injectWorker();
           }
-          this.onwmsg = event => this.onWorkerMessage(event);
           const {
             worker
           } = this.workerContext;
-          worker.addEventListener('message', this.onwmsg);
-          worker.onerror = event => {
-            const 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
-            });
-          };
+          worker.addEventListener('message', this.onWorkerMessage);
+          worker.addEventListener('error', this.onWorkerError);
           worker.postMessage({
+            instanceNo: this.instanceNo,
             cmd: 'init',
             typeSupported: m2tsTypeSupported,
-            vendor: '',
-            id: 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);
+  }
+  reset() {
+    this.frag = null;
+    this.part = null;
+    if (this.workerContext) {
+      const instanceNo = this.instanceNo;
+      this.instanceNo = transmuxerInstanceCount++;
+      const config = this.hls.config;
+      const m2tsTypeSupported = getM2TSSupportedAudioTypes(config.preferManagedMediaSource);
+      this.workerContext.worker.postMessage({
+        instanceNo: this.instanceNo,
+        cmd: 'reset',
+        resetNo: instanceNo,
+        typeSupported: m2tsTypeSupported,
+        id: this.id,
+        config: JSON.stringify(config)
+      });
+    }
   }
-  resetWorker() {
+  terminateWorker() {
     if (this.workerContext) {
       const {
-        worker,
-        objectURL
+        worker
       } = this.workerContext;
-      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();
       this.workerContext = null;
+      worker.removeEventListener('message', this.onWorkerMessage);
+      worker.removeEventListener('error', this.onWorkerError);
+      removeWorkerFromStore(this.hls.config.workerPath);
     }
   }
   destroy() {
     if (this.workerContext) {
-      this.resetWorker();
-      this.onwmsg = undefined;
+      this.terminateWorker();
+      // @ts-ignore
+      this.onWorkerMessage = this.onWorkerError = null;
     } else {
       const transmuxer = this.transmuxer;
       if (transmuxer) {
@@ -16872,6 +16993,7 @@ class TransmuxerInterface {
       observer.removeAllListeners();
     }
     this.frag = null;
+    this.part = null;
     // @ts-ignore
     this.observer = null;
     // @ts-ignore
@@ -16881,6 +17003,7 @@ class TransmuxerInterface {
     var _frag$initSegment, _lastFrag$initSegment;
     chunkMeta.transmuxing.start = self.performance.now();
     const {
+      instanceNo,
       transmuxer
     } = this;
     const timeOffset = part ? part.start : frag.start;
@@ -16903,7 +17026,7 @@ class TransmuxerInterface {
     const initSegmentChange = !(lastFrag && ((_frag$initSegment = frag.initSegment) == null ? void 0 : _frag$initSegment.url) === ((_lastFrag$initSegment = lastFrag.initSegment) == null ? void 0 : _lastFrag$initSegment.url));
     const 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}
+      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}
         discontinuity: ${discontinuity}
         trackSwitch: ${trackSwitch}
         contiguous: ${contiguous}
@@ -16920,6 +17043,7 @@ class TransmuxerInterface {
     if (this.workerContext) {
       // post fragment payload as transferable objects for ArrayBuffer (no copy)
       this.workerContext.worker.postMessage({
+        instanceNo,
         cmd: 'demux',
         data,
         decryptdata,
@@ -16929,14 +17053,12 @@ class TransmuxerInterface {
     } else if (transmuxer) {
       const transmuxResult = transmuxer.push(data, decryptdata, chunkMeta, state);
       if (isPromise(transmuxResult)) {
-        transmuxer.async = true;
         transmuxResult.then(data => {
           this.handleTransmuxComplete(data);
         }).catch(error => {
           this.transmuxerError(error, chunkMeta, 'transmuxer-interface push error');
         });
       } else {
-        transmuxer.async = false;
         this.handleTransmuxComplete(transmuxResult);
       }
     }
@@ -16944,20 +17066,18 @@ class TransmuxerInterface {
   flush(chunkMeta) {
     chunkMeta.transmuxing.start = self.performance.now();
     const {
+      instanceNo,
       transmuxer
     } = this;
     if (this.workerContext) {
       this.workerContext.worker.postMessage({
+        instanceNo,
         cmd: 'flush',
         chunkMeta
       });
     } else if (transmuxer) {
-      let transmuxResult = transmuxer.flush(chunkMeta);
-      const asyncFlush = isPromise(transmuxResult);
-      if (asyncFlush || transmuxer.async) {
-        if (!isPromise(transmuxResult)) {
-          transmuxResult = Promise.resolve(transmuxResult);
-        }
+      const transmuxResult = transmuxer.flush(chunkMeta);
+      if (isPromise(transmuxResult)) {
         transmuxResult.then(data => {
           this.handleFlushResult(data, chunkMeta);
         }).catch(error => {
@@ -16978,6 +17098,7 @@ class TransmuxerInterface {
       details: ErrorDetails.FRAG_PARSING_ERROR,
       chunkMeta,
       frag: this.frag || undefined,
+      part: this.part || undefined,
       fatal: false,
       error,
       err: error,
@@ -16990,60 +17111,14 @@ class TransmuxerInterface {
     });
     this.onFlush(chunkMeta);
   }
-  onWorkerMessage(event) {
-    const data = event.data;
-    if (!(data != null && data.event)) {
-      logger.warn(`worker message received with no ${data ? 'event name' : 'data'}`);
-      return;
-    }
-    const hls = this.hls;
-    if (!this.hls) {
-      return;
-    }
-    switch (data.event) {
-      case 'init':
-        {
-          var _this$workerContext;
-          const 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 (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;
-        }
-    }
-  }
   configureTransmuxer(config) {
     const {
+      instanceNo,
       transmuxer
     } = this;
     if (this.workerContext) {
       this.workerContext.worker.postMessage({
+        instanceNo,
         cmd: 'configure',
         config
       });
@@ -29268,7 +29343,7 @@ class Hls {
    * Get the video-dev/hls.js package version.
    */
   static get version() {
-    return "1.5.14-0.canary.10429";
+    return version;
   }
 
   /**