@marmooo/midy 0.0.4 → 0.0.5

package/esm/midy.js

@@ -1,5 +1,55 @@
 import { parseMidi } from "./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js";
-import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.1/+esm.js";
+import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.js";
+class Note {
+    constructor(noteNumber, velocity, startTime, instrumentKey) {
+        Object.defineProperty(this, "bufferSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gainNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filterNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modLFO", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modLFOGain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vibLFO", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vibLFOGain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.noteNumber = noteNumber;
+        this.velocity = velocity;
+        this.startTime = startTime;
+        this.instrumentKey = instrumentKey;
+    }
+}
 export class Midy {
     constructor(audioContext) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -181,10 +231,8 @@ export class Midy {
         const pannerNode = new StereoPannerNode(audioContext, {
             pan: Midy.channelSettings.pan,
         });
-        const modulationEffect = this.createModulationEffect(audioContext);
         const reverbEffect = this.createReverbEffect(audioContext);
         const chorusEffect = this.createChorusEffect(audioContext);
-        modulationEffect.lfo.start();
         chorusEffect.lfo.start();
         reverbEffect.dryGain.connect(pannerNode);
         reverbEffect.wetGain.connect(pannerNode);
@@ -193,7 +241,6 @@ export class Midy {
         return {
             gainNode,
             pannerNode,
-            modulationEffect,
             reverbEffect,
             chorusEffect,
         };
@@ -216,11 +263,11 @@ export class Midy {
         });
         return channels;
     }
-    async createNoteBuffer(noteInfo, isSF3) {
-        const sampleEnd = noteInfo.sample.length + noteInfo.end;
+    async createNoteBuffer(instrumentKey, isSF3) {
+        const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
         if (isSF3) {
-            const sample = new Uint8Array(noteInfo.sample.length);
-            sample.set(noteInfo.sample);
+            const sample = new Uint8Array(instrumentKey.sample.length);
+            sample.set(instrumentKey.sample);
             const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
             for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
                 const channelData = audioBuffer.getChannelData(channel);
@@ -229,26 +276,27 @@ export class Midy {
             return audioBuffer;
         }
         else {
-            const sample = noteInfo.sample.subarray(0, sampleEnd);
+            const sample = instrumentKey.sample.subarray(0, sampleEnd);
             const floatSample = this.convertToFloat32Array(sample);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
-                sampleRate: noteInfo.sampleRate,
+                sampleRate: instrumentKey.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
             channelData.set(floatSample);
             return audioBuffer;
         }
     }
-    async createNoteBufferNode(noteInfo, isSF3) {
+    async createNoteBufferNode(instrumentKey, isSF3) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
-        const audioBuffer = await this.createNoteBuffer(noteInfo, isSF3);
+        const audioBuffer = await this.createNoteBuffer(instrumentKey, isSF3);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = noteInfo.sampleModes % 2 !== 0;
+        bufferSource.loop = instrumentKey.sampleModes % 2 !== 0;
         if (bufferSource.loop) {
-            bufferSource.loopStart = noteInfo.loopStart / noteInfo.sampleRate;
-            bufferSource.loopEnd = noteInfo.loopEnd / noteInfo.sampleRate;
+            bufferSource.loopStart = instrumentKey.loopStart /
+                instrumentKey.sampleRate;
+            bufferSource.loopEnd = instrumentKey.loopEnd / instrumentKey.sampleRate;
         }
         return bufferSource;
     }
@@ -530,30 +578,26 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    getActiveNotes(channel) {
+    getActiveNotes(channel, time) {
         const activeNotes = new Map();
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, time);
             if (activeNote) {
                 activeNotes.set(activeNote.noteNumber, activeNote);
             }
         });
         return activeNotes;
     }
-    getActiveChannelNotes(scheduledNotes) {
-        for (let i = 0; i < scheduledNotes; i++) {
-            const scheduledNote = scheduledNotes[i];
-            if (scheduledNote)
-                return scheduledNote;
+    getActiveNote(noteList, time) {
+        for (let i = noteList.length - 1; i >= 0; i--) {
+            const note = noteList[i];
+            if (!note)
+                return;
+            if (time < note.startTime)
+                continue;
+            return (note.ending) ? null : note;
         }
-    }
-    createModulationEffect(audioContext) {
-        const lfo = new OscillatorNode(audioContext, {
-            frequency: 5,
-        });
-        return {
-            lfo,
-        };
+        return noteList[0];
     }
     createReverbEffect(audioContext, options = {}) {
         const { decay = 0.8, preDecay = 0, } = options;
@@ -663,77 +707,110 @@ export class Midy {
         const tuning = masterTuning + channelTuning;
         return channel.pitchBend * channel.pitchBendRange + tuning;
     }
-    calcPlaybackRate(noteInfo, noteNumber, semitoneOffset) {
-        return noteInfo.playbackRate(noteNumber) * Math.pow(2, semitoneOffset / 12);
+    calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset) {
+        return instrumentKey.playbackRate(noteNumber) *
+            Math.pow(2, semitoneOffset / 12);
     }
-    async createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3) {
-        const bufferSource = await this.createNoteBufferNode(noteInfo, isSF3);
-        const semitoneOffset = this.calcSemitoneOffset(channel);
-        bufferSource.playbackRate.value = this.calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
-        // volume envelope
-        const gainNode = new GainNode(this.audioContext, {
+    setVolumeEnvelope(channel, note) {
+        const { instrumentKey, startTime, velocity } = note;
+        note.gainNode = new GainNode(this.audioContext, {
             gain: 0,
         });
         let volume = (velocity / 127) * channel.volume * channel.expression;
         if (volume === 0)
             volume = 1e-6; // exponentialRampToValueAtTime() requires a non-zero value
-        const attackVolume = this.cbToRatio(-noteInfo.initialAttenuation) * volume;
-        const sustainVolume = attackVolume * (1 - noteInfo.volSustain);
-        const volDelay = startTime + noteInfo.volDelay;
-        const volAttack = volDelay + noteInfo.volAttack;
-        const volHold = volAttack + noteInfo.volHold;
-        const volDecay = volHold + noteInfo.volDecay;
-        gainNode.gain
+        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation) *
+            volume;
+        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
+        const volDelay = startTime + instrumentKey.volDelay;
+        const volAttack = volDelay + instrumentKey.volAttack;
+        const volHold = volAttack + instrumentKey.volHold;
+        const volDecay = volHold + instrumentKey.volDecay;
+        note.gainNode.gain
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
-        // filter envelope
+    }
+    setFilterEnvelope(channel, note) {
+        const { instrumentKey, startTime, noteNumber } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
         const maxFreq = this.audioContext.sampleRate / 2;
-        const baseFreq = this.centToHz(noteInfo.initialFilterFc) * softPedalFactor;
-        const peekFreq = this.centToHz(noteInfo.initialFilterFc + noteInfo.modEnvToFilterFc) * softPedalFactor;
+        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            softPedalFactor;
+        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = (baseFreq +
-            (peekFreq - baseFreq) * (1 - noteInfo.modSustain)) * softPedalFactor;
+            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain)) * softPedalFactor;
+        const modDelay = startTime + instrumentKey.modDelay;
+        const modAttack = modDelay + instrumentKey.modAttack;
+        const modHold = modAttack + instrumentKey.modHold;
+        const modDecay = modHold + instrumentKey.modDecay;
         const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
         const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
         const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
-        const filterNode = new BiquadFilterNode(this.audioContext, {
+        note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
-            Q: noteInfo.initialFilterQ / 10, // dB
+            Q: instrumentKey.initialFilterQ / 10, // dB
             frequency: adjustedBaseFreq,
         });
-        const modDelay = startTime + noteInfo.modDelay;
-        const modAttack = modDelay + noteInfo.modAttack;
-        const modHold = modAttack + noteInfo.modHold;
-        const modDecay = modHold + noteInfo.modDecay;
-        filterNode.frequency
+        note.filterNode.frequency
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
-        let lfoGain;
+        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modEnvToPitch, modDelay);
+    }
+    startModulation(channel, note, time) {
+        const { instrumentKey } = note;
+        note.modLFOGain = new GainNode(this.audioContext, {
+            gain: this.cbToRatio(instrumentKey.modLfoToVolume) * channel.modulation,
+        });
+        note.modLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqModLFO),
+        });
+        note.modLFO.start(time);
+        note.filterNode.frequency.setValueAtTime(note.filterNode.frequency.value + instrumentKey.modLfoToFilterFc, time);
+        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modLfoToPitch, time);
+        note.modLFO.connect(note.modLFOGain);
+        note.modLFOGain.connect(note.bufferSource.detune);
+    }
+    startVibrato(channel, note, time) {
+        const { instrumentKey } = note;
+        note.vibLFOGain = new GainNode(this.audioContext, {
+            gain: channel.vibratoDepth,
+        });
+        note.vibLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqModLFO) +
+                channel.vibratoRate,
+        });
+        note.vibLFO.start(time + channel.vibratoDelay);
+        note.vibLFO.connect(note.vibLFOGain);
+        note.vibLFOGain.connect(note.bufferSource.detune);
+    }
+    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3) {
+        const semitoneOffset = this.calcSemitoneOffset(channel);
+        const note = new Note(noteNumber, velocity, startTime, instrumentKey);
+        note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
+        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+        this.setVolumeEnvelope(channel, note);
+        this.setFilterEnvelope(channel, note);
         if (channel.modulation > 0) {
-            const vibratoDelay = startTime + channel.vibratoDelay;
-            const vibratoAttack = vibratoDelay + 0.1;
-            lfoGain = new GainNode(this.audioContext, {
-                gain: 0,
-            });
-            lfoGain.gain
-                .setValueAtTime(1e-6, vibratoDelay) // exponentialRampToValueAtTime() requires a non-zero value
-                .exponentialRampToValueAtTime(channel.modulation, vibratoAttack);
-            channel.modulationEffect.lfo.connect(lfoGain);
-            lfoGain.connect(bufferSource.detune);
+            const delayModLFO = startTime + instrumentKey.delayModLFO;
+            this.startModulation(channel, note, delayModLFO);
+        }
+        if (channel.vibratoDepth > 0) {
+            const delayVibLFO = startTime + instrumentKey.delayVibLFO;
+            this.startVibrato(channel, note, delayVibLFO);
         }
-        bufferSource.connect(filterNode);
-        filterNode.connect(gainNode);
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
-            channel.currentBufferSource = bufferSource;
+            channel.currentBufferSource = note.bufferSource;
         }
-        bufferSource.start(startTime, noteInfo.start / noteInfo.sampleRate);
-        return { bufferSource, gainNode, filterNode, lfoGain };
+        note.bufferSource.connect(note.filterNode);
+        note.filterNode.connect(note.gainNode);
+        note.bufferSource.start(startTime, instrumentKey.start / instrumentKey.sampleRate);
+        return note;
     }
     calcBank(channel, channelNumber) {
         if (channel.bankMSB === 121) {
@@ -752,36 +829,20 @@ export class Midy {
             return;
         const soundFont = this.soundFonts[soundFontIndex];
         const isSF3 = soundFont.parsed.info.version.major === 3;
-        const noteInfo = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
-        if (!noteInfo)
+        const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
+        if (!instrumentKey)
             return;
-        const { bufferSource, gainNode, filterNode, lfoGain } = await this
-            .createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3);
-        this.connectNoteEffects(channel, gainNode);
+        const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
+        this.connectNoteEffects(channel, note.gainNode);
         if (channel.sostenutoPedal) {
-            channel.sostenutoNotes.set(noteNumber, {
-                gainNode,
-                filterNode,
-                bufferSource,
-                noteNumber,
-                noteInfo,
-            });
+            channel.sostenutoNotes.set(noteNumber, note);
         }
         const scheduledNotes = channel.scheduledNotes;
-        const scheduledNote = {
-            bufferSource,
-            filterNode,
-            gainNode,
-            lfoGain,
-            noteInfo,
-            noteNumber,
-            startTime,
-        };
         if (scheduledNotes.has(noteNumber)) {
-            scheduledNotes.get(noteNumber).push(scheduledNote);
+            scheduledNotes.get(noteNumber).push(note);
         }
         else {
-            scheduledNotes.set(noteNumber, [scheduledNote]);
+            scheduledNotes.set(noteNumber, [note]);
         }
     }
     noteOn(channelNumber, noteNumber, velocity) {
@@ -803,15 +864,15 @@ export class Midy {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, modLFO, modLFOGain, vibLFO, vibLFOGain, instrumentKey, } = targetNote;
             const velocityRate = (velocity + 127) / 127;
-            const volEndTime = stopTime + noteInfo.volRelease * velocityRate;
+            const volEndTime = stopTime + instrumentKey.volRelease * velocityRate;
             gainNode.gain.cancelScheduledValues(stopTime);
             gainNode.gain.linearRampToValueAtTime(0, volEndTime);
             const maxFreq = this.audioContext.sampleRate / 2;
-            const baseFreq = this.centToHz(noteInfo.initialFilterFc);
+            const baseFreq = this.centToHz(instrumentKey.initialFilterFc);
             const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-            const modEndTime = stopTime + noteInfo.modRelease * velocityRate;
+            const modEndTime = stopTime + instrumentKey.modRelease * velocityRate;
             filterNode.frequency
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
@@ -825,8 +886,14 @@ export class Midy {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
-                    if (lfoGain)
-                        lfoGain.disconnect(0);
+                    if (modLFOGain)
+                        modLFOGain.disconnect(0);
+                    if (vibLFOGain)
+                        vibLFOGain.disconnect(0);
+                    if (modLFO)
+                        modLFO.stop();
+                    if (vibLFO)
+                        vibLFO.stop();
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -892,7 +959,7 @@ export class Midy {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         pressure /= 64;
-        const activeNotes = this.getActiveNotes(channel);
+        const activeNotes = this.getActiveNotes(channel, now);
         if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
             if (activeNotes.has(noteNumber)) {
                 const activeNote = activeNotes.get(noteNumber);
@@ -913,7 +980,7 @@ export class Midy {
         const channel = this.channels[channelNumber];
         pressure /= 64;
         channel.channelPressure = pressure;
-        const activeNotes = this.getActiveNotes(channel);
+        const activeNotes = this.getActiveNotes(channel, now);
         if (channel.channelPressure.amplitudeControl !== 1) {
             activeNotes.forEach((activeNote) => {
                 const gain = activeNote.gainNode.gain.value;
@@ -932,10 +999,10 @@ export class Midy {
         const channel = this.channels[channelNumber];
         channel.pitchBend = (pitchBend - 8192) / 8192;
         const semitoneOffset = this.calcSemitoneOffset(channel);
-        const activeNotes = this.getActiveNotes(channel);
+        const activeNotes = this.getActiveNotes(channel, now);
         activeNotes.forEach((activeNote) => {
-            const { bufferSource, noteInfo, noteNumber } = activeNote;
-            const playbackRate = calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
+            const { bufferSource, instrumentKey, noteNumber } = activeNote;
+            const playbackRate = calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
             bufferSource.playbackRate
                 .cancelScheduledValues(now)
                 .setValueAtTime(playbackRate * pressure, now);
@@ -1010,9 +1077,20 @@ export class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     setModulation(channelNumber, modulation) {
+        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.modulation = (modulation / 127) *
             (channel.modulationDepthRange * 100);
+        const activeNotes = this.getActiveNotes(channel, now);
+        activeNotes.forEach((activeNote) => {
+            if (activeNote.modLFO) {
+                activeNote.gainNode.gain.setValueAtTime(this.cbToRatio(activeNote.instrumentKey.modLfoToVolume) *
+                    channel.modulation, now);
+            }
+            else {
+                this.startModulation(channel, activeNote, now);
+            }
+        });
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         this.channels[channelNumber].portamentoTime = portamentoTime / 127;
@@ -1073,7 +1151,8 @@ export class Midy {
         const channel = this.channels[channelNumber];
         channel.sostenutoPedal = isOn;
         if (isOn) {
-            const activeNotes = this.getActiveNotes(channel);
+            const now = this.audioContext.currentTime;
+            const activeNotes = this.getActiveNotes(channel, now);
             channel.sostenutoNotes = new Map(activeNotes);
         }
         else {
@@ -1085,20 +1164,12 @@ export class Midy {
         channel.softPedal = softPedal / 127;
     }
     setVibratoRate(channelNumber, vibratoRate) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoRate = vibratoRate / 127 * 4 + 3; // 3-7Hz
-        channel.modulationEffect.lfo.frequency
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.vibratoRate, now);
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoDepth = vibratoDepth / 127;
-        channel.modulationEffect.lfoGain.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.vibratoDepth, now);
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         // Access Virus: 0-10sec
@@ -1179,8 +1250,8 @@ export class Midy {
         const velocity = 0;
         const stopPedal = true;
         const promises = [];
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, now);
             if (activeNote) {
                 const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
                 promises.push(notePromise);
@@ -1197,8 +1268,8 @@ export class Midy {
         const velocity = 0;
         const stopPedal = false;
         const promises = [];
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, now);
             if (activeNote) {
                 const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
                 promises.push(notePromise);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marmooo/midy",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A MIDI player/synthesizer written in JavaScript that supports GM-Lite/GM1 and SF2/SF3.",
   "repository": {
     "type": "git",

package/script/deps/cdn.jsdelivr.net/npm/@marmooo/{soundfont-parser@0.0.1 → soundfont-parser@0.0.2}/+esm.d.ts

@@ -12,7 +12,14 @@ declare class F {
         sampleName: any;
         sampleModes: number;
         playbackRate: (e: any) => number;
+        modLfoToPitch: number;
+        vibLfoToPitch: number;
         modEnvToPitch: number;
+        initialFilterFc: number;
+        initialFilterQ: number;
+        modLfoToFilterFc: number;
+        modEnvToFilterFc: number;
+        modLfoToVolume: number;
         scaleTuning: number;
         start: number;
         end: number;
@@ -32,12 +39,12 @@ declare class F {
         modRelease: number;
         keyRange: d;
         velRange: d;
-        initialFilterFc: number;
-        modEnvToFilterFc: number;
-        initialFilterQ: number;
+        delayModLFO: number;
+        freqModLFO: number;
+        delayVibLFO: number;
+        freqVibLFO: number;
         initialAttenuation: number;
-        freqVibLFO: number | undefined;
-        pan: undefined;
+        pan: number;
     } | null;
     getPresetNames(): {};
 }
@@ -95,7 +102,7 @@ declare namespace T {
     let initialFilterQ: number;
     let initialFilterFc: number;
     let sampleModes: number;
-    let pan: undefined;
+    let pan: number;
 }
 declare function b(e: any, n?: {}): {
     samples: any;

package/script/deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"+esm.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.js"],"names":[],"mappings":";;AAMizX;IAAQ,oBAA2H;IAAd,YAAa;IAAC,qDAAoJ;IAAA,mCAAoP;IAAA,uCAAwQ;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAAkqE;IAAA,qBAA0I;CAAC;AAAA,mCAAwC;AAA9oI,+BAA8F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA98D;;;;;;;;;;;;;;;;EAA27B;AAAr4I;IAAqQ,wBAAwD;IAArT,4BAAyN;IAApB,QAAS;IAAC,QAAS;IAAC,oBAAoC;CAAyD;AAAllG;IAAwjC,gCAA8d;CAAC"}

package/script/deps/cdn.jsdelivr.net/npm/@marmooo/{soundfont-parser@0.0.1 → soundfont-parser@0.0.2}/+esm.js

@@ -6,7 +6,7 @@ exports.createGeneratorObject = I;
 exports.parse = b;
 /**
  * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.37.0.
- * Original file: /npm/@marmooo/soundfont-parser@0.0.1/esm/mod.js
+ * Original file: /npm/@marmooo/soundfont-parser@0.0.2/esm/mod.js
  *
  * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
  */
@@ -114,7 +114,7 @@ function I(e) { const t = {}; for (const r of e) {
     const e = r.type;
     void 0 !== e && (t[e] = r.value);
 } return t; }
-const T = { keynum: void 0, instrument: void 0, velocity: void 0, exclusiveClass: void 0, keyRange: new d(0, 127), velRange: new d(0, 127), sampleID: void 0, delayVolEnv: -12e3, attackVolEnv: -12e3, decayVolEnv: -12e3, holdVolEnv: -12e3, sustainVolEnv: 0, releaseVolEnv: -12e3, delayModEnv: -12e3, attackModEnv: -12e3, decayModEnv: -12e3, holdModEnv: -12e3, sustainModEnv: 0, releaseModEnv: -12e3, modEnvToPitch: 0, modEnvToFilterFc: 0, modLfoToFilterFc: 0, modLfoToPitch: 0, modLfoToVolume: 0, vibLfoToPitch: 0, chorusEffectsSend: 0, reverbEffectsSend: 0, delayModLFO: 0, freqModLFO: 0, delayVibLFO: 0, keynumToModEnvDecay: 0, keynumToModEnvHold: 0, keynumToVolEnvDecay: 0, keynumToVolEnvHold: 0, coarseTune: 0, fineTune: 0, scaleTuning: 100, freqVibLFO: 0, startAddrsOffset: 0, startAddrsCoarseOffset: 0, endAddrsOffset: 0, endAddrsCoarseOffset: 0, startloopAddrsOffset: 0, startloopAddrsCoarseOffset: 0, initialAttenuation: 0, endloopAddrsOffset: 0, endloopAddrsCoarseOffset: 0, overridingRootKey: void 0, initialFilterQ: 1, initialFilterFc: 13500, sampleModes: 0, pan: void 0 };
+const T = { keynum: void 0, instrument: void 0, velocity: void 0, exclusiveClass: void 0, keyRange: new d(0, 127), velRange: new d(0, 127), sampleID: void 0, delayVolEnv: -12e3, attackVolEnv: -12e3, decayVolEnv: -12e3, holdVolEnv: -12e3, sustainVolEnv: 0, releaseVolEnv: -12e3, delayModEnv: -12e3, attackModEnv: -12e3, decayModEnv: -12e3, holdModEnv: -12e3, sustainModEnv: 0, releaseModEnv: -12e3, modEnvToPitch: 0, modEnvToFilterFc: 0, modLfoToFilterFc: 0, modLfoToPitch: 0, modLfoToVolume: 0, vibLfoToPitch: 0, chorusEffectsSend: 0, reverbEffectsSend: 0, delayModLFO: 0, freqModLFO: 0, delayVibLFO: 0, keynumToModEnvDecay: 0, keynumToModEnvHold: 0, keynumToVolEnvDecay: 0, keynumToVolEnvHold: 0, coarseTune: 0, fineTune: 0, scaleTuning: 100, freqVibLFO: 0, startAddrsOffset: 0, startAddrsCoarseOffset: 0, endAddrsOffset: 0, endAddrsCoarseOffset: 0, startloopAddrsOffset: 0, startloopAddrsCoarseOffset: 0, initialAttenuation: 0, endloopAddrsOffset: 0, endloopAddrsCoarseOffset: 0, overridingRootKey: void 0, initialFilterQ: 1, initialFilterFc: 13500, sampleModes: 0, pan: 0 };
 exports.defaultInstrumentZone = T;
 class F {
     constructor(e) { Object.defineProperty(this, "parsed", { enumerable: !0, configurable: !0, writable: !0, value: void 0 }), this.parsed = e; }
@@ -151,12 +151,12 @@ class F {
             break;
     } if (!l)
         return console.warn("instrument not found: bank=%s instrument=%s", e, t), null; if (void 0 === l.sampleID)
-        throw new Error("Invalid SoundFont: sampleID not found"); const d = { ...T, ...A(o || {}), ...A(s || {}), ...A(l) }, u = this.parsed.samples[d.sampleID], c = this.parsed.sampleHeaders[d.sampleID], f = d.coarseTune + d.fineTune / 100 + c.pitchCorrection / 100 - (d.overridingRootKey || c.originalPitch), p = d.scaleTuning / 100; return { sample: u, sampleRate: c.sampleRate, sampleName: c.sampleName, sampleModes: d.sampleModes, playbackRate: e => Math.pow(Math.pow(2, 1 / 12), (e + f) * p), modEnvToPitch: d.modEnvToPitch / 100, scaleTuning: p, start: 32768 * d.startAddrsCoarseOffset + d.startAddrsOffset, end: 32768 * d.endAddrsCoarseOffset + d.endAddrsOffset, loopStart: c.loopStart + 32768 * d.startloopAddrsCoarseOffset + d.startloopAddrsOffset, loopEnd: c.loopEnd + 32768 * d.endloopAddrsCoarseOffset + d.endloopAddrsOffset, volDelay: M(d.delayVolEnv), volAttack: M(d.attackVolEnv), volHold: M(d.holdVolEnv), volDecay: M(d.decayVolEnv), volSustain: d.sustainVolEnv / 1e3, volRelease: M(d.releaseVolEnv), modDelay: M(d.delayModEnv), modAttack: M(d.attackModEnv), modHold: M(d.holdModEnv), modDecay: M(d.decayModEnv), modSustain: d.sustainModEnv / 1e3, modRelease: M(d.releaseModEnv), keyRange: d.keyRange, velRange: d.velRange, initialFilterFc: d.initialFilterFc, modEnvToFilterFc: d.modEnvToFilterFc, initialFilterQ: d.initialFilterQ, initialAttenuation: d.initialAttenuation, freqVibLFO: d.freqVibLFO ? 8.176 * M(d.freqVibLFO) : void 0, pan: d.pan }; }
+        throw new Error("Invalid SoundFont: sampleID not found"); const d = { ...T, ...L(o || {}), ...L(s || {}), ...L(l) }, u = this.parsed.samples[d.sampleID], c = this.parsed.sampleHeaders[d.sampleID], f = d.coarseTune + d.fineTune / 100 + c.pitchCorrection / 100 - (d.overridingRootKey || c.originalPitch), p = d.scaleTuning / 100; return { sample: u, sampleRate: c.sampleRate, sampleName: c.sampleName, sampleModes: d.sampleModes, playbackRate: e => Math.pow(Math.pow(2, 1 / 12), (e + f) * p), modLfoToPitch: d.modLfoToPitch, vibLfoToPitch: d.vibLfoToPitch, modEnvToPitch: d.modEnvToPitch, initialFilterFc: d.initialFilterFc, initialFilterQ: d.initialFilterQ, modLfoToFilterFc: d.modLfoToFilterFc, modEnvToFilterFc: d.modEnvToFilterFc, modLfoToVolume: d.modLfoToVolume, scaleTuning: p, start: 32768 * d.startAddrsCoarseOffset + d.startAddrsOffset, end: 32768 * d.endAddrsCoarseOffset + d.endAddrsOffset, loopStart: c.loopStart + 32768 * d.startloopAddrsCoarseOffset + d.startloopAddrsOffset, loopEnd: c.loopEnd + 32768 * d.endloopAddrsCoarseOffset + d.endloopAddrsOffset, volDelay: M(d.delayVolEnv), volAttack: M(d.attackVolEnv), volHold: M(d.holdVolEnv), volDecay: M(d.decayVolEnv), volSustain: d.sustainVolEnv / 1e3, volRelease: M(d.releaseVolEnv), modDelay: M(d.delayModEnv), modAttack: M(d.attackModEnv), modHold: M(d.holdModEnv), modDecay: M(d.decayModEnv), modSustain: d.sustainModEnv / 1e3, modRelease: M(d.releaseModEnv), keyRange: d.keyRange, velRange: d.velRange, delayModLFO: M(d.delayModLFO), freqModLFO: d.freqModLFO, delayVibLFO: M(d.delayVibLFO), freqVibLFO: d.freqVibLFO, initialAttenuation: d.initialAttenuation, pan: d.pan }; }
     getPresetNames() { const e = {}; return this.parsed.presetHeaders.forEach((t => { e[t.bank] || (e[t.bank] = {}), e[t.bank][t.preset] = t.presetName; })), e; }
 }
 exports.SoundFont = F;
 function M(e) { return Math.pow(2, e / 1200); }
-function A(e) { const t = {}; for (const r in e)
+function L(e) { const t = {}; for (const r in e)
     void 0 !== e[r] && (t[r] = e[r]); return t; }
 exports.default = null;
-//# sourceMappingURL=/sm/f81f37edef0ee7c3c75f39a74df8b8e54ea144490d686e35430b76b426f1559d.map
+//# sourceMappingURL=/sm/22d03ff23e99217677631c656a57eea14149d50ae4425cf6cd850760c3e93c1e.map