@marmooo/midy 0.0.4 → 0.0.5

package/esm/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/esm/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/esm/deps/cdn.jsdelivr.net/npm/@marmooo/{soundfont-parser@0.0.1 → soundfont-parser@0.0.2}/+esm.js

@@ -1,6 +1,6 @@
 /**
  * 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
  */
@@ -108,7 +108,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 };
 class F {
     constructor(e) { Object.defineProperty(this, "parsed", { enumerable: !0, configurable: !0, writable: !0, value: void 0 }), this.parsed = e; }
     getGenerators(e, t, r, n) { const a = new Array(n - r); for (let i = r; i < n; i++) {
@@ -144,12 +144,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; }
 }
 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; }
 export { F as SoundFont, M as convertTime, I as createGeneratorObject, T as defaultInstrumentZone, b as parse };
 export default null;
-//# sourceMappingURL=/sm/f81f37edef0ee7c3c75f39a74df8b8e54ea144490d686e35430b76b426f1559d.map
+//# sourceMappingURL=/sm/22d03ff23e99217677631c656a57eea14149d50ae4425cf6cd850760c3e93c1e.map

package/esm/midy-GM1.d.ts

@@ -2,9 +2,6 @@ export class MidyGM1 {
     static channelSettings: {
         volume: number;
         pan: number;
-        vibratoRate: number;
-        vibratoDepth: number;
-        vibratoDelay: number;
         bank: number;
         dataMSB: number;
         dataLSB: number;
@@ -44,12 +41,8 @@ export class MidyGM1 {
     masterGain: any;
     channels: {
         scheduledNotes: Map<any, any>;
-        sostenutoNotes: Map<any, any>;
         gainNode: any;
         pannerNode: any;
-        modulationEffect: {
-            lfo: any;
-        };
         expression: number;
         modulation: number;
         sustainPedal: boolean;
@@ -58,9 +51,6 @@ export class MidyGM1 {
         pitchBendRange: number;
         volume: number;
         pan: number;
-        vibratoRate: number;
-        vibratoDepth: number;
-        vibratoDelay: number;
         bank: number;
         dataMSB: number;
         dataLSB: number;
@@ -77,18 +67,11 @@ export class MidyGM1 {
     setChannelAudioNodes(audioContext: any): {
         gainNode: any;
         pannerNode: any;
-        modulationEffect: {
-            lfo: any;
-        };
     };
     createChannels(audioContext: any): {
         scheduledNotes: Map<any, any>;
-        sostenutoNotes: Map<any, any>;
         gainNode: any;
         pannerNode: any;
-        modulationEffect: {
-            lfo: any;
-        };
         expression: number;
         modulation: number;
         sustainPedal: boolean;
@@ -97,9 +80,6 @@ export class MidyGM1 {
         pitchBendRange: number;
         volume: number;
         pan: number;
-        vibratoRate: number;
-        vibratoDepth: number;
-        vibratoDelay: number;
         bank: number;
         dataMSB: number;
         dataLSB: number;
@@ -109,8 +89,8 @@ export class MidyGM1 {
         coarseTuning: number;
         modulationDepthRange: number;
     }[];
-    createNoteBuffer(noteInfo: any, isSF3: any): Promise<any>;
-    createNoteBufferNode(noteInfo: any, isSF3: any): Promise<any>;
+    createNoteBuffer(instrumentKey: any, isSF3: any): Promise<any>;
+    createNoteBufferNode(instrumentKey: any, isSF3: any): Promise<any>;
     convertToFloat32Array(uint8Array: any): Float32Array;
     scheduleTimelineEvents(t: any, offset: any, queueIndex: any): Promise<any>;
     getQueueIndex(second: any): number;
@@ -129,22 +109,17 @@ export class MidyGM1 {
     seekTo(second: any): void;
     calcTotalTime(): number;
     currentTime(): number;
-    getActiveNotes(channel: any): Map<any, any>;
-    getActiveChannelNotes(scheduledNotes: any): any;
-    createModulationEffect(audioContext: any): {
-        lfo: any;
-    };
+    getActiveNotes(channel: any, time: any): Map<any, any>;
+    getActiveNote(noteList: any, time: any): any;
     connectNoteEffects(channel: any, gainNode: any): void;
     cbToRatio(cb: any): number;
     centToHz(cent: any): number;
     calcSemitoneOffset(channel: any): any;
-    calcPlaybackRate(noteInfo: any, noteNumber: any, semitoneOffset: any): number;
-    createNoteAudioChain(channel: any, noteInfo: any, noteNumber: any, velocity: any, startTime: any, isSF3: any): Promise<{
-        bufferSource: any;
-        gainNode: any;
-        filterNode: any;
-        lfoGain: any;
-    }>;
+    calcPlaybackRate(instrumentKey: any, noteNumber: any, semitoneOffset: any): number;
+    setVolumeEnvelope(channel: any, note: any): void;
+    setFilterEnvelope(channel: any, note: any): void;
+    startModulation(channel: any, note: any, time: any): void;
+    createNote(channel: any, instrumentKey: any, noteNumber: any, velocity: any, startTime: any, isSF3: any): Promise<Note>;
     scheduleNoteOn(channelNumber: any, noteNumber: any, velocity: any, startTime: any): Promise<void>;
     noteOn(channelNumber: any, noteNumber: any, velocity: any): Promise<void>;
     scheduleNoteRelease(channelNumber: any, noteNumber: any, velocity: any, stopTime: any, stopPedal?: boolean): Promise<any> | undefined;
@@ -176,4 +151,19 @@ export class MidyGM1 {
     handleSysEx(data: any): void;
     scheduleTask(callback: any, startTime: any): Promise<any>;
 }
+declare class Note {
+    constructor(noteNumber: any, velocity: any, startTime: any, instrumentKey: any);
+    bufferSource: any;
+    gainNode: any;
+    filterNode: any;
+    modLFO: any;
+    modLFOGain: any;
+    vibLFO: any;
+    vibLFOGain: any;
+    noteNumber: any;
+    velocity: any;
+    startTime: any;
+    instrumentKey: any;
+}
+export {};
 //# sourceMappingURL=midy-GM1.d.ts.map

package/esm/midy-GM1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"midy-GM1.d.ts","sourceRoot":"","sources":["../src/midy-GM1.js"],"names":[],"mappings":"AAMA;IAmBE;;;;;;;;;;;;;;MAcE;IAEF;;;;;;;MAOE;IAEF,+BAMC;IAjDD,qBAAmB;IACnB,kBAAc;IACd,0BAAwB;IACxB,kBAAc;IACd,mBAAiB;IACjB,kBAAc;IACd,mBAAe;IACf,kBAAgB;IAChB,sBAA2C;IAC3C,mBAAkB;IAClB,mBAAkB;IAClB,kBAAiB;IACjB,oBAAmB;IACnB,mBAAkB;IAClB,gBAAc;IACd,mBAAiB;IACjB,oBAAkB;IA4BhB,kBAAgC;IAChC,gBAA4C;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAiD;IAInD,4BAMC;IAED,mCASC;IAED,gDAMC;IAED,sCASC;IAED;;;;;;MAgBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWC;IAED,0DAyBC;IAED,8DAUC;IAED,qDAOC;IAED,2EA+CC;IAED,mCAOC;IAED,0BA+CC;IAED,uDAEC;IAED,wDAEC;IAED;;;MAyEC;IAED,4BAsBC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBAOC;IAED,sBAGC;IAED,4CASC;IAED,gDAKC;IAED;;MAOC;IAED,sDAEC;IAED,2BAEC;IAED,4BAEC;IAED,sCAGC;IAED,8EAEC;IAED;;;;;OA8EC;IAED,kGAuCC;IAED,0EAGC;IAED,sIA4CC;IAED,0FAGC;IAED,kEAeC;IAED,wFAiBC;IAED,4DAGC;IAED,qEAGC;IAED,0DAiBC;IAED,mFA+BC;IAED,yDAIC;IAED,iDAIC;IAED,2CAMC;IAED,yDAIC;IAED,sCAKC;IAED,sDAMC;IAED,gDAEC;IAED,gDAEC;IAED,+DAoBC;IAED,uCAoBC;IAED,8CAEC;IAED,uCAoBC;IAED,4DAgBC;IAED,oBAQC;IAED,yDAaC;IAED,yCAGC;IAED,sCAQC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF"}
+{"version":3,"file":"midy-GM1.d.ts","sourceRoot":"","sources":["../src/midy-GM1.js"],"names":[],"mappings":"AAuBA;IAmBE;;;;;;;;;;;MAWE;IAEF;;;;;;;MAOE;IAEF,+BAMC;IA9CD,qBAAmB;IACnB,kBAAc;IACd,0BAAwB;IACxB,kBAAc;IACd,mBAAiB;IACjB,kBAAc;IACd,mBAAe;IACf,kBAAgB;IAChB,sBAA2C;IAC3C,mBAAkB;IAClB,mBAAkB;IAClB,kBAAiB;IACjB,oBAAmB;IACnB,mBAAkB;IAClB,gBAAc;IACd,mBAAiB;IACjB,oBAAkB;IAyBhB,kBAAgC;IAChC,gBAA4C;IAE5C;;;;;;;;;;;;;;;;;;;;QAAiD;IAInD,4BAMC;IAED,mCASC;IAED,gDAMC;IAED,sCASC;IAED;;;MAaC;IAED;;;;;;;;;;;;;;;;;;;;QAUC;IAED,+DAyBC;IAED,mEAWC;IAED,qDAOC;IAED,2EA+CC;IAED,mCAOC;IAED,0BA+CC;IAED,uDAEC;IAED,wDAEC;IAED;;;MAyEC;IAED,4BAsBC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBAOC;IAED,sBAGC;IAED,uDASC;IAED,6CAQC;IAED,sDAEC;IAED,2BAEC;IAED,4BAEC;IAED,sCAGC;IAED,mFAGC;IAED,iDAmBC;IAED,iDAiCC;IAED,0DAmBC;IAED,wHA6BC;IAED,kGA6BC;IAED,0EAGC;IAED,sIAmDC;IAED,0FAGC;IAED,kEAeC;IAED,wFAiBC;IAED,4DAGC;IAED,qEAGC;IAED,0DAiBC;IAED,mFA+BC;IAED,yDAiBC;IAED,iDAIC;IAED,2CAMC;IAED,yDAIC;IAED,sCAKC;IAED,sDAMC;IAED,gDAEC;IAED,gDAEC;IAED,+DAoBC;IAED,uCAoBC;IAED,8CAEC;IAED,uCAoBC;IAED,4DAgBC;IAED,oBAQC;IAED,yDAaC;IAED,yCAGC;IAED,sCAQC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF;AAv+BD;IASE,gFAKC;IAbD,kBAAa;IACb,cAAS;IACT,gBAAW;IACX,YAAO;IACP,gBAAW;IACX,YAAO;IACP,gBAAW;IAGT,gBAA4B;IAC5B,cAAwB;IACxB,eAA0B;IAC1B,mBAAkC;CAErC"}

package/esm/midy-GM1.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 MidyGM1 {
     constructor(audioContext) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -151,14 +201,11 @@ export class MidyGM1 {
         const pannerNode = new StereoPannerNode(audioContext, {
             pan: MidyGM1.channelSettings.pan,
         });
-        const modulationEffect = this.createModulationEffect(audioContext);
-        modulationEffect.lfo.start();
         pannerNode.connect(gainNode);
         gainNode.connect(this.masterGain);
         return {
             gainNode,
             pannerNode,
-            modulationEffect,
         };
     }
     createChannels(audioContext) {
@@ -168,16 +215,15 @@ export class MidyGM1 {
                 ...MidyGM1.effectSettings,
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
-                sostenutoNotes: new Map(),
             };
         });
         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);
@@ -186,26 +232,27 @@ export class MidyGM1 {
             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;
     }
@@ -447,30 +494,26 @@ export class MidyGM1 {
         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];
     }
     connectNoteEffects(channel, gainNode) {
         gainNode.connect(channel.pannerNode);
@@ -485,71 +528,89 @@ export class MidyGM1 {
         const tuning = channel.coarseTuning + channel.fineTuning;
         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);
-        const peekFreq = this.centToHz(noteInfo.initialFilterFc + noteInfo.modEnvToFilterFc);
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - noteInfo.modSustain);
+        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 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);
+    }
+    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);
         }
-        bufferSource.connect(filterNode);
-        filterNode.connect(gainNode);
-        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;
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
@@ -559,27 +620,17 @@ export class MidyGM1 {
             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);
         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) {
@@ -599,15 +650,15 @@ export class MidyGM1 {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, modLFO, modLFOGain, 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);
@@ -621,8 +672,10 @@ export class MidyGM1 {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
-                    if (lfoGain)
-                        lfoGain.disconnect(0);
+                    if (modLFOGain)
+                        modLFOGain.disconnect(0);
+                    if (modLFO)
+                        modLFO.stop();
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -680,10 +733,10 @@ export class MidyGM1 {
         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);
@@ -720,9 +773,20 @@ export class MidyGM1 {
         }
     }
     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);
+            }
+        });
     }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
@@ -785,8 +849,8 @@ export class MidyGM1 {
         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);
@@ -803,8 +867,8 @@ export class MidyGM1 {
         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);
@@ -898,9 +962,6 @@ Object.defineProperty(MidyGM1, "channelSettings", {
     value: {
         volume: 100 / 127,
         pan: 0,
-        vibratoRate: 5,
-        vibratoDepth: 0.5,
-        vibratoDelay: 2.5,
         bank: 0,
         dataMSB: 0,
         dataLSB: 0,