spessasynth_lib 4.0.19 → 4.1.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { KeyModifier } from "spessasynth_core";
 function fillWithDefaults(obj, defObj) {
   return {
     ...defObj,
-    ...obj ?? {}
+    ...obj
   };
 }
 
@@ -147,13 +147,13 @@ var SoundBankManager = class {
     );
     await this.awaitResponse();
     const found = this.soundBankList.find((s) => s.id === id);
-    if (found !== void 0) {
-      found.bankOffset = bankOffset;
-    } else {
+    if (found === void 0) {
       this.soundBankList.push({
         id,
         bankOffset
       });
+    } else {
+      found.bankOffset = bankOffset;
     }
   }
   // noinspection JSUnusedGlobalSymbols
@@ -168,7 +168,7 @@ var SoundBankManager = class {
       );
       return;
     }
-    if (this.soundBankList.findIndex((s) => s.id === id) === -1) {
+    if (!this.soundBankList.some((s) => s.id === id)) {
       SpessaSynthCoreUtils.SpessaSynthWarn(
         `No sound banks with id of "${id}" found. Aborting!`
       );
@@ -264,20 +264,21 @@ var SynthEventHandler = class {
   /**
    * Calls the given event.
    * INTERNAL USE ONLY!
+   * @internal
    */
   callEventInternal(name, eventData) {
     const eventList = this.events[name];
     const callback = () => {
-      eventList.forEach((callback2) => {
+      for (const callback2 of eventList.values()) {
         try {
           callback2(eventData);
-        } catch (e) {
+        } catch (error) {
           console.error(
             `Error while executing an event callback for ${name}:`,
-            e
+            error
           );
         }
-      });
+      }
     };
     if (this.timeDelay > 0) {
       setTimeout(callback.bind(this), this.timeDelay * 1e3);
@@ -525,7 +526,10 @@ var ReverbProcessor = class extends BasicEffectsProcessor {
 };
 
 // src/synthesizer/basic/snapshot.ts
-import { ChannelSnapshot, SynthesizerSnapshot } from "spessasynth_core";
+import {
+  ChannelSnapshot,
+  SynthesizerSnapshot
+} from "spessasynth_core";
 var LibSynthesizerSnapshot = class extends SynthesizerSnapshot {
   /**
    * Chorus configuration of this synthesizer.
@@ -590,8 +594,10 @@ var BasicSynthesizer = class {
   presetList = [];
   /**
    * INTERNAL USE ONLY!
+   * @internal
+   * All sequencer callbacks
    */
-  sequencerCallbackFunction;
+  sequencers = new Array();
   /**
    * Resolves when the synthesizer is ready.
    */
@@ -608,6 +614,7 @@ var BasicSynthesizer = class {
   chorusProcessor;
   /**
    * INTERNAL USE ONLY!
+   * @internal
    */
   post;
   worklet;
@@ -1191,10 +1198,25 @@ var BasicSynthesizer = class {
    * INTERNAL USE ONLY!
    * @param type INTERNAL USE ONLY!
    * @param resolve INTERNAL USE ONLY!
+   * @internal
    */
   awaitWorkerResponse(type, resolve) {
     this.resolveMap.set(type, resolve);
   }
+  /**
+   * INTERNAL USE ONLY!
+   * @param callback the sequencer callback
+   * @internal
+   */
+  assignNewSequencer(callback) {
+    this.post({
+      channelNumber: -1,
+      type: "requestNewSequencer",
+      data: null
+    });
+    this.sequencers.push(callback);
+    return this.sequencers.length - 1;
+  }
   assignProgressTracker(type, progressFunction) {
     if (this.renderingProgressTracker.get(type)) {
       throw new Error("Something is already being rendered!");
@@ -1226,24 +1248,29 @@ var BasicSynthesizer = class {
    */
   handleMessage(m) {
     switch (m.type) {
-      case "eventCall":
+      case "eventCall": {
         this.eventHandler.callEventInternal(m.data.type, m.data.data);
         break;
-      case "sequencerReturn":
-        this.sequencerCallbackFunction?.(m.data);
+      }
+      case "sequencerReturn": {
+        this.sequencers[m.data.id](m.data);
         break;
-      case "isFullyInitialized":
+      }
+      case "isFullyInitialized": {
         this.workletResponds(m.data.type, m.data.data);
         break;
-      case "soundBankError":
+      }
+      case "soundBankError": {
         util.SpessaSynthWarn(m.data);
         this.eventHandler.callEventInternal("soundBankError", m.data);
         break;
-      case "renderingProgress":
+      }
+      case "renderingProgress": {
         this.renderingProgressTracker.get(m.data.type)?.(
           // @ts-expect-error I can't use generics with map
           m.data.data
         );
+      }
     }
   }
   addNewChannelInternal(post) {
@@ -1282,7 +1309,7 @@ var WorkletSynthesizer = class extends BasicSynthesizer {
    */
   constructor(context, config = DEFAULT_SYNTH_CONFIG) {
     const synthConfig = fillWithDefaults(config, DEFAULT_SYNTH_CONFIG);
-    let outputChannelCount = Array(18).fill(2);
+    let outputChannelCount = new Array(18).fill(2);
     let numberOfOutputs = 18;
     if (synthConfig.oneOutput) {
       outputChannelCount = [36];
@@ -1301,8 +1328,8 @@ var WorkletSynthesizer = class extends BasicSynthesizer {
           enableEventSystem: synthConfig.enableEventSystem
         }
       });
-    } catch (e) {
-      console.error(e);
+    } catch (error) {
+      console.error(error);
       throw new Error(
         "Could not create the AudioWorkletNode. Did you forget to addModule()?"
       );
@@ -1466,7 +1493,8 @@ var DEFAULT_WORKER_RENDER_AUDIO_OPTIONS = {
   loopCount: 0,
   progressCallback: void 0,
   preserveSynthParams: true,
-  enableEffects: true
+  enableEffects: true,
+  sequencerID: 0
 };
 var RENDER_BLOCKS_PER_PROGRESS = 64;
 var BLOCK_SIZE = 128;
@@ -1475,20 +1503,20 @@ function renderAudioWorker(sampleRate, options) {
     enableEventSystem: false
   });
   const rendererSeq = new SpessaSynthSequencer(rendererSynth);
-  this.synthesizer.soundBankManager.soundBankList.forEach(
-    (entry) => rendererSynth.soundBankManager.addSoundBank(
+  for (const entry of this.synthesizer.soundBankManager.soundBankList)
+    rendererSynth.soundBankManager.addSoundBank(
       entry.soundBank,
       entry.id,
       entry.bankOffset
-    )
-  );
+    );
   rendererSynth.soundBankManager.priorityOrder = this.synthesizer.soundBankManager.priorityOrder;
   this.stopAudioLoop();
-  const parsedMid = this.sequencer.midiData;
+  const seq = this.sequencers[options.sequencerID];
+  const parsedMid = seq.midiData;
   if (!parsedMid) {
     throw new Error("No MIDI is loaded!");
   }
-  const playbackRate = this.sequencer.playbackRate;
+  const playbackRate = seq.playbackRate;
   const loopStartAbsolute = parsedMid.midiTicksToSeconds(parsedMid.loop.start) / playbackRate;
   const loopEndAbsolute = parsedMid.midiTicksToSeconds(parsedMid.loop.end) / playbackRate;
   const loopDuration = loopEndAbsolute - loopStartAbsolute;
@@ -1496,15 +1524,12 @@ function renderAudioWorker(sampleRate, options) {
   const sampleDuration = sampleRate * duration;
   rendererSeq.loopCount = options.loopCount;
   if (options.preserveSynthParams) {
-    rendererSeq.playbackRate = this.sequencer.playbackRate;
+    rendererSeq.playbackRate = seq.playbackRate;
     const snapshot = this.synthesizer.getSnapshot();
     rendererSynth.applySynthesizerSnapshot(snapshot);
   }
   rendererSeq.loadNewSongList([parsedMid]);
   rendererSeq.play();
-  const progressCallback = (progress) => {
-    this.postProgress("renderAudio", progress);
-  };
   const reverb = [
     new Float32Array(sampleDuration),
     new Float32Array(sampleDuration)
@@ -1554,7 +1579,7 @@ function renderAudioWorker(sampleRate, options) {
         );
         index += BLOCK_SIZE;
       }
-      progressCallback(index / sampleDuration);
+      this.postProgress("renderAudio", index / sampleDuration);
     }
   } else {
     const dry = [
@@ -1587,7 +1612,7 @@ function renderAudioWorker(sampleRate, options) {
         );
         index += BLOCK_SIZE;
       }
-      progressCallback(index / sampleDuration);
+      this.postProgress("renderAudio", index / sampleDuration);
     }
   }
 }
@@ -1596,7 +1621,8 @@ function renderAudioWorker(sampleRate, options) {
 var DEFAULT_BANK_WRITE_OPTIONS = {
   trim: true,
   bankID: "",
-  writeEmbeddedSoundBank: true
+  writeEmbeddedSoundBank: true,
+  sequencerID: 0
 };
 var DEFAULT_SF2_WRITE_OPTIONS = {
   ...DEFAULT_BANK_WRITE_OPTIONS,
@@ -1645,7 +1671,7 @@ var WorkerSynthesizer = class extends BasicSynthesizer {
         context,
         PLAYBACK_WORKLET_PROCESSOR_NAME,
         {
-          outputChannelCount: Array(18).fill(2),
+          outputChannelCount: new Array(18).fill(2),
           numberOfOutputs: 18,
           processorOptions: {
             oneOutput: synthConfig.oneOutput,
@@ -1653,8 +1679,8 @@ var WorkerSynthesizer = class extends BasicSynthesizer {
           }
         }
       );
-    } catch (e) {
-      console.error(e);
+    } catch (error) {
+      console.error(error);
       throw new Error(
         "Could not create the AudioWorkletNode. Did you forget to registerPlaybackWorklet()?"
       );
@@ -1955,11 +1981,7 @@ var MIDIData = class _MIDIData extends BasicMIDI {
     super();
     super.copyMetadataFrom(mid);
     this.tracks = mid.tracks.map((t) => new MIDIDataTrack(t));
-    if (mid instanceof _MIDIData) {
-      this.embeddedSoundBankSize = mid.embeddedSoundBankSize;
-    } else {
-      this.embeddedSoundBankSize = mid?.embeddedSoundBank?.byteLength;
-    }
+    this.embeddedSoundBankSize = mid instanceof _MIDIData ? mid.embeddedSoundBankSize : mid?.embeddedSoundBank?.byteLength;
   }
 };
 
@@ -1976,7 +1998,7 @@ var songChangeType = {
 // src/synthesizer/basic/basic_synthesizer_core.ts
 var BasicSynthesizerCore = class {
   synthesizer;
-  sequencer;
+  sequencers = new Array();
   post;
   /**
    * Indicates if the processor is alive.
@@ -1985,7 +2007,6 @@ var BasicSynthesizerCore = class {
   alive = false;
   constructor(sampleRate, options, postMessage) {
     this.synthesizer = new SpessaSynthProcessor2(sampleRate, options);
-    this.sequencer = new SpessaSynthSequencer2(this.synthesizer);
     this.post = postMessage;
     this.synthesizer.onEventCall = (event) => {
       this.post({
@@ -1994,7 +2015,12 @@ var BasicSynthesizerCore = class {
         currentTime: this.synthesizer.currentSynthTime
       });
     };
-    this.sequencer.onEventCall = (e) => {
+  }
+  createNewSequencer() {
+    const sequencer = new SpessaSynthSequencer2(this.synthesizer);
+    const sequencerID = this.sequencers.length;
+    this.sequencers.push(sequencer);
+    sequencer.onEventCall = (e) => {
       if (e.type === "songListChange") {
         const songs = e.data.newSongList;
         const midiDatas = songs.map((s) => {
@@ -2004,7 +2030,8 @@ var BasicSynthesizerCore = class {
           type: "sequencerReturn",
           data: {
             type: e.type,
-            data: { newSongList: midiDatas }
+            data: { newSongList: midiDatas },
+            id: sequencerID
           },
           currentTime: this.synthesizer.currentSynthTime
         });
@@ -2012,7 +2039,7 @@ var BasicSynthesizerCore = class {
       }
       this.post({
         type: "sequencerReturn",
-        data: e,
+        data: { ...e, id: sequencerID },
         currentTime: this.synthesizer.currentSynthTime
       });
     };
@@ -2058,7 +2085,7 @@ var BasicSynthesizerCore = class {
       }
     }
     switch (m.type) {
-      case "midiMessage":
+      case "midiMessage": {
         this.synthesizer.processMessage(
           m.data.messageData,
           m.data.channelOffset,
@@ -2066,20 +2093,23 @@ var BasicSynthesizerCore = class {
           m.data.options
         );
         break;
-      case "customCcChange":
+      }
+      case "customCcChange": {
         channelObject?.setCustomController(
           m.data.ccNumber,
           m.data.ccValue
         );
         break;
-      case "ccReset":
+      }
+      case "ccReset": {
         if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION2) {
           this.synthesizer.resetAllControllers();
         } else {
           channelObject?.resetControllers();
         }
         break;
-      case "setChannelVibrato":
+      }
+      case "setChannelVibrato": {
         if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION2) {
           for (const chan of this.synthesizer.midiChannels) {
             if (m.data.rate === ALL_CHANNELS_OR_DIFFERENT_ACTION2) {
@@ -2102,32 +2132,36 @@ var BasicSynthesizerCore = class {
           );
         }
         break;
-      case "stopAll":
+      }
+      case "stopAll": {
         if (channel === ALL_CHANNELS_OR_DIFFERENT_ACTION2) {
           this.synthesizer.stopAllChannels(m.data === 1);
         } else {
           channelObject?.stopAllNotes(m.data === 1);
         }
         break;
-      case "killNotes":
-        this.synthesizer.killVoices(m.data);
-        break;
-      case "muteChannel":
+      }
+      case "muteChannel": {
         channelObject?.muteChannel(m.data);
         break;
-      case "addNewChannel":
+      }
+      case "addNewChannel": {
         this.synthesizer.createMIDIChannel();
         break;
-      case "setMasterParameter":
+      }
+      case "setMasterParameter": {
         this.synthesizer.setMasterParameter(m.data.type, m.data.data);
         break;
-      case "setDrums":
+      }
+      case "setDrums": {
         channelObject?.setDrums(m.data);
         break;
-      case "transposeChannel":
+      }
+      case "transposeChannel": {
         channelObject?.transposeChannel(m.data.semitones, m.data.force);
         break;
-      case "lockController":
+      }
+      case "lockController": {
         if (m.data.controllerNumber === ALL_CHANNELS_OR_DIFFERENT_ACTION2) {
           channelObject?.setPresetLock(m.data.isLocked);
         } else {
@@ -2137,16 +2171,18 @@ var BasicSynthesizerCore = class {
           channelObject.lockedControllers[m.data.controllerNumber] = m.data.isLocked;
         }
         break;
+      }
       case "sequencerSpecific": {
-        if (!this.sequencer) {
+        const seq = this.sequencers[m.data.id];
+        if (!seq) {
           return;
         }
-        const seq = this.sequencer;
         const seqMsg = m.data;
         switch (seqMsg.type) {
-          default:
+          default: {
             break;
-          case "loadNewSongList":
+          }
+          case "loadNewSongList": {
             try {
               const sList = seqMsg.data;
               const songMap = sList.map((s) => {
@@ -2159,53 +2195,64 @@ var BasicSynthesizerCore = class {
                 );
               });
               seq.loadNewSongList(songMap);
-            } catch (e) {
-              console.error(e);
+            } catch (error) {
+              console.error(error);
               this.post({
                 type: "sequencerReturn",
                 data: {
                   type: "midiError",
-                  data: e
+                  data: error,
+                  id: m.data.id
                 },
                 currentTime: this.synthesizer.currentSynthTime
               });
             }
             break;
-          case "pause":
+          }
+          case "pause": {
             seq.pause();
             break;
-          case "play":
+          }
+          case "play": {
             seq.play();
             break;
-          case "setTime":
+          }
+          case "setTime": {
             seq.currentTime = seqMsg.data;
             break;
-          case "changeMIDIMessageSending":
+          }
+          case "changeMIDIMessageSending": {
             seq.externalMIDIPlayback = seqMsg.data;
             break;
-          case "setPlaybackRate":
+          }
+          case "setPlaybackRate": {
             seq.playbackRate = seqMsg.data;
             break;
-          case "setLoopCount":
+          }
+          case "setLoopCount": {
             seq.loopCount = seqMsg.data;
             break;
-          case "changeSong":
+          }
+          case "changeSong": {
             switch (seqMsg.data.changeType) {
-              case songChangeType.shuffleOff:
+              case songChangeType.shuffleOff: {
                 seq.shuffleMode = false;
                 break;
-              case songChangeType.shuffleOn:
+              }
+              case songChangeType.shuffleOn: {
                 seq.shuffleMode = true;
                 break;
-              case songChangeType.index:
+              }
+              case songChangeType.index: {
                 if (seqMsg.data.data !== void 0) {
-                  console.log("INDEX", seqMsg.data);
                   seq.songIndex = seqMsg.data.data;
                 }
                 break;
+              }
             }
             break;
-          case "getMIDI":
+          }
+          case "getMIDI": {
             if (!seq.midiData) {
               throw new Error("No MIDI is loaded!");
             }
@@ -2213,24 +2260,27 @@ var BasicSynthesizerCore = class {
               type: "sequencerReturn",
               data: {
                 type: "getMIDI",
-                data: seq.midiData
+                data: seq.midiData,
+                id: m.data.id
               },
               currentTime: this.synthesizer.currentSynthTime
             });
             break;
-          case "setSkipToFirstNote":
+          }
+          case "setSkipToFirstNote": {
             seq.skipToFirstNoteOn = seqMsg.data;
             break;
+          }
         }
         break;
       }
-      case "soundBankManager":
+      case "soundBankManager": {
         try {
           const sfManager = this.synthesizer.soundBankManager;
           const sfManMsg = m.data;
           let font;
           switch (sfManMsg.type) {
-            case "addSoundBank":
+            case "addSoundBank": {
               font = SoundBankLoader.fromArrayBuffer(
                 sfManMsg.data.soundBankBuffer
               );
@@ -2241,43 +2291,51 @@ var BasicSynthesizerCore = class {
               );
               this.postReady("soundBankManager", null);
               break;
-            case "deleteSoundBank":
+            }
+            case "deleteSoundBank": {
               sfManager.deleteSoundBank(sfManMsg.data);
               this.postReady("soundBankManager", null);
               break;
-            case "rearrangeSoundBanks":
+            }
+            case "rearrangeSoundBanks": {
               sfManager.priorityOrder = sfManMsg.data;
               this.postReady("soundBankManager", null);
+            }
           }
-        } catch (e) {
+        } catch (error) {
           this.post({
             type: "soundBankError",
-            data: e,
+            data: error,
             currentTime: this.synthesizer.currentSynthTime
           });
         }
         break;
+      }
       case "keyModifierManager": {
         const kmMsg = m.data;
         const man = this.synthesizer.keyModifierManager;
         switch (kmMsg.type) {
-          default:
+          default: {
             return;
-          case "addMapping":
+          }
+          case "addMapping": {
             man.addMapping(
               kmMsg.data.channel,
               kmMsg.data.midiNote,
               kmMsg.data.mapping
             );
             break;
-          case "clearMappings":
+          }
+          case "clearMappings": {
             man.clearMappings();
             break;
-          case "deleteMapping":
+          }
+          case "deleteMapping": {
             man.deleteMapping(
               kmMsg.data.channel,
               kmMsg.data.midiNote
             );
+          }
         }
         break;
       }
@@ -2286,21 +2344,28 @@ var BasicSynthesizerCore = class {
         this.postReady("synthesizerSnapshot", snapshot);
         break;
       }
-      case "setLogLevel":
+      case "requestNewSequencer": {
+        this.createNewSequencer();
+        break;
+      }
+      case "setLogLevel": {
         SpessaSynthLogging(
           m.data.enableInfo,
           m.data.enableWarning,
           m.data.enableGroup
         );
         break;
-      case "destroyWorklet":
+      }
+      case "destroyWorklet": {
         this.alive = false;
         this.synthesizer.destroySynthProcessor();
         this.destroy();
         break;
-      default:
+      }
+      default: {
         util2.SpessaSynthWarn("Unrecognized event!", m);
         break;
+      }
     }
   }
 };
@@ -2320,14 +2385,15 @@ async function writeSF2Worker(opts) {
     });
     throw e;
   }
+  const sq = this.sequencers[opts.sequencerID];
   if (opts.trim) {
-    if (!this.sequencer.midiData) {
+    if (!sq.midiData) {
       throw new Error(
         "Sound bank MIDI trimming is enabled but no MIDI is loaded!"
       );
     }
     const sfCopy = BasicSoundBank.copyFrom(sf);
-    sfCopy.trimSoundBank(this.sequencer.midiData);
+    sfCopy.trimSoundBank(sq.midiData);
     sf = sfCopy;
   }
   let compressionFunction;
@@ -2357,14 +2423,15 @@ async function writeSF2Worker(opts) {
 }
 async function writeDLSWorker(opts) {
   let sf = this.getBank(opts);
+  const sq = this.sequencers[opts.sequencerID];
   if (opts.trim) {
-    if (!this.sequencer.midiData) {
+    if (!sq.midiData) {
       throw new Error(
         "Sound bank MIDI trimming is enabled but no MIDI is loaded!"
       );
     }
     const sfCopy = BasicSoundBank.copyFrom(sf);
-    sfCopy.trimSoundBank(this.sequencer.midiData);
+    sfCopy.trimSoundBank(sq.midiData);
     sf = sfCopy;
   }
   const b = await sf.writeDLS({
@@ -2387,7 +2454,8 @@ async function writeDLSWorker(opts) {
 // src/synthesizer/worker/write_rmi_worker.ts
 import { BasicMIDI as BasicMIDI3 } from "spessasynth_core";
 async function writeRMIDIWorker(opts) {
-  if (!this.sequencer.midiData) {
+  const sq = this.sequencers[opts.sequencerID];
+  if (!sq.midiData) {
     throw new Error("No MIDI is loaded!");
   }
   let sf;
@@ -2401,7 +2469,7 @@ async function writeRMIDIWorker(opts) {
     sfBin = bin.binary;
     sf = bin.bank;
   }
-  const mid = BasicMIDI3.copyFrom(this.sequencer.midiData);
+  const mid = BasicMIDI3.copyFrom(sq.midiData);
   return mid.writeRMIDI(sfBin, {
     soundBank: sf,
     ...opts
@@ -2449,21 +2517,21 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
    */
   handleMessage(m) {
     switch (m.type) {
-      case "renderAudio":
+      case "renderAudio": {
         const rendered = renderAudioWorker.call(
           this,
           m.data.sampleRate,
           m.data.options
         );
         const transferable = [];
-        rendered.reverb.forEach((r) => transferable.push(r.buffer));
-        rendered.chorus.forEach((c) => transferable.push(c.buffer));
-        rendered.dry.forEach(
-          (d) => transferable.push(...d.map((c) => c.buffer))
-        );
+        for (const r of rendered.reverb) transferable.push(r.buffer);
+        for (const c of rendered.chorus) transferable.push(c.buffer);
+        for (const d of rendered.dry)
+          transferable.push(...d.map((c) => c.buffer));
         this.postReady("renderAudio", rendered, transferable);
         break;
-      case "writeRMIDI":
+      }
+      case "writeRMIDI": {
         this.stopAudioLoop();
         void writeRMIDIWorker.call(this, m.data).then((data) => {
           this.postReady(
@@ -2477,7 +2545,8 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
           this.startAudioLoop();
         });
         break;
-      case "writeSF2":
+      }
+      case "writeSF2": {
         this.stopAudioLoop();
         void writeSF2Worker.call(this, m.data).then((data) => {
           this.postReady(
@@ -2491,7 +2560,8 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
           this.startAudioLoop();
         });
         break;
-      case "writeDLS":
+      }
+      case "writeDLS": {
         this.stopAudioLoop();
         void writeDLSWorker.call(this, m.data).then((data) => {
           this.postReady(
@@ -2505,20 +2575,17 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
           this.startAudioLoop();
         });
         break;
-      default:
+      }
+      default: {
         super.handleMessage(m);
+      }
     }
   }
   getBank(opts) {
-    let sf;
-    if (opts.writeEmbeddedSoundBank && this.sequencer.midiData?.embeddedSoundBank) {
-      sf = SoundBankLoader2.fromArrayBuffer(
-        this.sequencer.midiData.embeddedSoundBank
-      );
-    } else
-      sf = this.synthesizer.soundBankManager.soundBankList.find(
-        (b) => b.id === opts.bankID
-      )?.soundBank;
+    const sq = this.sequencers[opts.sequencerID];
+    const sf = opts.writeEmbeddedSoundBank && sq.midiData?.embeddedSoundBank ? SoundBankLoader2.fromArrayBuffer(sq.midiData.embeddedSoundBank) : this.synthesizer.soundBankManager.soundBankList.find(
+      (b) => b.id === opts.bankID
+    )?.soundBank;
     if (!sf) {
       const e = new Error(
         `${opts.bankID} does not exist in the sound bank list!`
@@ -2534,7 +2601,9 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
   }
   stopAudioLoop() {
     this.synthesizer.stopAllChannels(true);
-    this.sequencer.pause();
+    for (const seq of this.sequencers) {
+      seq.pause();
+    }
     this.alive = false;
   }
   startAudioLoop() {
@@ -2570,7 +2639,9 @@ var WorkerSynthesizerCore = class extends BasicSynthesizerCore {
       const dryR = new Float32Array(data.buffer, byteOffset, BLOCK_SIZE2);
       dry.push([dryL, dryR]);
     }
-    this.sequencer.processTick();
+    for (const seq of this.sequencers) {
+      seq.processTick();
+    }
     this.synthesizer.renderAudioSplit(rev, chr, dry);
     this.workletMessagePort.postMessage(data, [data.buffer]);
   }
@@ -2627,20 +2698,21 @@ var SeqEventHandler = class {
   /**
    * Calls the given event.
    * Internal use only.
+   * @internal
    */
   callEventInternal(name, eventData) {
     const eventList = this.events[name];
     const callback = () => {
-      eventList.forEach((callback2) => {
+      for (const callback2 of eventList.values()) {
         try {
           callback2(eventData);
-        } catch (e) {
+        } catch (error) {
           console.error(
             `Error while executing a sequencer event callback for ${name}:`,
-            e
+            error
           );
         }
-      });
+      }
     };
     if (this.timeDelay > 0) {
       setTimeout(callback.bind(this), this.timeDelay * 1e3);
@@ -2688,6 +2760,10 @@ var Sequencer = class {
    * Absolute playback startTime, bases on the synth's time.
    */
   absoluteStartTime;
+  /**
+   * For sending the messages to the correct SpessaSynthSequencer in core
+   */
+  sequencerID;
   /**
    * Creates a new MIDI sequencer for playing back MIDI files.
    * @param synth synth to send events to.
@@ -2696,7 +2772,9 @@ var Sequencer = class {
   constructor(synth, options = DEFAULT_SEQUENCER_OPTIONS) {
     this.synth = synth;
     this.absoluteStartTime = this.synth.currentTime;
-    this.synth.sequencerCallbackFunction = this.handleMessage.bind(this);
+    this.sequencerID = this.synth.assignNewSequencer(
+      this.handleMessage.bind(this)
+    );
     this._skipToFirstNoteOn = options?.skipToFirstNoteOn ?? true;
     if (options?.initialPlaybackRate !== 1) {
       this.playbackRate = options?.initialPlaybackRate ?? 1;
@@ -2916,16 +2994,15 @@ var Sequencer = class {
   }
   handleMessage(m) {
     switch (m.type) {
-      case "midiMessage":
+      case "midiMessage": {
         const midiEventData = m.data.message;
-        if (this.midiOut) {
-          if (midiEventData[0] >= 128) {
-            this.midiOut.send(midiEventData);
-            return;
-          }
+        if (this.midiOut && midiEventData[0] >= 128) {
+          this.midiOut.send(midiEventData);
+          return;
         }
         break;
-      case "songChange":
+      }
+      case "songChange": {
         this._songIndex = m.data.songIndex;
         const songChangeData = this.songListData[this._songIndex];
         this.midiData = songChangeData;
@@ -2933,35 +3010,41 @@ var Sequencer = class {
         this.absoluteStartTime = 0;
         this.callEventInternal("songChange", songChangeData);
         break;
-      case "timeChange":
+      }
+      case "timeChange": {
         const time = m.data.newTime;
         this.recalculateStartTime(time);
         this.callEventInternal("timeChange", time);
         break;
-      case "pause":
+      }
+      case "pause": {
         this.pausedTime = this.currentTime;
         this.isFinished = m.data.isFinished;
         if (this.isFinished) {
           this.callEventInternal("songEnded", null);
         }
         break;
-      case "midiError":
+      }
+      case "midiError": {
         this.callEventInternal("midiError", m.data);
         throw new Error(`MIDI parsing error:  ${m.data}`);
-      case "getMIDI":
+      }
+      case "getMIDI": {
         if (this.getMIDICallback) {
           this.getMIDICallback(BasicMIDI4.copyFrom(m.data));
         }
         break;
-      case "metaEvent":
+      }
+      case "metaEvent": {
         const event = m.data.event;
         switch (event.statusByte) {
-          case midiMessageTypes2.setTempo:
+          case midiMessageTypes2.setTempo: {
             this._currentTempo = 6e7 / SpessaSynthCoreUtils4.readBytesAsUintBigEndian(
               event.data,
               3
             );
             break;
+          }
           case midiMessageTypes2.text:
           case midiMessageTypes2.lyric:
           case midiMessageTypes2.copyright:
@@ -2969,7 +3052,7 @@ var Sequencer = class {
           case midiMessageTypes2.marker:
           case midiMessageTypes2.cuePoint:
           case midiMessageTypes2.instrumentName:
-          case midiMessageTypes2.programName:
+          case midiMessageTypes2.programName: {
             if (!this.midiData) {
               break;
             }
@@ -2995,25 +3078,30 @@ var Sequencer = class {
               lyricsIndex
             });
             break;
+          }
         }
         this.callEventInternal("metaEvent", {
           event: m.data.event,
           trackNumber: m.data.trackIndex
         });
         break;
-      case "loopCountChange":
+      }
+      case "loopCountChange": {
         this._loopCount = m.data.newCount;
         if (this._loopCount === 0) {
         }
         break;
-      case "songListChange":
+      }
+      case "songListChange": {
         this.songListData = m.data.newSongList.map(
           (m2) => new MIDIData(m2)
         );
         this.midiData = this.songListData[this._songIndex];
         break;
-      default:
+      }
+      default: {
         break;
+      }
     }
   }
   callEventInternal(type, data) {
@@ -3042,7 +3130,8 @@ var Sequencer = class {
       type: "sequencerSpecific",
       data: {
         type: messageType,
-        data: messageData
+        data: messageData,
+        id: this.sequencerID
       }
     });
   }
@@ -3105,9 +3194,11 @@ var LibMIDIInput = class extends LibMIDIPort {
   connectedSynths = /* @__PURE__ */ new Set();
   constructor(input) {
     super(input);
-    input.onmidimessage = (e) => this.connectedSynths.forEach((s) => {
-      if (e.data) s.sendMessage(e.data);
-    });
+    input.onmidimessage = (e) => {
+      for (const s of this.connectedSynths) {
+        if (e.data) s.sendMessage(e.data);
+      }
+    };
   }
   // noinspection JSUnusedGlobalSymbols
   /**
@@ -3159,12 +3250,12 @@ var MIDIDeviceHandler = class _MIDIDeviceHandler {
    */
   outputs = /* @__PURE__ */ new Map();
   constructor(access) {
-    access.inputs.forEach((value, key) => {
+    for (const [key, value] of access.inputs.entries()) {
       this.inputs.set(key, new LibMIDIInput(value));
-    });
-    access.outputs.forEach((value, key) => {
+    }
+    for (const [key, value] of access.outputs.entries()) {
       this.outputs.set(key, new LibMIDIOutput(value));
-    });
+    }
   }
   /**
    * Attempts to initialize the MIDI Device Handler.
@@ -3183,9 +3274,9 @@ var MIDIDeviceHandler = class _MIDIDeviceHandler {
           consoleColors.recognized
         );
         return new _MIDIDeviceHandler(response);
-      } catch (e) {
-        util3.SpessaSynthWarn(`Could not get MIDI Devices:`, e);
-        throw e;
+      } catch (error) {
+        util3.SpessaSynthWarn(`Could not get MIDI Devices:`, error);
+        throw error;
       }
     } else {
       util3.SpessaSynthWarn(
@@ -3214,7 +3305,7 @@ var WebMIDILinkHandler = class {
         return;
       }
       data.shift();
-      const midiData = data.map((byte) => parseInt(byte, 16));
+      const midiData = data.map((byte) => Number.parseInt(byte, 16));
       synth.sendMessage(midiData);
     });
     SpessaSynthCoreUtils5.SpessaSynthInfo(