@marmooo/midy 0.1.2 → 0.1.3

package/script/midy.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Midy = void 0;
 const _esm_js_1 = require("./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js");
-const _esm_js_2 = require("./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.js");
+const _esm_js_2 = require("./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.4/+esm.js");
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -11,37 +11,43 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "gainNode", {
+        Object.defineProperty(this, "filterNode", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "filterNode", {
+        Object.defineProperty(this, "volumeNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "volumeDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modLFO", {
+        Object.defineProperty(this, "modulationLFO", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modLFOGain", {
+        Object.defineProperty(this, "modulationDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibLFO", {
+        Object.defineProperty(this, "vibratoLFO", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "vibLFOGain", {
+        Object.defineProperty(this, "vibratoDepth", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -413,7 +419,7 @@ class Midy {
                 const t = this.audioContext.currentTime + offset;
                 queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
                 if (this.isPausing) {
-                    await this.stopNotes();
+                    await this.stopNotes(0, true);
                     this.notePromises = [];
                     resolve();
                     this.isPausing = false;
@@ -421,7 +427,7 @@ class Midy {
                     return;
                 }
                 else if (this.isStopping) {
-                    await this.stopNotes();
+                    await this.stopNotes(0, true);
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -429,7 +435,7 @@ class Midy {
                     return;
                 }
                 else if (this.isSeeking) {
-                    this.stopNotes();
+                    this.stopNotes(0, true);
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -544,21 +550,24 @@ class Midy {
         }
         return { instruments, timeline };
     }
-    stopNotes() {
+    async stopChannelNotes(channelNumber, velocity, stopPedal) {
         const now = this.audioContext.currentTime;
-        const velocity = 0;
-        const stopPedal = true;
-        this.channels.forEach((channel, channelNumber) => {
-            channel.scheduledNotes.forEach((scheduledNotes) => {
-                scheduledNotes.forEach((scheduledNote) => {
-                    if (scheduledNote) {
-                        const promise = this.scheduleNoteRelease(channelNumber, scheduledNote.noteNumber, velocity, now, stopPedal);
-                        this.notePromises.push(promise);
-                    }
-                });
+        const channel = this.channels[channelNumber];
+        channel.scheduledNotes.forEach((noteList) => {
+            noteList.forEach((note) => {
+                if (note) {
+                    const promise = this.scheduleNoteRelease(channelNumber, note.noteNumber, velocity, now, stopPedal);
+                    this.notePromises.push(promise);
+                }
             });
-            channel.scheduledNotes.clear();
         });
+        channel.scheduledNotes.clear();
+        await Promise.all(this.notePromises);
+    }
+    stopNotes(velocity, stopPedal) {
+        for (let i = 0; i < this.channels.length; i++) {
+            this.stopChannelNotes(i, velocity, stopPedal);
+        }
         return Promise.all(this.notePromises);
     }
     async start() {
@@ -773,36 +782,54 @@ class Midy {
     }
     setVolumeEnvelope(note) {
         const { instrumentKey, startTime } = note;
-        note.gainNode = new GainNode(this.audioContext, { gain: 0 });
+        note.volumeNode = new GainNode(this.audioContext, { gain: 0 });
         const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation);
         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
+        note.volumeNode.gain
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
     }
-    setFilterEnvelope(channel, note) {
-        const { instrumentKey, startTime, noteNumber } = note;
+    setPitch(note, semitoneOffset) {
+        const { instrumentKey, noteNumber, startTime } = note;
+        const modEnvToPitch = instrumentKey.modEnvToPitch / 100;
+        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+        if (modEnvToPitch === 0)
+            return;
+        const basePitch = note.bufferSource.playbackRate.value;
+        const peekPitch = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset + modEnvToPitch);
+        const modDelay = startTime + instrumentKey.modDelay;
+        const modAttack = modDelay + instrumentKey.modAttack;
+        const modHold = modAttack + instrumentKey.modHold;
+        const modDecay = modHold + instrumentKey.modDecay;
+        note.bufferSource.playbackRate.value
+            .setValueAtTime(basePitch, modDelay)
+            .exponentialRampToValueAtTime(peekPitch, modAttack)
+            .setValueAtTime(peekPitch, modHold)
+            .linearRampToValueAtTime(basePitch, modDecay);
+    }
+    setFilterNode(channel, note) {
+        const { instrumentKey, noteNumber, startTime } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
         const maxFreq = this.audioContext.sampleRate / 2;
         const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
             softPedalFactor;
         const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
-        const sustainFreq = (baseFreq +
-            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain)) * softPedalFactor;
+        const sustainFreq = baseFreq +
+            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain);
+        const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
+        const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
+        const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
         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);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
             Q: instrumentKey.initialFilterQ / 10, // dB
@@ -813,56 +840,72 @@ class Midy {
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
-        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modEnvToPitch, modDelay);
     }
-    startModulation(channel, note, time) {
+    startModulation(channel, note, startTime) {
         const { instrumentKey } = note;
-        note.modLFOGain = new GainNode(this.audioContext, {
-            gain: this.cbToRatio(instrumentKey.modLfoToVolume + channel.modulation),
-        });
-        note.modLFO = new OscillatorNode(this.audioContext, {
+        const { modLfoToPitch, modLfoToVolume } = instrumentKey;
+        note.modulationLFO = 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.filterDepth = new GainNode(this.audioContext, {
+            gain: instrumentKey.modLfoToFilterFc,
+        });
+        const modulationDepth = Math.abs(modLfoToPitch) + channel.modulationDepth;
+        const modulationDepthSign = (0 < modLfoToPitch) ? 1 : -1;
+        note.modulationDepth = new GainNode(this.audioContext, {
+            gain: modulationDepth * modulationDepthSign,
+        });
+        const volumeDepth = this.cbToRatio(Math.abs(modLfoToVolume)) - 1;
+        const volumeDepthSign = (0 < modLfoToVolume) ? 1 : -1;
+        note.volumeDepth = new GainNode(this.audioContext, {
+            gain: volumeDepth * volumeDepthSign,
         });
-        note.vibLFO = new OscillatorNode(this.audioContext, {
-            frequency: this.centToHz(instrumentKey.freqModLFO) +
+        note.modulationLFO.start(startTime + instrumentKey.delayModLFO);
+        note.modulationLFO.connect(note.filterDepth);
+        note.filterDepth.connect(note.filterNode.frequency);
+        note.modulationLFO.connect(note.modulationDepth);
+        note.modulationDepth.connect(note.bufferSource.detune);
+        note.modulationLFO.connect(note.volumeDepth);
+        note.volumeDepth.connect(note.volumeNode.gain);
+    }
+    startVibrato(channel, note, startTime) {
+        const { instrumentKey } = note;
+        const { vibLfoToPitch } = instrumentKey;
+        note.vibratoLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqVibLFO) *
                 channel.vibratoRate,
         });
-        note.vibLFO.start(time + channel.vibratoDelay);
-        note.vibLFO.connect(note.vibLFOGain);
-        note.vibLFOGain.connect(note.bufferSource.detune);
+        const vibratoDepth = Math.abs(vibLfoToPitch) * channel.vibratoDepth;
+        const vibratoDepthSign = 0 < vibLfoToPitch;
+        note.vibratoDepth = new GainNode(this.audioContext, {
+            gain: vibratoDepth * vibratoDepthSign,
+        });
+        note.vibratoLFO.start(startTime + instrumentKey.delayVibLFO * channel.vibratoDelay);
+        note.vibratoLFO.connect(note.vibratoDepth);
+        note.vibratoDepth.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.setFilterNode(channel, note);
         this.setVolumeEnvelope(note);
-        this.setFilterEnvelope(channel, note);
-        if (channel.modulation > 0) {
-            const delayModLFO = startTime + instrumentKey.delayModLFO;
-            this.startModulation(channel, note, delayModLFO);
+        if (0 < channel.vibratoDepth) {
+            this.startVibrato(channel, note, startTime);
         }
-        if (channel.vibratoDepth > 0) {
-            const delayVibLFO = startTime + instrumentKey.delayVibLFO;
-            this.startVibrato(channel, note, delayVibLFO);
+        if (0 < channel.modulationDepth) {
+            this.setPitch(note, semitoneOffset);
+            this.startModulation(channel, note, startTime);
+        }
+        else {
+            note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
         }
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
             channel.currentBufferSource = note.bufferSource;
         }
         note.bufferSource.connect(note.filterNode);
-        note.filterNode.connect(note.gainNode);
+        note.filterNode.connect(note.volumeNode);
         note.bufferSource.start(startTime, instrumentKey.start / instrumentKey.sampleRate);
         return note;
     }
@@ -887,8 +930,8 @@ class Midy {
         if (!instrumentKey)
             return;
         const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
-        note.gainNode.connect(channel.gainL);
-        note.gainNode.connect(channel.gainR);
+        note.volumeNode.connect(channel.gainL);
+        note.volumeNode.connect(channel.gainR);
         if (channel.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
@@ -922,17 +965,14 @@ class Midy {
             const velocityRate = (velocity + 127) / 127;
             const volEndTime = stopTime +
                 note.instrumentKey.volRelease * velocityRate;
-            note.gainNode.gain
+            note.volumeNode.gain
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(0, volEndTime);
-            const maxFreq = this.audioContext.sampleRate / 2;
-            const baseFreq = this.centToHz(note.instrumentKey.initialFilterFc);
-            const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-            const modEndTime = stopTime +
+            const modRelease = stopTime +
                 note.instrumentKey.modRelease * velocityRate;
             note.filterNode.frequency
                 .cancelScheduledValues(stopTime)
-                .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
+                .linearRampToValueAtTime(0, modRelease);
             note.ending = true;
             this.scheduleTask(() => {
                 note.bufferSource.loop = false;
@@ -941,16 +981,18 @@ class Midy {
                 note.bufferSource.onended = () => {
                     scheduledNotes[i] = null;
                     note.bufferSource.disconnect();
+                    note.volumeNode.disconnect();
                     note.filterNode.disconnect();
-                    note.gainNode.disconnect();
-                    if (note.modLFOGain)
-                        note.modLFOGain.disconnect();
-                    if (note.vibLFOGain)
-                        note.vibLFOGain.disconnect();
-                    if (note.modLFO)
-                        note.modLFO.stop();
-                    if (note.vibLFO)
-                        note.vibLFO.stop();
+                    if (note.volumeDepth)
+                        note.volumeDepth.disconnect();
+                    if (note.modulationDepth)
+                        note.modulationDepth.disconnect();
+                    if (note.modulationLFO)
+                        note.modulationLFO.stop();
+                    if (note.vibratoDepth)
+                        note.vibratoDepth.disconnect();
+                    if (note.vibratoLFO)
+                        note.vibratoLFO.stop();
                     resolve();
                 };
                 note.bufferSource.stop(volEndTime);
@@ -966,10 +1008,10 @@ class Midy {
         const channel = this.channels[channelNumber];
         const promises = [];
         channel.sustainPedal = false;
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            scheduledNotes.forEach((scheduledNote) => {
-                if (scheduledNote) {
-                    const { noteNumber } = scheduledNote;
+        channel.scheduledNotes.forEach((noteList) => {
+            noteList.forEach((note) => {
+                if (note) {
+                    const { noteNumber } = note;
                     const promise = this.releaseNote(channelNumber, noteNumber, velocity);
                     promises.push(promise);
                 }
@@ -1020,8 +1062,8 @@ class Midy {
         if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
             if (activeNotes.has(noteNumber)) {
                 const activeNote = activeNotes.get(noteNumber);
-                const gain = activeNote.gainNode.gain.value;
-                activeNote.gainNode.gain
+                const gain = activeNote.volumeNode.gain.value;
+                activeNote.volumeNode.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(gain * pressure, now);
             }
@@ -1040,8 +1082,8 @@ class Midy {
         const activeNotes = this.getActiveNotes(channel, now);
         if (channel.channelPressure.amplitudeControl !== 1) {
             activeNotes.forEach((activeNote) => {
-                const gain = activeNote.gainNode.gain.value;
-                activeNote.gainNode.gain
+                const gain = activeNote.volumeNode.gain.value;
+                activeNote.volumeNode.gain
                     .cancelScheduledValues(now)
                     .setValueAtTime(gain * pressure, now);
             });
@@ -1064,7 +1106,7 @@ class Midy {
             case 0:
                 return this.setBankMSB(channelNumber, value);
             case 1:
-                return this.setModulation(channelNumber, value);
+                return this.setModulationDepth(channelNumber, value);
             case 5:
                 return this.setPortamentoTime(channelNumber, value);
             case 6:
@@ -1131,18 +1173,19 @@ class Midy {
         const now = this.audioContext.currentTime;
         const activeNotes = this.getActiveNotes(channel, now);
         activeNotes.forEach((activeNote) => {
-            if (activeNote.modLFO) {
-                const { gainNode, instrumentKey } = activeNote;
-                gainNode.gain.setValueAtTime(this.cbToRatio(instrumentKey.modLfoToVolume + channel.modulation), now);
+            if (activeNote.modulationDepth) {
+                activeNote.modulationDepth.gain.setValueAtTime(channel.modulationDepth, now);
             }
             else {
+                const semitoneOffset = this.calcSemitoneOffset(channel);
+                this.setPitch(activeNote, semitoneOffset);
                 this.startModulation(channel, activeNote, now);
             }
         });
     }
-    setModulation(channelNumber, modulation) {
+    setModulationDepth(channelNumber, modulation) {
         const channel = this.channels[channelNumber];
-        channel.modulation = (modulation / 127) * channel.modulationDepthRange;
+        channel.modulationDepth = (modulation / 127) * channel.modulationDepthRange;
         this.updateModulation(channel);
     }
     setPortamentoTime(channelNumber, portamentoTime) {
@@ -1244,21 +1287,15 @@ class Midy {
     }
     setVibratoRate(channelNumber, vibratoRate) {
         const channel = this.channels[channelNumber];
-        channel.vibratoRate = vibratoRate / 127 * 4 + 3; // 3-7Hz
+        channel.vibratoRate = vibratoRate / 64;
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
         const channel = this.channels[channelNumber];
-        channel.vibratoDepth = vibratoDepth / 127;
+        channel.vibratoDepth = vibratoDepth / 64;
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
-        // Access Virus: 0-10sec
-        // Elektron: 0-5sec
-        // Korg: 0-5sec
-        // Nord: 0-5sec
-        // Roland: 0-5sec
-        // Yamaha: 0-8sec
         const channel = this.channels[channelNumber];
-        channel.vibratoDelay = vibratoDelay / 127 * 5; // 0-5sec
+        channel.vibratoDelay = vibratoDelay / 64;
     }
     limitData(channel, minMSB, maxMSB, minLSB, maxLSB) {
         if (maxLSB < channel.dataLSB) {
@@ -1380,47 +1417,23 @@ class Midy {
     handleModulationDepthRangeRPN(channelNumber) {
         const channel = this.channels[channelNumber];
         this.limitData(channel, 0, 127, 0, 127);
-        const modulationDepthRange = dataMSB + dataLSB / 128;
+        const modulationDepthRange = (dataMSB + dataLSB / 128) * 100;
         this.setModulationDepthRange(channelNumber, modulationDepthRange);
     }
     setModulationDepthRange(channelNumber, modulationDepthRange) {
         const channel = this.channels[channelNumber];
         channel.modulationDepthRange = modulationDepthRange;
-        channel.modulation = (modulation / 127) * channel.modulationDepthRange;
+        channel.modulationDepth = (modulation / 127) * modulationDepthRange;
         this.updateModulation(channel);
     }
     allSoundOff(channelNumber) {
-        const now = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const velocity = 0;
-        const stopPedal = true;
-        const promises = [];
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, now);
-            if (activeNote) {
-                const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
-                promises.push(notePromise);
-            }
-        });
-        return promises;
+        return this.stopChannelNotes(channelNumber, 0, true);
     }
     resetAllControllers(channelNumber) {
         Object.assign(this.channels[channelNumber], this.effectSettings);
     }
     allNotesOff(channelNumber) {
-        const now = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const velocity = 0;
-        const stopPedal = false;
-        const promises = [];
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, now);
-            if (activeNote) {
-                const notePromise = this.scheduleNoteRelease(channelNumber, activeNote.noteNumber, velocity, now, stopPedal);
-                promises.push(notePromise);
-            }
-        });
-        return promises;
+        return this.stopChannelNotes(channelNumber, 0, false);
     }
     omniOff() {
         this.omni = false;
@@ -1781,9 +1794,9 @@ Object.defineProperty(Midy, "channelSettings", {
         portamentoTime: 0,
         reverbSendLevel: 0,
         chorusSendLevel: 0,
-        vibratoRate: 5,
-        vibratoDepth: 0.5,
-        vibratoDelay: 2.5,
+        vibratoRate: 1,
+        vibratoDepth: 1,
+        vibratoDelay: 1,
         bank: 121 * 128,
         bankMSB: 121,
         bankLSB: 0,
@@ -1793,7 +1806,7 @@ Object.defineProperty(Midy, "channelSettings", {
         pitchBend: 0,
         fineTuning: 0, // cb
         coarseTuning: 0, // cb
-        modulationDepthRange: 0.5, // cb
+        modulationDepthRange: 50, // cent
     }
 });
 Object.defineProperty(Midy, "effectSettings", {
@@ -1802,7 +1815,7 @@ Object.defineProperty(Midy, "effectSettings", {
     writable: true,
     value: {
         expression: 1,
-        modulation: 0,
+        modulationDepth: 0,
         sustainPedal: false,
         portamento: false,
         sostenutoPedal: false,

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

@@ -1,135 +0,0 @@
-declare const _default: null;
-export default _default;
-declare class F {
-    constructor(e: any);
-    parsed: any;
-    getGenerators(e: any, t: any, r: any, n: any): any[];
-    getPresetGenerators(e: any): any[];
-    getInstrumentGenerators(e: any): any[];
-    getInstrumentKey(e: any, t: any, r: any, n?: number): {
-        sample: any;
-        sampleRate: any;
-        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;
-        loopStart: any;
-        loopEnd: any;
-        volDelay: number;
-        volAttack: number;
-        volHold: number;
-        volDecay: number;
-        volSustain: number;
-        volRelease: number;
-        modDelay: number;
-        modAttack: number;
-        modHold: number;
-        modDecay: number;
-        modSustain: number;
-        modRelease: number;
-        keyRange: d;
-        velRange: d;
-        delayModLFO: number;
-        freqModLFO: number;
-        delayVibLFO: number;
-        freqVibLFO: number;
-        initialAttenuation: number;
-        pan: number;
-    } | null;
-    getPresetNames(): {};
-}
-declare function M(e: any): number;
-declare function I(e: any): {};
-declare namespace T {
-    let keynum: undefined;
-    let instrument: undefined;
-    let velocity: undefined;
-    let exclusiveClass: undefined;
-    let keyRange: d;
-    let velRange: d;
-    let sampleID: undefined;
-    let delayVolEnv: number;
-    let attackVolEnv: number;
-    let decayVolEnv: number;
-    let holdVolEnv: number;
-    let sustainVolEnv: number;
-    let releaseVolEnv: number;
-    let delayModEnv: number;
-    let attackModEnv: number;
-    let decayModEnv: number;
-    let holdModEnv: number;
-    let sustainModEnv: number;
-    let releaseModEnv: number;
-    let modEnvToPitch: number;
-    let modEnvToFilterFc: number;
-    let modLfoToFilterFc: number;
-    let modLfoToPitch: number;
-    let modLfoToVolume: number;
-    let vibLfoToPitch: number;
-    let chorusEffectsSend: number;
-    let reverbEffectsSend: number;
-    let delayModLFO: number;
-    let freqModLFO: number;
-    let delayVibLFO: number;
-    let keynumToModEnvDecay: number;
-    let keynumToModEnvHold: number;
-    let keynumToVolEnvDecay: number;
-    let keynumToVolEnvHold: number;
-    let coarseTune: number;
-    let fineTune: number;
-    let scaleTuning: number;
-    let freqVibLFO: number;
-    let startAddrsOffset: number;
-    let startAddrsCoarseOffset: number;
-    let endAddrsOffset: number;
-    let endAddrsCoarseOffset: number;
-    let startloopAddrsOffset: number;
-    let startloopAddrsCoarseOffset: number;
-    let initialAttenuation: number;
-    let endloopAddrsOffset: number;
-    let endloopAddrsCoarseOffset: number;
-    let overridingRootKey: undefined;
-    let initialFilterQ: number;
-    let initialFilterFc: number;
-    let sampleModes: number;
-    let pan: number;
-}
-declare function b(e: any, n?: {}): {
-    samples: any;
-    presetHeaders: any[];
-    presetZone: any[];
-    presetModulators: any[];
-    presetGenerators: any[];
-    instruments: any[];
-    instrumentZone: any[];
-    instrumentModulators: any[];
-    instrumentGenerators: any[];
-    sampleHeaders: any[];
-    info: o;
-    samplingData: {
-        offsetMSB: any;
-        offsetLSB: any;
-    };
-};
-declare class d {
-    static parse(e: any): d;
-    constructor(e: any, t: any);
-    lo: any;
-    hi: any;
-    in(e: any): boolean;
-}
-declare class o {
-    static parse(t: any, r: any): o;
-}
-export { F as SoundFont, M as convertTime, I as createGeneratorObject, T as defaultInstrumentZone, b as parse };
-//# sourceMappingURL=+esm.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}