midi-audio-player 1.1.2 → 2.0.0

package/dist/index.js

@@ -1,18 +1,18 @@
 /*!
 
-	██████╗ ██╗ █████╗ ███╗   ███╗███████╗████████╗██████╗ ██╗ ██████╗██╗  ██╗
-	██╔══██╗██║██╔══██╗████╗ ████║██╔════╝╚══██╔══╝██╔══██╗██║██╔════╝██║ ██╔╝
-	██║  ██║██║███████║██╔████╔██║█████╗     ██║   ██████╔╝██║██║     █████╔╝
-	██║  ██║██║██╔══██║██║╚██╔╝██║██╔══╝     ██║   ██╔══██╗██║██║     ██╔═██╗
-	██████╔╝██║██║  ██║██║ ╚═╝ ██║███████╗   ██║   ██║  ██║██║╚██████╗██║  ██╗
-	╚═════╝ ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝	
+	███╗   ███╗██╗██████╗ ██╗ █████╗ ██╗   ██╗██████╗ ██╗ ██████╗ ██████╗ ██╗      █████╗ ██╗   ██╗███████╗██████╗
+	████╗ ████║██║██╔══██╗██║██╔══██╗██║   ██║██╔══██╗██║██╔═══██╗██╔══██╗██║     ██╔══██╗╚██╗ ██╔╝██╔════╝██╔══██╗
+	██╔████╔██║██║██║  ██║██║███████║██║   ██║██║  ██║██║██║   ██║██████╔╝██║     ███████║ ╚████╔╝ █████╗  ██████╔╝
+	██║╚██╔╝██║██║██║  ██║██║██╔══██║██║   ██║██║  ██║██║██║   ██║██╔═══╝ ██║     ██╔══██║  ╚██╔╝  ██╔══╝  ██╔══██╗
+	██║ ╚═╝ ██║██║██████╔╝██║██║  ██║╚██████╔╝██████╔╝██║╚██████╔╝██║     ███████╗██║  ██║   ██║   ███████╗██║  ██║
+	╚═╝     ╚═╝╚═╝╚═════╝ ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+	Version: 2.0.0
+	Build:   2026-05-29 17:16:44
+	Author:  Maxime Larrivée-Roy <mlarriveeroy@gmail.com>
+	Github:  https://github.com/webaudiofonts/midi-audio-player/
+	Website: https://webaudiofonts.github.io/midi-audio-player/
 
-	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,85 @@ var index = {
   Constants
 };
 
-// src/webaudiofontplayer.js
+// node_modules/webaudiofontplayer/dist/index.js
 var WebAudioFontPlayer = class {
   #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) {
     this.#audioCtx = audioCtx;
+    this.#compressor = compressor;
+    this.#preset = preset;
+    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.#preset.zones.map((zone) => this.#adjustZone(zone));
+  }
+  get preset() {
+    return this.#preset;
+  }
+  set preset(preset) {
     this.#preset = preset;
     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 +1303,9 @@ var WebAudioFontPlayer = class {
     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 +1321,10 @@ var WebAudioFontPlayer = class {
     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,22 +1336,54 @@ var WebAudioFontPlayer = class {
       }
     });
   }
+  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;
+    }
+  }
   #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) {
+    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);
@@ -1305,6 +1396,7 @@ var WebAudioFontPlayer = class {
         },
         (error) => {
           console.error("Audio decoding error:", error);
+          console.warn(this.#preset);
           return false;
         }
       );
@@ -1319,10 +1411,9 @@ var WebAudioFontPlayer = class {
     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 +1421,7 @@ var WebAudioFontPlayer = class {
     ];
     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 +1431,7 @@ var WebAudioFontPlayer = class {
       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 +1439,24 @@ var WebAudioFontPlayer = class {
       }
       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,21 +1466,32 @@ var WebAudioFontPlayer = class {
         }
         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) {
@@ -1399,212 +1510,1604 @@ var WebAudioFontPlayer = class {
     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 load(content) {
+  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);
+    this.#players[channel].preset = preset;
+    this.#setupChange();
+  }
+  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;
+  }
+  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 (
+              // (this.#opts.presetAuto || this.#opts.presetRandom) &&
+              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].preset = 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 #endOfFile() {
-    if (typeof this.#opts.onEndFile == "function") await this.#opts.onEndFile();
+  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].preset = 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 });
+        }
       });
-      this.#activeNotes.clear();
+    });
+    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);
+        }
+      });
+      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;
 export {
   MidiAudioPlayer,
-  index_default as default
+  index_default2 as default
 };
 //# sourceMappingURL=index.js.map