midi-audio-player 1.1.2 → 2.0.1

package/dist/midi-audio-player.js

@@ -1,18 +1,18 @@
 /*!
 
-	██████╗ ██╗ █████╗ ███╗   ███╗███████╗████████╗██████╗ ██╗ ██████╗██╗  ██╗
-	██╔══██╗██║██╔══██╗████╗ ████║██╔════╝╚══██╔══╝██╔══██╗██║██╔════╝██║ ██╔╝
-	██║  ██║██║███████║██╔████╔██║█████╗     ██║   ██████╔╝██║██║     █████╔╝
-	██║  ██║██║██╔══██║██║╚██╔╝██║██╔══╝     ██║   ██╔══██╗██║██║     ██╔═██╗
-	██████╔╝██║██║  ██║██║ ╚═╝ ██║███████╗   ██║   ██║  ██║██║╚██████╗██║  ██╗
-	╚═════╝ ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝	
+	███╗   ███╗██╗██████╗ ██╗ █████╗ ██╗   ██╗██████╗ ██╗ ██████╗ ██████╗ ██╗      █████╗ ██╗   ██╗███████╗██████╗
+	████╗ ████║██║██╔══██╗██║██╔══██╗██║   ██║██╔══██╗██║██╔═══██╗██╔══██╗██║     ██╔══██╗╚██╗ ██╔╝██╔════╝██╔══██╗
+	██╔████╔██║██║██║  ██║██║███████║██║   ██║██║  ██║██║██║   ██║██████╔╝██║     ███████║ ╚████╔╝ █████╗  ██████╔╝
+	██║╚██╔╝██║██║██║  ██║██║██╔══██║██║   ██║██║  ██║██║██║   ██║██╔═══╝ ██║     ██╔══██║  ╚██╔╝  ██╔══╝  ██╔══██╗
+	██║ ╚═╝ ██║██║██████╔╝██║██║  ██║╚██████╔╝██████╔╝██║╚██████╔╝██║     ███████╗██║  ██║   ██║   ███████╗██║  ██║
+	╚═╝     ╚═╝╚═╝╚═════╝ ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+	Version: 2.0.1
+	Build:   2026-05-31 02:44:14
+	Author:  Maxime Larrivée-Roy <mlarriveeroy@gmail.com>
+	Github:  https://github.com/webaudiofonts/midi-audio-player/
+	Website: https://webaudiofonts.com/midiaudioplayer/
 
-	Version: 1.1.2
-	Généré:  2026-05-10 00:19:40
-	Auteur:  Maxime Larrivée-Roy <mlarriveeroy@gmail.com>
-	Github:  https://github.com/ZmotriN/midi-audio-player/
-	Website: https://zmotrin.github.io/midi-audio-player/
-	
 */
 (() => {
   // node_modules/midi-player-js/build/index.browser.js
@@ -1212,26 +1212,94 @@
     Constants
   };
 
-  // src/webaudiofontplayer.js
-  var WebAudioFontPlayer = class {
+  // node_modules/webaudiofontplayer/dist/index.js
+  var WebAudioFontPlayer = class _WebAudioFontPlayer {
     #audioCtx = null;
+    #compressor = null;
     #preset = null;
     #envelopes = [];
     #afterTime = 0.05;
     #nearZero = 1e-6;
-    constructor(audioCtx, preset) {
+    #bendRange = 2;
+    #mainGain = null;
+    #volumeValue = 0.7;
+    #expressionValue = 1;
+    #expressionGain = null;
+    #sustain = false;
+    #pitchBendValue = 8192;
+    #notesWaitingForSustain = /* @__PURE__ */ new Set();
+    constructor(preset, audioCtx, compressor = null, callback = null) {
       this.#audioCtx = audioCtx;
+      this.#compressor = compressor;
+      this.#mainGain = this.#audioCtx.createGain();
+      this.#mainGain.gain.setValueAtTime(this.#volumeValue, this.#audioCtx.currentTime);
+      this.#expressionGain = this.#audioCtx.createGain();
+      this.#expressionGain.gain.setValueAtTime(this.#expressionValue, this.#audioCtx.currentTime);
+      this.#mainGain.connect(this.#expressionGain);
+      this.#expressionGain.connect(this.#compressor ? this.#compressor.input : this.#audioCtx.destination);
+      this.setPreset(preset).then(() => {
+        if (typeof callback === "function") callback();
+      });
+    }
+    get preset() {
+      return this.#preset;
+    }
+    set preset(preset) {
+      this.setPreset(preset);
+    }
+    static load(preset, audioCtx, compressor = null) {
+      return new Promise((resolve) => {
+        const player = new _WebAudioFontPlayer(preset, audioCtx, compressor, () => resolve(player));
+      });
+    }
+    async setPreset(preset) {
       this.#preset = preset;
-      this.#preset.zones.map((zone) => this.#adjustZone(zone));
+      await Promise.all(this.#preset.zones.map((zone) => this.#adjustZone(zone)));
+    }
+    close() {
+      const now = this.#audioCtx.currentTime;
+      this.#envelopes.forEach((envelope) => {
+        try {
+          envelope.gain.cancelScheduledValues(0);
+          if (envelope.audioBufferSourceNode) {
+            envelope.audioBufferSourceNode.stop(now);
+            envelope.audioBufferSourceNode.disconnect();
+            envelope.audioBufferSourceNode = null;
+          }
+        } catch (e) {
+        }
+        try {
+          envelope.disconnect();
+        } catch (e) {
+        }
+      });
+      this.#envelopes = [];
+      this.#notesWaitingForSustain.clear();
+      try {
+        this.#mainGain.disconnect();
+      } catch (e) {
+      }
+      try {
+        this.#expressionGain.disconnect();
+      } catch (e) {
+      }
+      this.#mainGain = null;
+      this.#expressionGain = null;
+      this.#preset = null;
+      this.#compressor = null;
+      this.#audioCtx = null;
     }
     queueWaveTable(when, pitch, duration, volume, slides) {
       if (this.#audioCtx.state === "suspended") this.#audioCtx.resume().catch(() => {
       });
       const vol = this.#limitVolume(volume);
-      const zone = this.#findZone(pitch);
+      const zone = this.#findZone(Math.round(pitch));
       if (!zone?.buffer) return null;
-      const baseDetune = zone.originalPitch - 100 * zone.coarseTune - zone.fineTune;
-      const playbackRate = Math.pow(2, (100 * pitch - baseDetune) / 1200);
+      const baseDetuneCents = zone.originalPitch - 100 * zone.coarseTune - zone.fineTune;
+      const originalPitchCents = pitch * 100;
+      const currentBendCents = (this.#pitchBendValue - 8192) / 8192 * this.#bendRange * 100;
+      const totalCents = originalPitchCents - baseDetuneCents + currentBendCents;
+      const playbackRate = Math.pow(2, totalCents / 1200);
       const startWhen = Math.max(when, this.#audioCtx.currentTime);
       let waveDuration = duration + this.#afterTime;
       const loop = zone.loopStart >= 1 && zone.loopStart < zone.loopEnd;
@@ -1244,7 +1312,9 @@
       if (slides?.length > 0) {
         source.playbackRate.setValueAtTime(playbackRate, startWhen);
         slides.forEach((s) => {
-          const newRate = Math.pow(2, (100 * (pitch + s.delta) - baseDetune) / 1200);
+          const slidePitchCents = (pitch + s.delta) * 100;
+          const totalSlideCents = slidePitchCents - baseDetuneCents + currentBendCents;
+          const newRate = Math.pow(2, totalSlideCents / 1200);
           source.playbackRate.linearRampToValueAtTime(newRate, startWhen + s.when);
         });
       }
@@ -1260,12 +1330,10 @@
       envelope.audioBufferSourceNode = source;
       envelope.when = startWhen;
       envelope.duration = waveDuration;
+      envelope.pitch = pitch;
+      envelope.baseDetune = baseDetuneCents;
       return envelope;
     }
-    queueChord(prst, w, pchs, d, v, s) {
-      const vol = this.#limitVolume(v);
-      return pchs.map((p, i) => this.queueWaveTable(this.#audioCtx, this.#audioCtx.destination, prst, w, p, d, vol - Math.random() * 0.01, s?.[i])).filter(Boolean);
-    }
     async cancelQueue() {
       this.#envelopes.forEach((e) => {
         e.gain.cancelScheduledValues(0);
@@ -1277,41 +1345,68 @@
         }
       });
     }
-    #adjustZone(zone) {
-      if (zone.buffer) return Promise.resolve(zone);
-      zone.delay = 0;
-      if (zone.sample) {
-        const binaryString = atob(zone.sample);
-        const len = binaryString.length;
-        const bytes = new Uint8Array(len);
-        for (let i = 0; i < len; i++) bytes[i] = binaryString.charCodeAt(i);
-        const int16Samples = new Int16Array(bytes.buffer);
-        const numSamples = int16Samples.length;
-        zone.buffer = this.#audioCtx.createBuffer(1, numSamples, zone.sampleRate);
-        const float32Array = zone.buffer.getChannelData(0);
-        for (let i = 0; i < numSamples; i++) float32Array[i] = int16Samples[i] / 32768;
-        this.#applyZoneParameters(zone);
-        return zone;
-      } else if (zone.file) {
-        const decoded = atob(zone.file);
-        const uint8Array = new Uint8Array(decoded.length);
-        for (let i = 0; i < decoded.length; i++) uint8Array[i] = decoded.charCodeAt(i);
-        this.#audioCtx.decodeAudioData(
-          uint8Array.buffer,
-          (audioBuffer) => {
-            zone.buffer = audioBuffer;
-            this.#applyZoneParameters(zone);
-            return zone;
-          },
-          (error) => {
-            console.error("Audio decoding error:", error);
-            return false;
+    isSustainActive() {
+      return this.#sustain;
+    }
+    registerSustainNote(cancelFn) {
+      this.#notesWaitingForSustain.add(cancelFn);
+    }
+    setPitchBend(value) {
+      this.#pitchBendValue = value;
+      const normalized = value - 8192;
+      const semitones = normalized >= 0 ? normalized / 8191 * this.#bendRange : normalized / 8192 * this.#bendRange;
+      const now = this.#audioCtx.currentTime;
+      this.#envelopes.forEach((e) => {
+        if (e.audioBufferSourceNode && e.when + e.duration > now) {
+          const originalPitchCents = e.pitch * 100;
+          const baseDetuneCents = e.baseDetune;
+          const bendCents = semitones * 100;
+          const totalCents = originalPitchCents - baseDetuneCents + bendCents;
+          const newRate = Math.pow(2, totalCents / 1200);
+          e.audioBufferSourceNode.playbackRate.cancelScheduledValues(now);
+          e.audioBufferSourceNode.playbackRate.setTargetAtTime(newRate, now, 0.015);
+        }
+      });
+    }
+    setController(number, value) {
+      const now = this.#audioCtx.currentTime;
+      const normalizedValue = Math.max(0, Math.min(127, value)) / 127;
+      switch (number) {
+        case 7:
+          this.#volumeValue = normalizedValue;
+          this.#mainGain.gain.setTargetAtTime(this.#volumeValue, now, 0.05);
+          break;
+        case 11:
+          this.#expressionValue = normalizedValue;
+          this.#expressionGain.gain.setTargetAtTime(this.#expressionValue, now, 0.03);
+          break;
+        case 64:
+          this.#sustain = value >= 64;
+          if (!this.#sustain) {
+            this.#notesWaitingForSustain.forEach((cancelFn) => cancelFn());
+            this.#notesWaitingForSustain.clear();
           }
-        );
+          break;
+      }
+    }
+    async #adjustZone(zone) {
+      if (zone.buffer) return zone;
+      zone.delay = 0;
+      if (zone.file) {
+        const binary = atob(zone.file);
+        const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+        try {
+          zone.buffer = await this.#audioCtx.decodeAudioData(bytes.buffer);
+          this.#applyZoneParameters(zone);
+        } catch (error) {
+          console.error("Audio decoding error:", error);
+          console.warn(this.#preset);
+          return false;
+        }
       } else {
         this.#applyZoneParameters(zone);
-        return zone;
       }
+      return zone;
     }
     #applyZoneParameters(zone) {
       zone.loopStart = this.#numValue(zone.loopStart, 0);
@@ -1319,10 +1414,9 @@
       zone.coarseTune = this.#numValue(zone.coarseTune, 0);
       zone.fineTune = this.#numValue(zone.fineTune, 0);
       zone.originalPitch = this.#numValue(zone.originalPitch, 6e3);
-      zone.sampleRate = this.#numValue(zone.sampleRate, 44100);
     }
     #setupEnvelope(envelope, zone, volume, when, sampleDuration, noteDuration) {
-      envelope.gain.setValueAtTime(this.#noZeroVolume(0), this.#audioCtx.currentTime);
+      envelope.gain.setValueAtTime(this.#nearZero, this.#audioCtx.currentTime);
       const duration = Math.min(noteDuration, sampleDuration - this.#afterTime);
       const ahdsr = zone.ahdsr && zone.ahdsr.length > 0 ? zone.ahdsr : [
         { duration: 0, volume: 1 },
@@ -1330,7 +1424,7 @@
       ];
       envelope.gain.cancelScheduledValues(when);
       const initialVol = (ahdsr[0]?.volume ?? 1) * volume;
-      envelope.gain.setValueAtTime(this.#noZeroVolume(initialVol), when);
+      envelope.gain.linearRampToValueAtTime(this.#noZeroVolume(initialVol), when + 2e-3);
       let lastTime = 0;
       let lastVolume = ahdsr[0]?.volume ?? 1;
       for (const stage of ahdsr) {
@@ -1340,7 +1434,7 @@
         if (stageDuration > remainingTime) {
           const ratio = remainingTime / stageDuration;
           const interpolatedVolume = lastVolume + ratio * (stageVolume - lastVolume);
-          envelope.gain.linearRampToValueAtTime(
+          envelope.gain.exponentialRampToValueAtTime(
             this.#noZeroVolume(volume * interpolatedVolume),
             when + duration
           );
@@ -1348,15 +1442,24 @@
         }
         lastTime += stageDuration;
         lastVolume = stageVolume;
-        envelope.gain.linearRampToValueAtTime(
+        envelope.gain.exponentialRampToValueAtTime(
           this.#noZeroVolume(volume * lastVolume),
           when + lastTime
         );
       }
-      envelope.gain.linearRampToValueAtTime(this.#noZeroVolume(0), when + duration + this.#afterTime);
+      envelope.gain.exponentialRampToValueAtTime(this.#nearZero, when + duration + this.#afterTime);
     }
-    #findEnvelope() {
-      let envelope = this.#envelopes.find((e) => e.target === this.#audioCtx.destination && this.#audioCtx.currentTime > e.when + e.duration + 1e-3);
+    #findEnvelope(destinationNode) {
+      const target = destinationNode || this.#mainGain;
+      const now = this.#audioCtx.currentTime;
+      let envelope = this.#envelopes.find((e) => e.target === target && now > e.when + e.duration + 0.05);
+      if (!envelope && this.#envelopes.length >= 64) {
+        const activeEnvelopes = this.#envelopes.filter((e) => e.target === target);
+        if (activeEnvelopes.length > 0) {
+          activeEnvelopes.sort((a, b) => a.when - b.when);
+          envelope = activeEnvelopes[0];
+        }
+      }
       if (envelope) {
         if (envelope.audioBufferSourceNode) {
           try {
@@ -1366,27 +1469,36 @@
           }
           envelope.audioBufferSourceNode = null;
         }
+        envelope.gain.cancelScheduledValues(0);
+        envelope.gain.setValueAtTime(this.#nearZero, now);
       } else {
         envelope = this.#audioCtx.createGain();
         envelope.gain.value = 0;
-        envelope.target = this.#audioCtx.destination;
-        envelope.connect(this.#audioCtx.destination);
-        envelope.cancel = () => {
-          if (envelope.when + envelope.duration > this.#audioCtx.currentTime) {
-            envelope.gain.cancelScheduledValues(0);
-            envelope.gain.setTargetAtTime(this.#nearZero, this.#audioCtx.currentTime, 0.1);
-            envelope.when = this.#audioCtx.currentTime + 1e-5;
-            envelope.duration = 0;
-          }
-        };
+        envelope.target = target;
+        envelope.connect(target);
         this.#envelopes.push(envelope);
       }
+      envelope.cancel = (force = false) => {
+        const currentTime = this.#audioCtx.currentTime;
+        if (force && envelope.audioBufferSourceNode) {
+          try {
+            envelope.audioBufferSourceNode.stop(0);
+            envelope.audioBufferSourceNode.disconnect();
+          } catch (e) {
+          }
+          envelope.audioBufferSourceNode = null;
+        }
+        if (envelope.when + envelope.duration > currentTime) {
+          envelope.gain.cancelScheduledValues(0);
+          envelope.gain.setTargetAtTime(this.#nearZero, currentTime, force ? 5e-3 : 0.02);
+          envelope.when = currentTime + 1e-5;
+          envelope.duration = 0;
+        }
+      };
       return envelope;
     }
     #findZone(pitch) {
-      const zone = this.#preset.zones.findLast((z) => pitch >= z.keyRangeLow && pitch <= z.keyRangeHigh + 1);
-      if (zone) this.#adjustZone(zone);
-      return zone;
+      return this.#preset.zones.findLast((z) => pitch >= z.keyRangeLow && pitch <= z.keyRangeHigh);
     }
     #limitVolume(v) {
       const requestedVolume = v ? 1 * v : 0.5;
@@ -1399,209 +1511,1597 @@
       return typeof a === "number" ? a : b;
     }
   };
+  if (typeof window !== "undefined") window.WebAudioFontPlayer = WebAudioFontPlayer;
+  var index_default = WebAudioFontPlayer;
 
-  // src/presets/defaultpreset.json
-  var defaultpreset_default = {
-    zones: [
-      {
-        midi: 81,
-        originalPitch: 4200,
-        keyRangeLow: 0,
-        keyRangeHigh: 43,
-        loopStart: 256,
-        loopEnd: 768,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "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",
-        anchor: 533333e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 5400,
-        keyRangeLow: 44,
-        keyRangeHigh: 55,
-        loopStart: 128,
-        loopEnd: 384,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAEsADMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJATAAAAAAAAABLAMEvhQAAAAAAAAAAAAAAAAAAAA//vUxAAACSwNaVQwACRXSC6/NYAIAAa9txyS8qHAwMDPlz5QEIIROfLn1AhBBy3lz/BCt5c/wQz5c/RBCXPlw/EEEHLPlz9EEOt8QQQcs+XPykQVh8uH4gcIHLD6w+JgcGkGbGakSCqjColKJDEMCR4mYQ8kQZ1UAiwCAIbAc4b1maEch6LAEVzMhwxuYQGCgLBWbmQSPi+kAzkOM6i/Ei2XrGgFiMbisXednEOO7NP9KJdLKedbxd7vvezh3pl/YdmreFqxnZjEgf+NyN/I1TXaWzqnqWqTOzTyyihuX0cMUlNa3S81TYWrGd63q/RRuno4xSUUbt3YzSYU1fuH8z/uH8zp6OMUlFK6e/KKTG5zKZy+ax/+4fzP+4fzP70rp78opL1PXv0lSzVy+tjjVyyrY41e4fzf91/N/3X83/dfzf91/N/3X5/3D+b/uv5v+6/m/7r/3/6/9/+sst446yy3jVyyrY41csq2ONXLKtjjVyyrKiLXdbW5JI24SEB1CQjhFAAXAIxdxbUKO0ekXEuKphJ5DkSgYKJVFFxQVwUwFDcRcUFcFcCjsTYoK4K4FHYmxQXwrgUdibFBfCvCjsTcRXhXhT8TcRXhXhT8TcRXhXhT8TcRXhXhT8TcakxBTUUzLjk5LjWqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//tkxMWDzQgxS7zzACgAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
-        anchor: 266667e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 6600,
-        keyRangeLow: 56,
-        keyRangeHigh: 67,
-        loopStart: 64,
-        loopEnd: 192,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAE4ADs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAXAAAAAAAAABODQyktQAAAAAAAAAAAAAAAAAAAA//vkxAAABywBgbQAACYVyC6/P9AwKAASUcckkt4YWD4fLn1AhBCJz5c+oEFghy5/ghy5+cghy7+GKZd/DHLn1HIYk5d/DHL+6H5d5TOdLnbLTLKrBqyq+vlkqeD4lCzTAngBgvMYACAAGg+NZZoFwogYAGAZCwCsDgBJsJhRJLyYvYUvg4BLFAA9AKpqYxQCumE3hMhEBIkBkBLuNR5oOGzUbs0Jk7jR1yTFgpzGY2TMgWV8qtT4fmaf4xDKgxlNgzTGRZScSFbPVQxarGZbWMLiNMUC1MshXMJx+MRSeaZHnuceOvbGrV2ls6MOQUMAAnMDAzMMgRMAQkMCQufiahT9zMJfim7ul5rIDBEFgJBgHgoHQuBANAwFA1WkUbqzssyns944flv09UjUcU9kjkkk9UjZfjOyzKep8Z2kxucyq9+ax9JFNJNJNZNFNFNVNJNJNbKRRvGQxjKejfJ2Udq/9bf1darY41U0U0U1U0k0k+k0U0U+U0k0k+k0e5/zD+5/zD+5/zX93/Nf3f81/d////////7/9f+//X/v/1/7/9Jop8ppJpJ9Jop6qwppJ7KxJGp6qwpHKrKxI2qqqwo3KrKxI2qqq9RuVWV8jaqqr1G5TEFNRTMuOTkuNVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/hwAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
-        anchor: 133333e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 7800,
-        keyRangeLow: 68,
-        keyRangeHigh: 79,
-        loopStart: 32,
-        loopEnd: 96,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAZAAAAAAAAAA8CsVDBMAAAAAAAAAAAAAAAAAAAA//vExAAABmQBjaAAACGQBa9497AdtbAkWdckklxRyjhQ5BBYYqOFHRAXDHKHOGOUOcMco7nOJHawxynnOU5cMcHOXOcHOl3NXGMqsiEAqoMI8QsSUcIsgeiQgJISFCg5ABAyw+VQaiK8yY18FNiuxBUorwU0FdiC4ivimgrsQXEV4KaCuxBcTfBXAv4isTfiuBf6KxN+L4r8RUU3wXoL+JsU3wXoL+JsV3gvRSpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqq6goZoAABEOiCXDs8P3G8oicJAhZjVVVBlsStNFVVUT8StNVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxOuDxEQnByYExigAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
-        anchor: 66667e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 9e3,
-        keyRangeLow: 80,
-        keyRangeHigh: 91,
-        loopStart: 16,
-        loopEnd: 48,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8ChXkahAAAAAAAAAAAAAAAAAAAA//vExAAABkQDh+AAACGUhq9895iZZVlzMgFEYk0nBACCLQfD6gTB8/qBDBwMflC4f/gQMfqBMH/4OHP4Df+XBw5+UBN/6wJu1fapqZhlttyF2FyUYQ0W0QkFSJiRIro4TAYk8aQCAQCAKjiRIkSr+xQUFOBQUV/5BQU4KChv+CgoL4KCu/4QUN8KCn/8UFN8FFf/wgp/hQ3/8FBXYgoL/+FBX5BQ3/8FBfigopVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/gAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
-        anchor: 33333e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 10200,
-        keyRangeLow: 92,
-        keyRangeHigh: 103,
-        loopStart: 8,
-        loopEnd: 56,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8AljJJeAAAAAAAAAAAAAAAAAAAA//vExAAABmgDh+AAACG7Cq649JmAh3unfGYwJRhSgQBBEXB8PjogBDn8EwfP6gQdicP/g4GOXB/lHfgmH905/UclwcOf/8oA/2r/qekIFM1D+AxK8OEgo9IhpLSJFdJaehzC3CbBom0GChJpEiRn/tRxIkSJT6OJJB3BUFXSwNB3BUFQVgqCoaqBoGsqd4iBo8oGgaTWCoaxEDR6VBUFTpUFQV//BoGoiBoO//rxKCv//iIGv/+WTEFNRTMuOTkuNVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy45OS41VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sUxNoDwAAB/gAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV",
-        anchor: 16667e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 11400,
-        keyRangeLow: 104,
-        keyRangeHigh: 115,
-        loopStart: 12,
-        loopEnd: 52,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAADwADm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm5ubm//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaAAAAAAAAAA8CNr1v4AAAAAAAAAAAAAAAAAAAA//vExAAAB1SVheCEbeI4SC349ApomIy4jYiPtA6x5AACs4xjvkAAPmMY/wAXzGMf4AL/X+IgG4PvwQOfIQQOZcH//wQlwfBA5/1h/iB2sP/17/1GMvIAEJ8BiUYMEW0NSAKQjJWj5HCbB/EGHqQ5m2plUuYL1WvVqeGZmb/VVVf9mZr/1VVX9hYGwKgFgbB9TCwNgbB8BG6lKUreYxjfKUrfQxvylK3oYxjeUKAgICJYoCAgICUvoYxvylL9DGN9SlL9P+UrfMYxjOoYCAgIUb6lL////////qUpSzASTEFNRTMuOTkuNaqqqqpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//sUxNoDwAAB/gAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
-        anchor: 8333e-8
-      },
-      {
-        midi: 81,
-        originalPitch: 12600,
-        keyRangeLow: 116,
-        keyRangeHigh: 127,
-        loopStart: 6,
-        loopEnd: 42,
-        coarseTune: 0,
-        fineTune: 0,
-        sampleRate: 48e3,
-        ahdsr: false,
-        file: "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU3LjcyLjEwMQAAAAAAAAAAAAAA//tUwAAAAAAAAAAAAAAAAAAAAAAAWGluZwAAAA8AAAACAAAEIADo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo6Ojo//////////////////////////////////////////////////////////////////8AAAAATGF2YzU3Ljk2AAAAAAAAAAAAAAAAJAaQAAAAAAAABCDWHfeqAAAAAAAAAAAAAAAAAAAA//vUxAAACUUrfeCE1eMLSCx88a54l3jMh4t/trUApEAAAUAGYxja+WMYx/yAAH+MY/+AYx/4AAX8xjH/7/8AF//zHyAMdoIAgAAADAYWTt4IA/Kc5/////////y4Pg/v3FZropQkAAAEiDVBBhkjdBSk5JyDlHqDmWi+kJRsJiOZ69eva6x+zAQEBCm/9VVVb/9mVVL/9mZmP/6qqqn/8ZlVV/6zMzM3/VCgICanXX+5I2JRJHaana+SSNwIQEQAwAQAQEw6j5KBCASACACAKAmBGHcdr5RNR2jtJRsed/DkTU1NTra/3Oc5znf+1rWuc7/3Na1ra/9znOc7/9rWtc7/9zWta3/4c5znO/9rTU1NXOvbW4lDtDyHkPI7TqQIQAxMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpMQU1FMy45OS41qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq//sUxNoDwAABpAAAACAAADSAAAAEqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
-        anchor: 4167e-8
-      }
-    ]
+  // src/libraries/audiocompressor.js
+  var AudioCompressor = class _AudioCompressor {
+    #input = null;
+    #output = null;
+    #audioCtx = null;
+    #limiter = null;
+    #analyser = null;
+    #reverbNode = null;
+    #reverbWet = null;
+    #currentReverbLevel = 0;
+    #eqBands = /* @__PURE__ */ new Map();
+    static #EQ_FREQUENCIES = [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384];
+    static #EQ_Q = /* @__PURE__ */ new Map([
+      [32, 0.7],
+      [64, 0.8],
+      [128, 0.9],
+      [256, 1],
+      [512, 1.1],
+      [1024, 1.2],
+      [2048, 1.4],
+      [4096, 1.6],
+      [8192, 1.8],
+      [16384, 2]
+    ]);
+    constructor(audioCtx, volume, reverb) {
+      this.#audioCtx = audioCtx;
+      this.#input = this.#audioCtx.createGain();
+      let lastNode = this.#input;
+      const frequencies = [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384];
+      frequencies.forEach((freq) => {
+        lastNode = this.#bandEqualizer(lastNode, freq);
+        const label = freq < 1e3 ? freq : freq / 1024 + "k";
+        this["band".concat(label)] = lastNode;
+      });
+      this.#currentReverbLevel = reverb;
+      this.#reverbNode = this.#audioCtx.createConvolver();
+      this.#reverbWet = this.#audioCtx.createGain();
+      this.#reverbWet.gain.setValueAtTime(reverb, this.#audioCtx.currentTime);
+      this.#generateImpulseResponse(1.5, 2);
+      this.#limiter = this.#audioCtx.createDynamicsCompressor();
+      this.#limiter.threshold.setValueAtTime(-10, this.#audioCtx.currentTime);
+      this.#limiter.ratio.setValueAtTime(20, this.#audioCtx.currentTime);
+      this.#limiter.attack.setValueAtTime(1e-3, this.#audioCtx.currentTime);
+      this.#limiter.release.setValueAtTime(0.1, this.#audioCtx.currentTime);
+      this.#limiter.knee.setValueAtTime(0, this.#audioCtx.currentTime);
+      this.#analyser = this.#audioCtx.createAnalyser();
+      this.#analyser.fftSize = 256;
+      this.#analyser.smoothingTimeConstant = 0.6;
+      this.#output = this.#audioCtx.createGain();
+      this.#output.gain.setValueAtTime(volume, this.#audioCtx.currentTime);
+      lastNode.connect(this.#output);
+      this.#output.connect(this.#limiter);
+      this.#output.connect(this.#reverbNode);
+      this.#reverbNode.connect(this.#reverbWet);
+      this.#limiter.connect(this.#analyser);
+      this.#reverbWet.connect(this.#analyser);
+      this.#analyser.connect(this.#audioCtx.destination);
+    }
+    get eqFrequencies() {
+      return _AudioCompressor.#EQ_FREQUENCIES;
+    }
+    get analyser() {
+      return this.#analyser || null;
+    }
+    get input() {
+      return this.#input;
+    }
+    get reverb() {
+      return this.#currentReverbLevel;
+    }
+    set reverb(value) {
+      this.#currentReverbLevel = Math.max(0, Math.min(1, value));
+      this.#reverbWet.gain.setTargetAtTime(this.#currentReverbLevel, this.#audioCtx.currentTime, 0.1);
+    }
+    get masterVolume() {
+      return this.#output.gain.value;
+    }
+    set masterVolume(value) {
+      const linearValue = Math.max(0, Math.min(1, value));
+      const logVolume = Math.pow(linearValue, 2);
+      this.#output.gain.setTargetAtTime(logVolume, this.#audioCtx.currentTime, 0.01);
+    }
+    killReverbTail() {
+      const now = this.#audioCtx.currentTime;
+      this.#reverbWet.gain.cancelScheduledValues(now);
+      this.#reverbWet.gain.setValueAtTime(0, now);
+    }
+    restoreReverb() {
+      this.reverb = this.#currentReverbLevel;
+    }
+    setEQ(gains, smoothTime = 0.04) {
+      const now = this.#audioCtx.currentTime;
+      const MAX_DB = 12;
+      for (const [key, val] of Object.entries(gains)) {
+        const freq = Number(key);
+        const band = this.#eqBands.get(freq);
+        if (!band) continue;
+        const dbValue = Math.max(-MAX_DB, Math.min(MAX_DB, val));
+        band.filter.gain.setTargetAtTime(dbValue, now, smoothTime);
+        band.gain = dbValue;
+      }
+    }
+    getEQ() {
+      const result = {};
+      for (const [freq, band] of this.#eqBands) result[freq] = band.gain;
+      return result;
+    }
+    resetEQ(smoothTime = 0.04) {
+      const flat = {};
+      for (const freq of _AudioCompressor.#EQ_FREQUENCIES) flat[freq] = 0;
+      this.setEQ(flat, smoothTime);
+    }
+    setEQPreset(name) {
+      const presets = {
+        flat: { 32: 0, 64: 0, 128: 0, 256: 0, 512: 0, 1024: 0, 2048: 0, 4096: 0, 8192: 0, 16384: 0 },
+        bass: { 32: 7, 64: 6, 128: 4, 256: 2, 512: 0, 1024: -1, 2048: -1, 4096: 0, 8192: 0, 16384: 0 },
+        treble: { 32: 0, 64: 0, 128: 0, 256: 0, 512: 0, 1024: 1, 2048: 3, 4096: 5, 8192: 7, 16384: 8 },
+        vocal: { 32: -3, 64: -2, 128: 0, 256: 2, 512: 4, 1024: 5, 2048: 4, 4096: 2, 8192: 1, 16384: 0 },
+        loudness: { 32: 6, 64: 4, 128: 1, 256: 0, 512: -1, 1024: -1, 2048: 0, 4096: 2, 8192: 4, 16384: 5 },
+        classical: { 32: 4, 64: 3, 128: 2, 256: 0, 512: 0, 1024: 0, 2048: 0, 4096: 2, 8192: 3, 16384: 4 },
+        jazz: { 32: 4, 64: 3, 128: 1, 256: 0, 512: -1, 1024: -1, 2048: 0, 4096: 1, 8192: 3, 16384: 4 },
+        electronic: { 32: 6, 64: 5, 128: 2, 256: -1, 512: -2, 1024: -1, 2048: 2, 4096: 4, 8192: 5, 16384: 6 }
+      };
+      const preset = presets[name];
+      if (!preset) throw new Error('Preset EQ unkown: "'.concat(name, '". Avaiables: ').concat(Object.keys(presets).join(", ")));
+      this.setEQ(preset);
+    }
+    #bandEqualizer(from, frequency) {
+      const filter = this.#audioCtx.createBiquadFilter();
+      filter.type = "peaking";
+      filter.frequency.setValueAtTime(frequency, this.#audioCtx.currentTime);
+      filter.gain.setValueAtTime(0, this.#audioCtx.currentTime);
+      const q = _AudioCompressor.#EQ_Q.get(frequency) ?? 1;
+      filter.Q.setValueAtTime(q, this.#audioCtx.currentTime);
+      this.#eqBands.set(frequency, { filter, gain: 0 });
+      from.connect(filter);
+      return filter;
+    }
+    #generateImpulseResponse(duration, decay) {
+      const sampleRate = this.#audioCtx.sampleRate;
+      const length = sampleRate * duration;
+      const impulse = this.#audioCtx.createBuffer(2, length, sampleRate);
+      const preDelayTime = 0.015;
+      const preDelaySamples = Math.floor(preDelayTime * sampleRate);
+      for (let channel = 0; channel < impulse.numberOfChannels; channel++) {
+        const data = impulse.getChannelData(channel);
+        let lastValue = 0;
+        const channelOffset = channel === 1 ? Math.floor(2e-3 * sampleRate) : 0;
+        for (let i = 0; i < length; i++) {
+          if (i < preDelaySamples) {
+            data[i] = 0;
+            continue;
+          }
+          const t = (i - preDelaySamples) / sampleRate;
+          const envelope = Math.exp(-t * (decay / duration));
+          const dampingFactor = Math.max(0.01, 0.2 * Math.exp(-t * 2.5));
+          const whiteNoise = Math.random() * 2 - 1;
+          lastValue = whiteNoise * dampingFactor + lastValue * (1 - dampingFactor);
+          let sampleValue = lastValue * envelope;
+          if (t < 0.04) {
+            if (i % 123 === 0 || i % 234 === 0) {
+              sampleValue += (Math.random() * 2 - 1) * 0.2 * (0.04 - t) / 0.04;
+            }
+          }
+          if (i + channelOffset < length) data[i + channelOffset] = sampleValue;
+          else data[i] = sampleValue;
+        }
+      }
+      this.#reverbNode.buffer = impulse;
+    }
   };
 
+  // src/libraries/indexeddbstorage.js
+  var DB_NAME = "MidiAudioPlayer";
+  var STORE_NAME = "KeyValues";
+  var DEFAULT_VERSION = 1;
+  var dbInstance = null;
+  var currentVersion = DEFAULT_VERSION;
+  async function getDB(version = currentVersion) {
+    if (dbInstance && version !== currentVersion) {
+      dbInstance.close();
+      dbInstance = null;
+      currentVersion = version;
+    }
+    if (dbInstance) return dbInstance;
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, version);
+      request.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME);
+        }
+      };
+      request.onsuccess = (e) => {
+        dbInstance = e.target.result;
+        resolve(dbInstance);
+      };
+      request.onerror = (e) => reject(e.target.error);
+    });
+  }
+  var indexedDbStorage = {
+    async setVersion(version) {
+      await getDB(version);
+    },
+    async setItem(key, value, compress = false) {
+      const db = await getDB();
+      let finalData = value;
+      let isCompressed = false;
+      if (compress) {
+        const stringData = JSON.stringify(value);
+        const stream = new Blob([stringData]).stream();
+        const compressedStream = stream.pipeThrough(new CompressionStream("gzip"));
+        const response = new Response(compressedStream);
+        finalData = await response.arrayBuffer();
+        isCompressed = true;
+      }
+      const record = { data: finalData, isCompressed };
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.put(record, key);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async getItem(key) {
+      const db = await getDB();
+      const record = await new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readonly");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(key);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+      if (!record) return null;
+      if (record.isCompressed) {
+        const stream = new Blob([record.data]).stream();
+        const decompressedStream = stream.pipeThrough(new DecompressionStream("gzip"));
+        const response = new Response(decompressedStream);
+        const text = await response.text();
+        return JSON.parse(text);
+      }
+      return record.data;
+    },
+    async removeItem(key) {
+      const db = await getDB();
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.delete(key);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async clear() {
+      const db = await getDB();
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.clear();
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+      });
+    }
+  };
+  var indexeddbstorage_default = indexedDbStorage;
+
   // src/midiaudioplayer.js
-  var MidiAudioPlayer = class extends index.Player {
+  var clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+  var MidiAudioPlayer = class _MidiAudioPlayer extends index.Player {
+    static ENDPOINT = "https://webaudiofonts.com/presets/";
+    static DEFAULT_PRESET = -1;
+    static REFERENCE_GAIN = 0.15;
+    static KARAOKE_CHANNEL = 0;
+    #catalog = null;
     #audioCtx = null;
-    #audioPlayer = null;
-    #activeNotes = null;
+    #compressor = null;
+    #vocalChannel = null;
+    #activeNotes = {};
+    #channelStates = {};
+    #instruments = {};
+    #players = {};
+    #channels = {};
+    #channelVolumes = {};
+    #presetMap = {};
+    #bufferHash = null;
+    #presetTimer = null;
+    #presetMapThread = null;
+    #lyrics = null;
+    #haveLyrics = false;
+    #title = "";
     #opts = {
-      preset: defaultpreset_default,
-      volume: 0.012,
-      onEndFile: null
+      endpoint: _MidiAudioPlayer.ENDPOINT,
+      volume: 0.6,
+      reverb: 0.3,
+      onEndFile: null,
+      localCache: true,
+      presetRandom: false,
+      karaoke: false,
+      karaokeDelay: 0,
+      muteExpression: false,
+      maxCharPerLine: 48,
+      eqPreset: "flat",
+      preferred: [],
+      presets: []
     };
     constructor(opts = {}) {
-      super((event) => this.#handleMidiPipeline(event));
+      super();
       this.#opts = { ...this.#opts, ...opts };
-      this.#activeNotes = /* @__PURE__ */ new Map();
+      this.#presetMapThread = this.#mapPresets();
       this.#audioCtx = new (window.AudioContext || window.webkitAudioContext)();
-      this.#audioPlayer = new WebAudioFontPlayer(this.#audioCtx, this.#opts.preset);
-      this.on("endOfFile", async () => {
-        await new Promise((resolve) => requestAnimationFrame(() => setTimeout(resolve, 1)));
-        await this.#endOfFile();
+      this.#compressor = new AudioCompressor(this.#audioCtx, this.#opts.volume, this.#opts.reverb);
+      this.#compressor.setEQPreset(this.#opts.eqPreset);
+      if (this.#opts.karaoke) this.#sendKaraokeFrame("intro");
+    }
+    get catalog() {
+      return this.getCatalog();
+    }
+    get channels() {
+      return this.#players;
+    }
+    get channelStates() {
+      return this.#channelStates;
+    }
+    get volume() {
+      return this.#opts.volume;
+    }
+    set volume(vol) {
+      this.#opts.volume = clamp(vol, 0, 1);
+      this.#compressor.masterVolume = this.#opts.volume;
+    }
+    get volumes() {
+      return this.#channelVolumes;
+    }
+    get reverb() {
+      return this.#compressor.reverb;
+    }
+    set reverb(rev) {
+      this.#compressor.reverb = rev;
+    }
+    get muteExpression() {
+      return this.#opts.muteExpression;
+    }
+    set muteExpression(val) {
+      this.#opts.muteExpression = Boolean(val);
+    }
+    get eqFrequencies() {
+      return this.#compressor.eqFrequencies;
+    }
+    get eq() {
+      return this.#compressor.getEQ();
+    }
+    getEQ() {
+      return this.#compressor.getEQ();
+    }
+    setEQ(gains) {
+      this.#compressor.setEQ(gains);
+    }
+    setEQPreset(name) {
+      this.#compressor.setEQPreset(name);
+    }
+    setChannelVolume(channel, volume) {
+      this.#channelVolumes[channel] = volume;
+      this.#setupChange();
+    }
+    async #mapPresets() {
+      await Promise.all(this.#opts.presets.map(async (p) => {
+        const preset = await this.findPreset(p);
+        if (preset) this.#presetMap[preset.program] = preset;
+      }));
+    }
+    async findPreset(id) {
+      let preset = null;
+      const categories = await this.getCategories();
+      categories.some((c) => {
+        c.instruments.some((i) => {
+          preset = i.presets.find((p) => p.id == id);
+          if (preset) {
+            preset.category = c.name;
+            preset.instrument = i.name;
+            preset.program = i.program;
+            return true;
+          }
+        });
+        if (preset) return true;
       });
+      return preset;
+    }
+    async close() {
+      Object.keys(this.#players).forEach((id) => this.#players[id].close());
+      await this.#audioCtx.close();
+    }
+    async getCatalog() {
+      if (this.#catalog) return this.#catalog;
+      const cachedata = this.#opts.localCache ? await sessionStorage.getItem("waf_catalog") : null;
+      if (cachedata) this.#catalog = JSON.parse(cachedata);
+      else {
+        this.#log("Downloading catalog...");
+        const response = await fetch("".concat(this.#opts.endpoint, "catalog.json"));
+        if (!response.ok) throw new Error("Impossible to download catalog: ".concat(response.status));
+        this.#catalog = await response.json();
+        if (this.#opts.localCache) await sessionStorage.setItem("waf_catalog", JSON.stringify(this.#catalog));
+      }
+      const catalogDate = new Date(this.#catalog.updatedAt).getTime();
+      const catalogVersion = await indexeddbstorage_default.getItem("waf_catalog_version") || 1;
+      if (catalogVersion < catalogDate) {
+        await indexeddbstorage_default.clear();
+        indexeddbstorage_default.setItem("waf_catalog_version", catalogDate);
+      }
+      return this.#catalog;
+    }
+    async getCategories() {
+      return (await this.getCatalog()).categories;
+    }
+    async getProgramInstruments(program) {
+      const categories = await this.getCategories();
+      let instruments = [];
+      await Promise.all(categories.map(async (category) => category.instruments.filter((elm) => elm.program == program).forEach((elm) => {
+        elm.presets.forEach((p) => {
+          p.instrument = category.name + " / " + elm.name;
+          instruments.push(p);
+        });
+      })));
+      return instruments;
+    }
+    async getPreset(id) {
+      try {
+        if (typeof id === "object") return id;
+        const cacheid = "waf_preset_".concat(id);
+        const cachedata = this.#opts.localCache ? await indexeddbstorage_default.getItem(cacheid) : null;
+        if (cachedata) return JSON.parse(cachedata);
+        this.#log("Downloading preset ".concat(id, "..."));
+        const response = await fetch("".concat(_MidiAudioPlayer.ENDPOINT).concat(id, ".json"));
+        const preset = await response.json();
+        if (preset.zones === void 0) {
+          console.error("Invalid preset: ".concat($id));
+          throw new Error("Invalid preset: ".concat($id));
+        }
+        if (this.#opts.localCache) await indexeddbstorage_default.setItem(cacheid, JSON.stringify(preset), true);
+        return preset;
+      } catch (e) {
+        console.error("Invalid preset: ".concat(id));
+        throw new Error("Invalid preset: ".concat(id));
+      }
+    }
+    async loadPreset(presetId, channel) {
+      const presetInfo = await this.findPreset(presetId);
+      if (!presetInfo) throw new Error("Invalid preset: ".concat(presetId));
+      this.#presetMap[presetInfo.program] = presetInfo;
+      const preset = await this.getPreset(presetId);
+      await this.#players[channel].setPreset(preset);
+      this.#setupChange();
     }
-    async load(content) {
+    async load(content, setup) {
+      if (typeof content === "string") {
+        this.#log("Downloading song...");
+        const response = await fetch(content);
+        content = await response.arrayBuffer();
+      }
+      if (typeof setup === "string") {
+        this.#log("Downloading setup...");
+        const response = await fetch(setup);
+        setup = await response.json();
+      }
+      this.#bufferHash = await this.hashBuffer(content);
+      await this.#presetMapThread;
       if (this.isPlaying()) this.stop();
       this.#clearActiveNotes();
-      await this.loadArrayBuffer(content);
+      await Promise.all(Object.values(this.#players).map(async (player) => player.close()));
+      this.#players = {};
+      this.#instruments = {};
+      this.#activeNotes = {};
+      this.#title = "";
+      this.#log("Loading buffer...");
+      try {
+        await this.loadArrayBuffer(content);
+      } catch (e) {
+        await this.loadArrayBuffer(await this.#repairMidi(content));
+      }
+      this.#log("Loading instruments...");
+      this.#channels = await this.#getInstruments();
+      this.#channelStates = Object.keys(this.#channels).reduce((acc, key) => ({ ...acc, [key]: false }), {});
+      this.#channelVolumes = Object.keys(this.#channels).reduce((acc, key) => ({ ...acc, [key]: 1 }), {});
+      if (setup?.volumes !== void 0) {
+        await Promise.all(Object.keys(setup.volumes).map(async (channel) => {
+          if (this.#channelVolumes[channel] === void 0) return;
+          this.#channelVolumes[channel] = setup.volumes[channel];
+        }));
+      }
+      const setupPrograms = /* @__PURE__ */ new Set();
+      const setupPresets = {};
+      if (setup?.presets !== void 0) {
+        await Promise.all(Object.keys(setup.presets).map(async (channel) => {
+          const presetInfo = await this.findPreset(setup.presets[channel]);
+          if (!presetInfo) return;
+          setupPresets[channel] = await this.getPreset(presetInfo.id);
+          setupPrograms.add(presetInfo.program);
+        }));
+      }
+      const uniqueInstruments = await this.#getUniqueInstruments();
+      if (!Object.values(this.#channels).length) this.#log("Error: no instrument found");
+      const presets = Promise.all([...uniqueInstruments].map(async (program) => {
+        if (setupPrograms.has(program)) return;
+        let preset = null;
+        if (this.#presetMap[program] !== void 0) preset = await this.getPreset(this.#presetMap[program].id);
+        else if (this.#opts.presetRandom) preset = await this.#getRandomPreset(program);
+        else preset = await this.#getAutoPreset(program);
+        this.#instruments[program] = preset;
+      }));
+      if (this.#opts.karaoke) {
+        this.#log("Generating karaoke frames...");
+        this.#lyrics = null;
+        await this.#generateKaraokeFrames();
+        if (this.#title) this.#sendKaraokeFrame("title", this.#title);
+      }
+      this.#log("Trim midi events...");
+      this.#trimMidiEvents();
+      queueMicrotask(() => this.triggerPlayerEvent("computed"));
+      await presets;
+      await Promise.all(Object.keys(this.#channels).map(async (channel) => {
+        if (this.#players[channel]) this.#players[channel].close();
+        if (setupPresets[channel] !== void 0) this.#players[channel] = await this.#createPlayer(setupPresets[channel]);
+        else this.#players[channel] = await this.#createPlayer(this.#instruments[this.#channels[channel]]);
+      }));
+      this.#log("Initializing instrument states...");
+      await this.#initInstrumentStates();
+      await this.triggerPlayerEvent("presetsLoaded", this.#instruments);
+      await this.#setupChange();
+      this.#log("Player ready");
+    }
+    async getSongSetup() {
+      let setup = { hash: this.#bufferHash, presets: {}, volumes: {} };
+      Object.keys(this.#players).map(async (channel) => setup.presets[channel] = this.#players[channel].preset.id);
+      setup.volumes = this.#channelVolumes;
+      return setup;
+    }
+    async getTrainingPresets() {
+      return await Promise.all(Object.values(this.#presetMap).map(async (preset) => preset.id));
     }
     async play(content = null) {
+      if (this.#audioCtx.state === "suspended") {
+        try {
+          await this.#audioCtx.resume();
+        } catch (e) {
+          return false;
+        }
+      }
       if (content) await this.load(content);
-      await this.#audioCtx.resume();
-      await super.play();
+      await Promise.all(Object.keys(this.#players).map(async (k) => await this.#players[k]?.cancelQueue()));
+      this.#compressor.restoreReverb();
+      if (!this.isPlaying()) {
+        if (!this.startTime) this.startTime = (/* @__PURE__ */ new Date()).getTime();
+        this.scheduledTime = Date.now();
+        this.schedulePlayLoop(this.sampleRate);
+      }
+      return true;
     }
     async pause() {
       await super.pause();
+      this.#compressor.killReverbTail();
       await this.#clearActiveNotes();
-      await this.#audioPlayer.cancelQueue();
+      await Promise.all(Object.keys(this.#players).map(async (k) => await this.#players[k]?.cancelQueue()));
     }
-    async stop() {
+    async stop(skipKill = false) {
       await super.stop();
+      this.setTimeoutId = false;
+      if (!skipKill) {
+        this.#compressor.killReverbTail();
+        await Promise.all(Object.keys(this.#players).map(async (k) => await this.#players[k]?.cancelQueue()));
+      }
       await this.#clearActiveNotes();
-      await this.#audioPlayer.cancelQueue();
+      if (this.#opts.karaoke) this.#sendKaraokeFrame("intro");
+      return this;
+    }
+    getRealTimeVolume() {
+      const analyser = this.#compressor.analyser;
+      const dataArray = new Uint8Array(analyser.frequencyBinCount);
+      analyser.getByteFrequencyData(dataArray);
+      let values = 0;
+      for (let i = 0; i < dataArray.length; i++) values += dataArray[i];
+      return values / (dataArray.length * 100);
+    }
+    getSongTimeRemaining() {
+      return this.ticksToSeconds(this.getCurrentTick(), this.totalTicks);
+    }
+    async skipToSeconds(seconds) {
+      const songTime = this.getSongTime();
+      if (seconds < 0 || seconds > songTime) throw seconds + " seconds not within song time of " + songTime;
+      await this.skipToTick(this.secondsToTicks(seconds));
+      return this;
+    }
+    async generateWaveformSVG(samples = 1e3) {
+      if (!this.totalTicks || !this.events) return "";
+      const waveform = new Array(samples).fill(0);
+      const tickInterval = this.totalTicks / samples;
+      const allEvents = this.events.flatMap(
+        (track, trackIdx) => track.map((event) => ({
+          ...event,
+          computedChannel: event.channel !== void 0 ? event.channel : trackIdx
+        }))
+      ).filter(
+        (event) => event.name === "Controller Change" || event.name === "Program Change" || event.name === "Note on" && event.velocity > 0
+      ).sort((a, b) => a.tick - b.tick);
+      const channelsVolume = /* @__PURE__ */ new Map();
+      const channelsExpression = /* @__PURE__ */ new Map();
+      allEvents.forEach((event) => {
+        const idx = Math.floor(event.tick / tickInterval);
+        if (idx >= samples) return;
+        const chan = event.computedChannel;
+        if (!channelsVolume.has(chan)) channelsVolume.set(chan, 100);
+        if (!channelsExpression.has(chan)) channelsExpression.set(chan, 127);
+        if (event.name === "Controller Change") {
+          if (event.number === 7) channelsVolume.set(chan, event.value);
+          else if (event.number === 11) channelsExpression.set(chan, event.value);
+        } else if (event.name === "Note on") {
+          const volFactor = channelsVolume.get(chan) / 127;
+          const expFactor = channelsExpression.get(chan) / 127;
+          const modulatedVelocity = event.velocity * volFactor * expFactor;
+          waveform[idx] += modulatedVelocity;
+        }
+      });
+      const maxAmp = waveform.reduce((max, val) => {
+        if (isNaN(val)) return max;
+        return val > max ? val : max;
+      }, 0);
+      const normalized = maxAmp > 0 ? waveform.map((v) => isNaN(v) ? 0 : v / maxAmp) : waveform.fill(0);
+      const width = samples;
+      const height = width / 5;
+      const points = normalized.map((val, i) => {
+        const x = i;
+        const y = Math.max(0, Math.min(height, height - val * height));
+        return "".concat(x, ",").concat(y.toFixed(2));
+      });
+      const d = "M 0,".concat(height, " L ").concat(points.join(" L "), " L ").concat(width, ",").concat(height);
+      return '<svg class="midiaudioplayer-waveform" viewBox="0 0 '.concat(width, " ").concat(height, '" preserveAspectRatio="none"><path d="').concat(d, '" fill="none" stroke-linecap="round" stroke-linejoin="round" /></svg>');
+    }
+    // ----------------------------------------------------------------------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------------------
+    // ----------------------------------------------------------------------------------------------------------------------
+    async hashBuffer(arrayBuffer, algorithm = "SHA-256") {
+      const hashBuffer = await crypto.subtle.digest(algorithm, arrayBuffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    async #setupChange() {
+      if (this.#presetTimer) clearTimeout(this.#presetTimer);
+      this.#presetTimer = setTimeout(async () => {
+        const setup = await this.getSongSetup();
+        queueMicrotask(() => this.triggerPlayerEvent("setupChange", setup));
+      }, 1e3);
+    }
+    async triggerPlayerEvent(playerEvent, data) {
+      if (playerEvent == "fileLoaded") return;
+      else if (playerEvent == "computed") {
+        this.#vocalChannel = await this.#detectKaraokeVocalChannel();
+        super.triggerPlayerEvent(playerEvent, {
+          title: this.#title,
+          karaoke: this.#haveLyrics,
+          vocalChannel: this.#vocalChannel,
+          tempo: this.tempo,
+          division: this.division,
+          duration: this.getSongTime(),
+          sampleRate: this.sampleRate,
+          totalTicks: this.totalTicks,
+          totalEvents: this.totalEvents,
+          channels: await this.#channels
+        });
+      } else if (playerEvent == "endOfFile" && this.#opts.karaoke) {
+        queueMicrotask(() => super.triggerPlayerEvent(playerEvent, data));
+      } else super.triggerPlayerEvent(playerEvent, data);
+    }
+    async playLoop(dryRun) {
+      if (this.inLoop) return;
+      if (!dryRun && this.endOfFile() && this.tick > 0) {
+        await this.stop(true);
+        this.tick = 0;
+        this.triggerPlayerEvent("endOfFile");
+        return;
+      }
+      this.inLoop = true;
+      this.tick = this.getCurrentTick();
+      const tracksLen = this.tracks.length;
+      for (let i = 0; i < tracksLen; i++) {
+        const result = this.tracks[i].handleEvent(this.tick, dryRun);
+        if (!result) continue;
+        const isArray = result.constructor === Array;
+        const eventsLen = isArray ? result.length : 1;
+        for (let j = 0; j < eventsLen; j++) {
+          const event = isArray ? result[j] : result;
+          const { name, data, value } = event;
+          if (name === "Set Tempo") this.setTempo(data);
+          if (dryRun) {
+            if (name === "Program Change" && !this.instruments.includes(value)) this.instruments.push(value);
+          } else {
+            this.emitEvent(event);
+          }
+        }
+      }
+      if (!dryRun && this.isPlaying()) this.triggerPlayerEvent("playing", { tick: this.tick });
+      this.inLoop = false;
+    }
+    schedulePlayLoop(delay) {
+      this.setTimeoutId = setTimeout(() => {
+        if (this.setTimeoutId === false) return;
+        this.playLoop();
+        const currentAudioTime = this.#audioCtx.currentTime;
+        if (!this._lastAudioTime) this._lastAudioTime = currentAudioTime;
+        const elapsed = currentAudioTime - this._lastAudioTime;
+        this._lastAudioTime = currentAudioTime;
+        const sampleRateSec = this.sampleRate / 1e3;
+        const drift = elapsed - sampleRateSec;
+        const nextDelay = Math.max(0, this.sampleRate - drift * 1e3);
+        this.schedulePlayLoop(nextDelay);
+      }, delay);
+    }
+    emitEvent(event) {
+      this.#handleMidiPipeline(event);
+    }
+    ticksToSeconds(startTick, endTick) {
+      if (endTick === void 0) {
+        endTick = startTick;
+        startTick = 0;
+      }
+      if (startTick >= endTick) return 0;
+      let seconds = 0;
+      const len = this.tempoMap.length;
+      const timeFactor = 60 / this.division;
+      let low = 0;
+      let high = len - 1;
+      let startIndex = 0;
+      while (low <= high) {
+        const mid = low + high >> 1;
+        if (this.tempoMap[mid].tick <= startTick) {
+          startIndex = mid;
+          low = mid + 1;
+        } else {
+          high = mid - 1;
+        }
+      }
+      let currentTick = startTick;
+      for (let i = startIndex; i < len; i++) {
+        const entry = this.tempoMap[i];
+        const nextTick = i + 1 < len ? this.tempoMap[i + 1].tick : endTick;
+        if (nextTick <= startTick) continue;
+        const segStart = Math.max(entry.tick, startTick);
+        const segEnd = Math.min(nextTick, endTick);
+        if (segStart >= endTick) break;
+        seconds += (segEnd - segStart) / entry.tempo * timeFactor;
+        currentTick = segEnd;
+      }
+      if (currentTick < endTick) {
+        const lastEntry = this.tempoMap[len - 1];
+        seconds += (endTick - currentTick) / lastEntry.tempo * timeFactor;
+      }
+      return seconds;
+    }
+    secondsToTicks(seconds) {
+      let remainingSeconds = seconds;
+      const len = this.tempoMap.length;
+      const factor = 60 / this.division;
+      for (let i = 0; i < len; i++) {
+        const entry = this.tempoMap[i];
+        const nextTick = i + 1 < len ? this.tempoMap[i + 1].tick : Infinity;
+        const segmentTicks = nextTick - entry.tick;
+        const segmentSeconds = segmentTicks / entry.tempo * factor;
+        if (remainingSeconds <= segmentSeconds) {
+          return entry.tick + Math.round(remainingSeconds * entry.tempo / factor);
+        }
+        remainingSeconds -= segmentSeconds;
+      }
+      return this.totalTicks;
     }
-    async #endOfFile() {
-      if (typeof this.#opts.onEndFile == "function") await this.#opts.onEndFile();
+    getTickBeforeSeconds(targetTick, seconds) {
+      if (targetTick <= 0) return 0;
+      const targetTime = this.ticksToSeconds(0, targetTick);
+      const desiredTime = Math.max(0, targetTime - seconds);
+      return this.secondsToTicks(desiredTime);
+    }
+    async skipToTick(tick) {
+      const safeTick = Math.max(0, Math.min(tick, this.totalTicks || 0));
+      const wasPlaying = this.isPlaying();
+      this.#clearActiveNotes();
+      Object.keys(this.channels).forEach((k) => this.channels[k]?.cancelQueue?.());
+      if (wasPlaying) super.pause();
+      this.startTick = safeTick;
+      this.tick = safeTick;
+      if (this.tempoMap && this.tempoMap.length > 0) {
+        for (let i = this.tempoMap.length - 1; i >= 0; i--) {
+          if (this.tempoMap[i].tick <= safeTick) {
+            this.setTempo(this.tempoMap[i].tempo);
+            break;
+          }
+        }
+      }
+      try {
+        const controllerChange = [];
+        const programChange = [];
+        const pitchBend = [];
+        const karaokeEvent = [];
+        this.#collectStateAtTick(safeTick).forEach((event) => {
+          const channel = event.channel;
+          if ((channel === void 0 || !this.channels[channel]) && event.name !== "Karaoke Event") return;
+          switch (event.name) {
+            case "Controller Change":
+              controllerChange[event.channel] = event;
+              break;
+            case "Program Change":
+              programChange[event.channel] = event;
+              break;
+            case "Pitch Bend":
+              pitchBend[event.channel] = event;
+              break;
+            case "Karaoke Event":
+              karaokeEvent[event.channel] = event;
+              break;
+          }
+        });
+        controllerChange.forEach((evt) => this.emitEvent(evt));
+        programChange.forEach((evt) => this.emitEvent(evt));
+        pitchBend.forEach((evt) => this.emitEvent(evt));
+        karaokeEvent.forEach((evt) => this.triggerPlayerEvent("karaoke", { type: evt.type, tick: evt.tick, html: evt.text }));
+      } catch (e) {
+        console.warn("Chase MIDI Error:", e);
+        this.#log("Chase MIDI Error:", e);
+      }
+      if (this.tracks && this.tracks.length > 0) {
+        this.tracks.forEach((track, index2) => {
+          const trackEvents = this.events[index2];
+          if (trackEvents && trackEvents.length > 0) {
+            let low = 0;
+            let high = trackEvents.length - 1;
+            let pointer = trackEvents.length;
+            while (low <= high) {
+              const mid = low + high >> 1;
+              if (trackEvents[mid].tick >= safeTick) {
+                pointer = mid;
+                high = mid - 1;
+              } else {
+                low = mid + 1;
+              }
+            }
+            track.eventIndex = pointer;
+          } else if (typeof track.setEventIndexByTick === "function") {
+            track.setEventIndexByTick(safeTick);
+          }
+        });
+      }
+      if (wasPlaying) this.play();
+      else this.triggerPlayerEvent("playing", { tick: safeTick });
+      return this;
+    }
+    #collectStateAtTick(tick) {
+      const dominated = {};
+      if (!this.events) return [];
+      for (let t = 0; t < this.events.length; t++) {
+        const trackEvents = this.events[t];
+        if (!trackEvents || trackEvents.length === 0) continue;
+        let low = 0;
+        let high = trackEvents.length - 1;
+        let endIdx = trackEvents.length;
+        while (low <= high) {
+          const mid = low + high >> 1;
+          if (trackEvents[mid].tick >= tick) {
+            endIdx = mid;
+            high = mid - 1;
+          } else {
+            low = mid + 1;
+          }
+        }
+        for (let i = 0; i < endIdx; i++) {
+          const event = trackEvents[i];
+          let key;
+          if (event.name === "Program Change") {
+            key = "pc:" + event.channel;
+          } else if (event.name === "Controller Change") {
+            key = "cc:" + event.channel + ":" + event.number;
+          } else if (event.name === "Pitch Bend") {
+            key = "pb:" + event.channel;
+          } else if (event.name === "Karaoke Event") {
+            key = "ke:" + event.channel;
+          }
+          if (key) {
+            dominated[key] = event;
+          }
+        }
+      }
+      return Object.keys(dominated).map((key) => dominated[key]);
+    }
+    async #initInstrumentStates() {
+      if (this.events) {
+        this.#collectStateAtTick(1).forEach((event) => {
+          const channel = event.channel;
+          if (!this.#players[channel]) return;
+          switch (event.name) {
+            case "Controller Change":
+              this.#players[channel].setController(event.number, event.value);
+              break;
+            case "Pitch Bend":
+              this.#players[channel].setPitchBend?.(event.value);
+              break;
+            case "Program Change":
+              if (event.value >= 0 && event.value <= 127 && this.#instruments[event.value + 1] !== void 0 && event.channel != 10) {
+                if (this.#players[channel].preset?.program !== event.value + 1) {
+                  this.#players[channel].setPreset(this.#instruments[event.value + 1]);
+                }
+              }
+              break;
+          }
+        });
+      }
+    }
+    async #getInstruments() {
+      const instrumentMap = {};
+      const channelUsed = /* @__PURE__ */ new Set();
+      this.events.forEach((track) => {
+        track.forEach((event) => {
+          if (event.name === "Program Change" && event.value >= 0 && event.value <= 127) {
+            if (instrumentMap[event.channel]) return;
+            else if (event.channel == 10) instrumentMap[event.channel] = -1;
+            else instrumentMap[event.channel] = event.value + 1;
+          } else if (event.name === "Note on" && event.channel == 10) {
+            instrumentMap[event.channel] = -1;
+            channelUsed.add(10);
+          } else if (event.name === "Note on") {
+            channelUsed.add(event.channel);
+          }
+        });
+      });
+      Object.keys(instrumentMap).forEach((channel) => {
+        if (!channelUsed.has(Number(channel))) delete instrumentMap[channel];
+      });
+      return instrumentMap;
+    }
+    async #getUniqueInstruments() {
+      const instrumentMap = /* @__PURE__ */ new Set();
+      this.events.forEach((track) => {
+        track.forEach((event) => {
+          if (event.name === "Program Change" && event.value >= 0 && event.value <= 127) {
+            instrumentMap.add(event.channel == 10 ? -1 : event.value + 1);
+          } else if (event.name === "Note on" && event.channel == 10) instrumentMap.add(-1);
+        });
+      });
+      return instrumentMap;
+    }
+    async #getRandomPreset(program) {
+      const instruments = await this.getProgramInstruments(program);
+      if (!instruments.length) return null;
+      let preset = null;
+      this.#opts.preferred.some((bank) => {
+        const regex = new RegExp("_".concat(bank, "$"), "i");
+        const group = instruments.filter((i) => regex.test(i.id));
+        if (group.length) {
+          preset = group[Math.floor(Math.random() * group.length)];
+          return true;
+        }
+      });
+      if (!preset) preset = instruments[Math.floor(Math.random() * instruments.length)];
+      this.#presetMap[program] = preset;
+      return await this.getPreset(preset.id);
+    }
+    async #getAutoPreset(program) {
+      const instruments = await this.getProgramInstruments(program);
+      if (!instruments.length) return null;
+      let preset = null;
+      this.#opts.preferred.some((bank) => {
+        const regex = new RegExp("_".concat(bank, "$"), "i");
+        preset = instruments.find((i) => regex.test(i.id));
+        if (preset) return true;
+      });
+      if (!preset) preset = instruments[0];
+      this.#presetMap[program] = preset;
+      return await this.getPreset(preset.id);
+    }
+    async #createPlayer(preset) {
+      return new index_default(preset, this.#audioCtx, this.#compressor);
     }
     async #handleMidiPipeline(event) {
-      if (event.name !== "Note on" && event.name !== "Note off") return;
       if (!this.isPlaying()) return;
-      if (event.noteNumber === void 0) return;
-      const now = this.#audioCtx.currentTime;
       switch (event.name) {
         case "Note on":
+          if (event.tick < this.tick - 100) return;
+          if (event.noteNumber === void 0) return;
+          if (event.channel == this.#vocalChannel && this.#opts.muteExpression) return;
           if (event.velocity > 0 && event.velocity <= 127) {
-            this.#stopNotePipe(event.noteNumber);
-            const vol = event.velocity / 127 * this.#opts.volume;
-            const envelope = this.#audioPlayer.queueWaveTable(0, event.noteNumber, 2, vol);
-            this.#activeNotes.set(event.noteNumber, envelope);
+            this.#stopNote(event.channel, event.noteNumber);
+            if (this.#channelVolumes[event.channel] == 0) return;
+            const noteVelocityRatio = event.velocity / 127;
+            const finalVol = _MidiAudioPlayer.REFERENCE_GAIN * Math.pow(noteVelocityRatio, 2) * this.#channelVolumes[event.channel];
+            const envelope = this.#players[event.channel]?.queueWaveTable(0, event.noteNumber, 2, finalVol);
+            if (envelope) this.#addNote(event.channel, event.noteNumber, envelope);
           } else {
-            this.#stopNotePipe(event.noteNumber);
+            this.#stopNote(event.channel, event.noteNumber);
           }
           break;
         case "Note off":
-          this.#stopNotePipe(event.noteNumber);
+          if (event.noteNumber === void 0) return;
+          this.#stopNote(event.channel, event.noteNumber);
+          break;
+        case "Controller Change":
+          this.#players[event.channel]?.setController(event.number, event.value);
+          break;
+        case "Pitch Bend":
+          this.#players[event.channel]?.setPitchBend?.(event.value);
+          break;
+        case "Program Change":
+          return;
+          if (!this.#players[event.channel]) return;
+          if (event.channel == 10 || event.value > 127 || event.value < 0) break;
+          if (this.#players[event.channel] !== void 0 && this.#players[event.channel].preset.program != event.value + 1)
+            this.#players[event.channel].setPreset(this.#instruments[event.value + 1]);
+          break;
+        case "Karaoke Event":
+          if (event.tick < this.tick - this.secondsToTicks(10)) return;
+          this.triggerPlayerEvent("karaoke", { type: event.type, tick: event.tick, html: event.text });
           break;
       }
     }
-    #stopNotePipe(noteNumber) {
-      const envelope = this.#activeNotes.get(noteNumber);
+    #addNote(channel, note, envelope) {
+      if (!this.#activeNotes[channel]) this.#activeNotes[channel] = /* @__PURE__ */ new Map();
+      this.#activeNotes[channel].set(note, envelope);
+      this.#updateChannelStates();
+      const realDurationMs = (envelope.duration || 0) * 1e3;
+      envelope.cleanupTimer = setTimeout(() => {
+        if (this.#activeNotes[channel]?.get(note) === envelope) {
+          this.#activeNotes[channel].delete(note);
+          this.#updateChannelStates();
+        }
+      }, realDurationMs + 50);
+    }
+    #stopNote(channel, noteNumber) {
+      const player = this.#players[channel];
+      const envelope = this.#activeNotes[channel]?.get(noteNumber);
       if (envelope) {
-        envelope.cancel();
-        this.#activeNotes.delete(noteNumber);
+        if (envelope.cleanupTimer) clearTimeout(envelope.cleanupTimer);
+        const removeNoteFromRegistry = () => {
+          this.#activeNotes[channel]?.delete(noteNumber);
+          this.#updateChannelStates();
+        };
+        if (player && player.isSustainActive()) {
+          player.registerSustainNote(() => envelope.cancel(false));
+        } else {
+          envelope.cancel(false);
+        }
+        removeNoteFromRegistry();
       }
     }
     #clearActiveNotes() {
-      if (this.#activeNotes) {
-        this.#activeNotes.forEach((envelope, note) => {
-          if (envelope && envelope.cancel) envelope.cancel();
+      Object.keys(this.#activeNotes).forEach((channel) => {
+        this.#activeNotes[channel].forEach((envelope, note) => {
+          if (envelope) {
+            if (envelope.cleanupTimer) clearTimeout(envelope.cleanupTimer);
+            if (envelope.cancel) envelope.cancel(true);
+          }
+          this.#activeNotes[channel]?.delete(note);
+        });
+      });
+      this.#updateChannelStates();
+    }
+    async #updateChannelStates() {
+      let hasChanged = false;
+      const nextStates = {};
+      Object.keys(this.#players).forEach((channel) => {
+        const isActive = Boolean(this.#activeNotes[channel]?.size && this.#activeNotes[channel].size > 0);
+        nextStates[channel] = isActive;
+        if (this.#channelStates[channel] !== isActive) hasChanged = true;
+      });
+      if (hasChanged) {
+        this.#channelStates = nextStates;
+        this.triggerPlayerEvent("channelState", this.#channelStates);
+      }
+    }
+    async #repairMidi(buffer) {
+      const src = new Uint8Array(buffer);
+      const view = new DataView(buffer);
+      const magic = String.fromCharCode(...src.slice(0, 4));
+      if (magic !== "MThd") throw new Error("Invalid MIDI file (MThd missing)");
+      const headerLen = view.getUint32(4);
+      const format = view.getUint16(8);
+      const ntrks = view.getUint16(10);
+      const division = view.getUint16(12);
+      const EOT = [255, 47, 0];
+      const chunks = [];
+      let pos = 8 + headerLen;
+      while (pos < src.length) {
+        if (pos + 8 > src.length) {
+          break;
+        }
+        const tag = String.fromCharCode(...src.slice(pos, pos + 4));
+        const declaredLen = view.getUint32(pos + 4);
+        const dataStart = pos + 8;
+        const dataEnd = dataStart + declaredLen;
+        if (tag !== "MTrk") {
+          const end = Math.min(dataEnd, src.length);
+          chunks.push({ tag, data: src.slice(pos, end), repaired: false });
+          pos = dataEnd;
+          continue;
+        }
+        const trackNum = chunks.filter((c) => c.tag === "MTrk").length + 1;
+        const available = Math.min(declaredLen, src.length - dataStart);
+        const trackData = src.slice(dataStart, dataStart + available);
+        const last3 = trackData.slice(-3);
+        const hasEOT = last3[0] === 255 && last3[1] === 47 && last3[2] === 0;
+        if (hasEOT && available === declaredLen) {
+          chunks.push({ tag, data: trackData, repaired: false });
+        } else {
+          let repairedData;
+          if (available < declaredLen) {
+            const missing = declaredLen - available;
+            const last2 = trackData.slice(-2);
+            if (last2[0] === 255 && last2[1] === 47) {
+              repairedData = new Uint8Array(trackData.length + 1);
+              repairedData.set(trackData);
+              repairedData[trackData.length] = 0;
+            } else {
+              repairedData = new Uint8Array(trackData.length + 3);
+              repairedData.set(trackData);
+              repairedData.set(EOT, trackData.length);
+            }
+          } else {
+            repairedData = new Uint8Array(trackData.length + 3);
+            repairedData.set(trackData);
+            repairedData.set(EOT, trackData.length);
+          }
+          chunks.push({ tag, data: repairedData, repaired: true });
+        }
+        pos = dataEnd;
+      }
+      const fixedNtrks = chunks.filter((c) => c.tag === "MTrk").length;
+      const totalSize = 14 + chunks.reduce((acc, c) => acc + 8 + c.data.length, 0);
+      const out = new Uint8Array(totalSize);
+      const outView = new DataView(out.buffer);
+      out.set([77, 84, 104, 100], 0);
+      outView.setUint32(4, 6);
+      outView.setUint16(8, format);
+      outView.setUint16(10, fixedNtrks);
+      outView.setUint16(12, division);
+      let outPos = 14;
+      for (const chunk of chunks) {
+        const tagBytes = chunk.tag.split("").map((c) => c.charCodeAt(0));
+        out.set(tagBytes, outPos);
+        outView.setUint32(outPos + 4, chunk.data.length);
+        out.set(chunk.data, outPos + 8);
+        outPos += 8 + chunk.data.length;
+      }
+      const repairedCount = chunks.filter((c) => c.repaired).length;
+      return out.buffer;
+    }
+    #trimMidiEvents() {
+      if (!this.events || this.events.length === 0) return;
+      let firstNoteTick = Infinity;
+      let lastNoteTick = 0;
+      this.events.forEach((track) => {
+        track.forEach((event) => {
+          if (event.name === "Note on" || event.name === "Note off") {
+            if (event.tick < firstNoteTick) firstNoteTick = event.tick;
+            if (event.tick > lastNoteTick) lastNoteTick = event.tick;
+          }
+        });
+      });
+      if (firstNoteTick === Infinity) return;
+      const allSetupEventsBeforeFirstNote = [];
+      this.events.forEach((track, trackIdx) => {
+        track.forEach((event) => {
+          const isSetupEvent = event.name === "Program Change" || event.name === "Controller Change" || event.name === "Pitch Bend" || event.name === "Set Tempo";
+          if (event.tick < firstNoteTick && isSetupEvent) {
+            allSetupEventsBeforeFirstNote.push({ event, trackIdx });
+          }
+        });
+      });
+      const uniqueSetupByTrack = Object.fromEntries(this.events.map((_, idx) => [idx, []]));
+      const globalUniqueKeys = /* @__PURE__ */ new Set();
+      for (let i = allSetupEventsBeforeFirstNote.length - 1; i >= 0; i--) {
+        const { event, trackIdx } = allSetupEventsBeforeFirstNote[i];
+        const channel = event.channel !== void 0 ? event.channel : "track-".concat(trackIdx);
+        let key = null;
+        if (event.name === "Program Change") {
+          key = "pc:".concat(channel);
+        } else if (event.name === "Controller Change") {
+          key = "cc:".concat(channel, ":").concat(event.number);
+        } else if (event.name === "Pitch Bend") {
+          key = "pb:".concat(channel);
+        } else if (event.name === "Set Tempo") {
+          key = "tempo";
+        }
+        if (key) {
+          if (!globalUniqueKeys.has(key)) {
+            globalUniqueKeys.add(key);
+            const clonedEvent = { ...event, tick: 0 };
+            uniqueSetupByTrack[trackIdx].push(clonedEvent);
+          }
+        }
+      }
+      const trimmedEvents = this.events.map((track, trackIdx) => {
+        const newTrack = [];
+        track.forEach((event) => {
+          const isSetupEvent = event.name === "Program Change" || event.name === "Controller Change" || event.name === "Pitch Bend" || event.name === "Set Tempo";
+          const isTextOrKaraoke = event.name === "Text Event" || event.name === "Lyric Event" || event.name === "Track Name" || event.name === "Karaoke Event";
+          if (event.tick < firstNoteTick) {
+            if (!isSetupEvent && (isTextOrKaraoke || trackIdx === 0)) {
+              event.tick = 0;
+              newTrack.push(event);
+            }
+          } else {
+            event.tick = event.tick - firstNoteTick;
+            const maxAllowedTick = lastNoteTick - firstNoteTick;
+            if (event.tick > maxAllowedTick) {
+              event.tick = maxAllowedTick;
+            }
+            newTrack.push(event);
+          }
         });
-        this.#activeNotes.clear();
+        const filteredTrackSetup = uniqueSetupByTrack[trackIdx] || [];
+        return [...filteredTrackSetup, ...newTrack].sort((a, b) => a.tick - b.tick);
+      });
+      this.events = trimmedEvents;
+      this.totalTicks = lastNoteTick - firstNoteTick;
+      if (typeof this.computeTempoMap === "function") this.computeTempoMap();
+    }
+    async #extractLyrics() {
+      if (this.#lyrics) return this.#lyrics;
+      const structure = { language: "", title: "", paragraphs: [] };
+      let bestTrack = null;
+      let maxTextEventsCount = 0;
+      this.events.forEach((track) => {
+        const textEventsInTrack = track.filter(
+          (e) => e.name === "Text Event" || e.name === "Lyric Event" || e.name === "Cue Point" || e.name === "Marker" || e.name === "Track Name"
+        );
+        const realLyricsCount = textEventsInTrack.filter((e) => {
+          const textStr = e.string || e.text || "";
+          return textStr && !textStr.startsWith("@");
+        }).length;
+        if (realLyricsCount > maxTextEventsCount) {
+          maxTextEventsCount = realLyricsCount;
+          bestTrack = textEventsInTrack;
+        }
+      });
+      if (!bestTrack || bestTrack.length === 0) return structure;
+      const allTextEvents = bestTrack.sort((a, b) => a.tick - b.tick);
+      let paragraphs = [];
+      let currentParaLines = [];
+      let currentLineBlocks = [];
+      let lastBlockTick = 0;
+      allTextEvents.forEach((event) => {
+        let text = this.#decodeKaraokeString(event.string || "");
+        if (!text) return;
+        if (/^Track-/i.test(text.trim()) || /^Piste/i.test(text.trim()) || text.trim() === "" || event.tick === 0 && text.length > 20) {
+          return;
+        }
+        if (text.startsWith("@L")) {
+          structure.language = text.substring(2).trim();
+          return;
+        }
+        if (text.startsWith("@T")) {
+          structure.title += (structure.title ? " / " : "") + text.substring(2).trim();
+          return;
+        }
+        if (text.startsWith("@") || text.startsWith("(") || text.startsWith("PART") || /^\d+\s+\d+/.test(text.trim())) {
+          return;
+        }
+        if (/^(Verse|Chorus|Bridge|Break|Intro|End\.)/i.test(text.trim())) {
+          const isExplicitCut = text.startsWith("\\") || text.startsWith("/");
+          const isNaturalTransition = currentLineBlocks.length === 0 || event.tick - lastBlockTick > 500;
+          if (isExplicitCut || isNaturalTransition) {
+            if (currentLineBlocks.length > 0) {
+              currentParaLines.push({ tick: currentLineBlocks[0].tick, blocks: currentLineBlocks });
+              currentLineBlocks = [];
+            }
+            if (currentParaLines.length > 0) {
+              while (currentParaLines.length > 4) {
+                const linesToPush = currentParaLines.splice(0, 4);
+                paragraphs.push({ tick: linesToPush[0].tick, lines: linesToPush });
+              }
+              if (currentParaLines.length > 0) {
+                paragraphs.push({ tick: currentParaLines[0].tick, lines: currentParaLines });
+                currentParaLines = [];
+              }
+            }
+          }
+          return;
+        }
+        let forceNewLine = false;
+        if (currentLineBlocks.length > 0) {
+          const prevBlock = currentLineBlocks[currentLineBlocks.length - 1];
+          const prevText = prevBlock.text;
+          const currentTrimmed = text.trimLeft();
+          if (currentTrimmed.length > 0) {
+            const isCapitalized = /^[A-Z]/.test(currentTrimmed) || /^'[A-Z]/.test(currentTrimmed);
+            const prevIsCapitalized = /^[A-Z]/.test(prevText.trim()) || /^'[A-Z]/.test(prevText.trim());
+            if (isCapitalized && !prevText.endsWith(" ") && prevText.trim() != "o" && !prevIsCapitalized) {
+              if (event.tick > lastBlockTick) {
+                forceNewLine = true;
+              }
+            }
+            if (text.startsWith('"') && prevText.endsWith('"')) {
+              forceNewLine = true;
+            }
+            if (text.startsWith('"') && (prevText.endsWith(")") || prevText.endsWith(')"'))) {
+              forceNewLine = true;
+            }
+            if (currentTrimmed.startsWith('"') && prevText.trimRight().endsWith(")")) {
+              forceNewLine = true;
+            }
+          }
+        }
+        const isNewParagraphMarker = text.startsWith("\\");
+        const isNewLineMarker = text.startsWith("/") || forceNewLine;
+        if (isNewParagraphMarker || isNewLineMarker) {
+          if (text.startsWith("\\") || text.startsWith("/")) {
+            text = text.substring(1);
+          }
+        }
+        text = text.replace(/[\r\n]/g, "");
+        let isTimeGapTrigger = false;
+        if (lastBlockTick > 0 && event.tick > lastBlockTick) {
+          const secondsSilence = this.ticksToSeconds(lastBlockTick, event.tick);
+          if (secondsSilence > 2.5) {
+            isTimeGapTrigger = true;
+          }
+        }
+        const currentLineChars = currentLineBlocks.reduce((sum, b) => sum + b.text.length, 0);
+        const isWordLimitTrigger = currentLineChars + text.length > this.#opts.maxCharPerLine;
+        if (isNewLineMarker || isNewParagraphMarker || isTimeGapTrigger || isWordLimitTrigger) {
+          if (currentLineBlocks.length > 0) {
+            currentParaLines.push({ tick: currentLineBlocks[0].tick, blocks: currentLineBlocks });
+            currentLineBlocks = [];
+          }
+          if (currentParaLines.length > 0) {
+            if (isNewParagraphMarker || isTimeGapTrigger) {
+              while (currentParaLines.length > 4) {
+                const linesToPush = currentParaLines.splice(0, 4);
+                paragraphs.push({ tick: linesToPush[0].tick, lines: linesToPush });
+              }
+              if (currentParaLines.length > 0) {
+                paragraphs.push({ tick: currentParaLines[0].tick, lines: currentParaLines });
+                currentParaLines = [];
+              }
+            } else if (currentParaLines.length >= 6) {
+              const linesToPush = currentParaLines.splice(0, 4);
+              paragraphs.push({ tick: linesToPush[0].tick, lines: linesToPush });
+            }
+          }
+        }
+        if (text.length > 0) {
+          currentLineBlocks.push({ text, tick: event.tick });
+          lastBlockTick = event.tick;
+        }
+      });
+      if (currentLineBlocks.length > 0) {
+        currentParaLines.push({
+          tick: currentLineBlocks[0].tick,
+          blocks: currentLineBlocks
+        });
+      }
+      while (currentParaLines.length > 4) {
+        const linesToPush = currentParaLines.splice(0, 4);
+        paragraphs.push({ tick: linesToPush[0].tick, lines: linesToPush });
+      }
+      if (currentParaLines.length > 0) {
+        paragraphs.push({ tick: currentParaLines[0].tick, lines: currentParaLines });
+      }
+      paragraphs = paragraphs.filter((p) => {
+        return !(p.lines.length == 1 && p.lines[0].blocks.length == 1 && ["intro", "outro", "sfx", "solo", "chorus", "verse", "bridge", "break", "end"].includes(p.lines[0].blocks[0].text.toLowerCase().trim()));
+      });
+      if (paragraphs.length <= 2) paragraphs = [];
+      structure.paragraphs = paragraphs;
+      this.#lyrics = structure;
+      return structure;
+    }
+    async #generateKaraokeFrames() {
+      const lyrics = await this.#extractLyrics();
+      if (!lyrics.paragraphs.length) {
+        this.#haveLyrics = false;
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: '<span class="karaoke-intro"></span>',
+          name: "Karaoke Event",
+          type: "intro",
+          tick: 0,
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL] = this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].sort((a, b) => a.tick - b.tick);
+        return;
+      }
+      this.#haveLyrics = true;
+      this.#title = lyrics.title;
+      let lastFrameEnd = 0;
+      const delayTicks = this.secondsToTicks(this.#opts.karaokeDelay);
+      const threeSecondsInTicks = this.secondsToTicks(3);
+      const fiveSecondsInTicks = this.secondsToTicks(5);
+      const sevenSecondsInTicks = this.secondsToTicks(7);
+      const tenSecondsInTicks = this.secondsToTicks(10);
+      const allBlocksInSong = [];
+      lyrics.paragraphs.forEach((p, pIdx) => {
+        p.lines.forEach((l, lIdx) => {
+          l.blocks.forEach((b) => {
+            allBlocksInSong.push({
+              block: b,
+              lineIdx: lIdx,
+              paraIdx: pIdx,
+              paragraph: p,
+              fastLinesText: p.lines.map((li) => li.blocks.map((bl) => bl.text).join(""))
+            });
+          });
+        });
+      });
+      const paragraphDisplayTicks = [];
+      lyrics.paragraphs.forEach((p, pIdx) => {
+        let paragraphDisplayTick = this.getTickBeforeSeconds(p.tick, 5);
+        if (paragraphDisplayTick < lastFrameEnd)
+          paragraphDisplayTick = lastFrameEnd + (p.tick - lastFrameEnd) / 2;
+        if (pIdx === 0 && paragraphDisplayTick < 20)
+          paragraphDisplayTick = 20;
+        paragraphDisplayTicks[pIdx] = paragraphDisplayTick;
+        const fastLinesText = p.lines.map((li) => li.blocks.map((b) => b.text).join(""));
+        const initialHTML = fastLinesText.map((lineText) => '<span class="karaoke-coming">'.concat(lineText, "</span>")).join("<br/>");
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: initialHTML,
+          name: "Karaoke Event",
+          type: "lyric",
+          tick: paragraphDisplayTick,
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+        if (p.lines.length > 0) {
+          const lastLine = p.lines[p.lines.length - 1];
+          if (lastLine.blocks.length > 0)
+            lastFrameEnd = lastLine.blocks[lastLine.blocks.length - 1].tick;
+        }
+      });
+      const firstParaDisplayTick = paragraphDisplayTicks[0] || 0;
+      if (firstParaDisplayTick > 25) {
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: '<span class="karaoke-clear"></span>',
+          name: "Karaoke Event",
+          type: "clear",
+          tick: 5,
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+      }
+      allBlocksInSong.forEach((current, index2) => {
+        const currentBlock = current.block;
+        const currentLineIdx = current.lineIdx;
+        const currentParaIdx = current.paraIdx;
+        const p = current.paragraph;
+        const fastLinesText = current.fastLinesText;
+        const generateHTML = (forceAllPlayedOnActiveLine = false) => {
+          return p.lines.map((li, liIdx) => {
+            if (liIdx < currentLineIdx)
+              return '<span class="karaoke-played">'.concat(fastLinesText[liIdx], "</span>");
+            if (liIdx > currentLineIdx)
+              return '<span class="karaoke-coming">'.concat(fastLinesText[liIdx], "</span>");
+            let lineHTML = "";
+            li.blocks.forEach((block) => {
+              let className = "coming";
+              if (forceAllPlayedOnActiveLine || block.tick < currentBlock.tick)
+                className = "played";
+              else if (block.tick === currentBlock.tick)
+                className = "playing";
+              lineHTML += '<span class="karaoke-'.concat(className, '">').concat(block.text, "</span>");
+            });
+            return lineHTML;
+          }).join("<br>");
+        };
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: generateHTML(false),
+          name: "Karaoke Event",
+          type: "lyric",
+          tick: currentBlock.tick - delayTicks,
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+        const next = allBlocksInSong[index2 + 1];
+        if (next) {
+          const tickDifference = next.block.tick - currentBlock.tick;
+          if (tickDifference > threeSecondsInTicks) {
+            let targetCleanupTick = currentBlock.tick + threeSecondsInTicks;
+            let targetClearTick = currentBlock.tick + sevenSecondsInTicks;
+            let shouldAddClear = tickDifference > tenSecondsInTicks && currentParaIdx > 0;
+            if (next.paraIdx !== currentParaIdx) {
+              const nextParaDisplayTick = paragraphDisplayTicks[next.paraIdx];
+              if (targetCleanupTick >= nextParaDisplayTick)
+                targetCleanupTick = nextParaDisplayTick - 1;
+              if (shouldAddClear) {
+                if (targetClearTick >= nextParaDisplayTick || nextParaDisplayTick - targetClearTick < threeSecondsInTicks)
+                  shouldAddClear = false;
+              }
+            }
+            if (targetCleanupTick > currentBlock.tick) {
+              this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+                text: generateHTML(true),
+                name: "Karaoke Event",
+                type: "lyric",
+                tick: targetCleanupTick - delayTicks,
+                channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+              });
+            }
+            if (shouldAddClear && targetClearTick > targetCleanupTick) {
+              this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+                text: '<span class="karaoke-clear"></span>',
+                name: "Karaoke Event",
+                type: "clear",
+                tick: targetClearTick - delayTicks,
+                channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+              });
+            }
+          }
+        }
+        lastFrameEnd = currentBlock.tick;
+      });
+      if (this.totalTicks - lastFrameEnd > this.secondsToTicks(5)) {
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: '<span class="karaoke-clear"></span>',
+          name: "Karaoke Event",
+          type: "clear",
+          tick: lastFrameEnd + this.secondsToTicks(5),
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+      } else {
+        this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].push({
+          text: '<span class="karaoke-clear"></span>',
+          name: "Karaoke Event",
+          type: "clear",
+          tick: this.totalTicks - 1,
+          channel: _MidiAudioPlayer.KARAOKE_CHANNEL
+        });
+      }
+      this.events[_MidiAudioPlayer.KARAOKE_CHANNEL] = this.events[_MidiAudioPlayer.KARAOKE_CHANNEL].sort((a, b) => a.tick - b.tick);
+    }
+    async #detectKaraokeVocalChannel() {
+      const lyrics = await this.#extractLyrics();
+      if (!lyrics?.paragraphs?.length) return null;
+      const textTicks = lyrics.paragraphs.flatMap((p) => p.lines.flatMap((l) => l.blocks.map((b) => b.tick)));
+      if (textTicks.length === 0) return null;
+      const tickTolerance = this.division ? this.division / 2 : 48;
+      const VOCAL_MIN = 48;
+      const VOCAL_MAX = 84;
+      const channelsToScan = Object.keys(this.#channels).map(Number).filter((chan) => chan !== 10);
+      let bestChannel = null;
+      let bestScore = -Infinity;
+      for (const channel of channelsToScan) {
+        const notes = this.events.flatMap(
+          (track) => track.filter(
+            (e) => e.name === "Note on" && e.velocity > 0 && e.channel === channel
+          )
+        );
+        if (notes.length === 0) continue;
+        const aligned = textTicks.filter(
+          (t) => notes.some((n) => Math.abs(n.tick - t) <= tickTolerance)
+        ).length;
+        const alignmentScore = aligned / textTicks.length;
+        const notesInRange = notes.filter((n) => n.noteNumber >= VOCAL_MIN && n.noteNumber <= VOCAL_MAX);
+        const rangeScore = notesInRange.length / notes.length;
+        if (rangeScore < 0.3) continue;
+        const sorted = [...notes].sort((a, b) => a.tick - b.tick);
+        const minGap = this.division / 8 || 6;
+        const poly = sorted.filter((n, i) => i > 0 && Math.abs(n.tick - sorted[i - 1].tick) < minGap).length;
+        const monophonyScore = 1 - poly / Math.max(notes.length - 1, 1);
+        const densityRatio = notes.length / Math.max(textTicks.length, 1);
+        const densityScore = densityRatio < 0.3 ? densityRatio / 0.3 : densityRatio > 5 ? Math.max(0, 1 - (densityRatio - 5) / 10) : 1;
+        const score = alignmentScore * 0.45 + rangeScore * 0.35 + monophonyScore * 0.15 + densityScore * 0.05;
+        if (score > bestScore) {
+          bestScore = score;
+          bestChannel = channel;
+        }
       }
+      return bestScore >= 0.4 ? bestChannel : null;
+    }
+    #decodeKaraokeString(str) {
+      if (!str) return "";
+      const bytes = new Uint8Array(str.length);
+      for (let i = 0; i < str.length; i++) bytes[i] = str.charCodeAt(i) & 255;
+      const decoder = new TextDecoder("windows-1252");
+      let decoded = decoder.decode(bytes);
+      decoded = decoded.replace(/ÿ/g, "");
+      decoded = decoded.replace(/’/g, "'");
+      decoded = decoded.replace(/`/g, "'");
+      return decoded;
+    }
+    #sendKaraokeFrame(type = "clear", text = "") {
+      const html = '<span class="karaoke-'.concat(type, '">').concat(text.replace(/\s\/\s/g, "<br>"), "</span>");
+      if (this.#opts.karaoke) {
+        if (type == "title") queueMicrotask(() => this.triggerPlayerEvent("karaoke", { type, title: text, html }));
+        else queueMicrotask(() => this.triggerPlayerEvent("karaoke", { type, html }));
+      }
+    }
+    #log(str, err = false) {
+      queueMicrotask(() => this.triggerPlayerEvent("logs", str));
     }
   };
 
   // index.js
   if (typeof window !== "undefined") window.MidiAudioPlayer = MidiAudioPlayer;
-  var index_default = MidiAudioPlayer;
+  var index_default2 = MidiAudioPlayer;
 })();
-//# sourceMappingURL=midi-audio-player.js.map