@marmooo/midy 0.1.6 → 0.1.7

package/script/midy-GM2.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidyGM2 = 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.6/+esm.js");
+const midi_file_1 = require("midi-file");
+const soundfont_parser_1 = require("@marmooo/soundfont-parser");
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -53,6 +53,18 @@ class Note {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "reverbEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "chorusEffectsSend", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
@@ -208,6 +220,12 @@ class MidyGM2 {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "exclusiveClassMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "defaultOptions", {
             enumerable: true,
             configurable: true,
@@ -264,14 +282,14 @@ class MidyGM2 {
     async loadSoundFont(soundFontUrl) {
         const response = await fetch(soundFontUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const parsed = (0, _esm_js_2.parse)(new Uint8Array(arrayBuffer));
-        const soundFont = new _esm_js_2.SoundFont(parsed);
+        const parsed = (0, soundfont_parser_1.parse)(new Uint8Array(arrayBuffer));
+        const soundFont = new soundfont_parser_1.SoundFont(parsed);
         this.addSoundFont(soundFont);
     }
     async loadMIDI(midiUrl) {
         const response = await fetch(midiUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const midi = (0, _esm_js_1.parseMidi)(new Uint8Array(arrayBuffer));
+        const midi = (0, midi_file_1.parseMidi)(new Uint8Array(arrayBuffer));
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
@@ -311,19 +329,25 @@ class MidyGM2 {
         const sampleStart = instrumentKey.start;
         const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
         if (isSF3) {
-            const sample = instrumentKey.sample.slice(sampleStart, sampleEnd);
-            const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
+            const audioBuffer = await this.audioContext.decodeAudioData(buffer);
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample.subarray(sampleStart, sampleEnd);
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
                 sampleRate: instrumentKey.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
-            const int16Array = new Int16Array(sample.buffer);
+            const int16Array = new Int16Array(buffer);
             for (let i = 0; i < int16Array.length; i++) {
                 channelData[i] = int16Array[i] / 32768;
             }
@@ -421,6 +445,7 @@ class MidyGM2 {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
                     resolve();
                     return;
                 }
@@ -436,6 +461,7 @@ class MidyGM2 {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -444,6 +470,7 @@ class MidyGM2 {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -672,14 +699,14 @@ class MidyGM2 {
         return impulse;
     }
     createConvolutionReverb(audioContext, impulse) {
-        const output = new GainNode(audioContext);
+        const input = new GainNode(audioContext);
         const convolverNode = new ConvolverNode(audioContext, {
             buffer: impulse,
         });
-        convolverNode.connect(output);
+        input.connect(convolverNode);
         return {
-            input: convolverNode,
-            output,
+            input,
+            output: convolverNode,
             convolverNode,
         };
     }
@@ -721,7 +748,6 @@ class MidyGM2 {
     //   M.R.Schroeder, "Natural Sounding Artificial Reverberation", J.Audio Eng. Soc., vol.10, p.219, 1962
     createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays) {
         const input = new GainNode(audioContext);
-        const output = new GainNode(audioContext);
         const mergerGain = new GainNode(audioContext);
         for (let i = 0; i < combDelays.length; i++) {
             const comb = this.createCombFilter(audioContext, input, combDelays[i], combFeedbacks[i]);
@@ -732,7 +758,7 @@ class MidyGM2 {
             const allpass = this.createAllpassFilter(audioContext, (i === 0) ? mergerGain : allpasses.at(-1), allpassDelays[i], allpassFeedbacks[i]);
             allpasses.push(allpass);
         }
-        allpasses.at(-1).connect(output);
+        const output = allpasses.at(-1);
         return { input, output };
     }
     createChorusEffect(audioContext) {
@@ -963,6 +989,20 @@ class MidyGM2 {
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeNode);
+        if (0 < channel.reverbSendLevel && 0 < instrumentKey.reverbEffectsSend) {
+            note.reverbEffectsSend = new GainNode(this.audioContext, {
+                gain: instrumentKey.reverbEffectsSend,
+            });
+            note.volumeNode.connect(note.reverbEffectsSend);
+            note.reverbEffectsSend.connect(this.reverbEffect.input);
+        }
+        if (0 < channel.chorusSendLevel && 0 < instrumentKey.chorusEffectsSend) {
+            note.chorusEffectsSend = new GainNode(this.audioContext, {
+                gain: instrumentKey.chorusEffectsSend,
+            });
+            note.volumeNode.connect(note.chorusEffectsSend);
+            note.chorusEffectsSend.connect(this.chorusEffect.input);
+        }
         note.bufferSource.start(startTime);
         return note;
     }
@@ -992,6 +1032,19 @@ class MidyGM2 {
         if (channel.sostenutoPedal) {
             channel.sostenutoNotes.set(noteNumber, note);
         }
+        const exclusiveClass = instrumentKey.exclusiveClass;
+        if (exclusiveClass !== 0) {
+            if (this.exclusiveClassMap.has(exclusiveClass)) {
+                const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
+                const [prevNote, prevChannelNumber] = prevEntry;
+                if (!prevNote.ending) {
+                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, undefined, // portamentoNoteNumber
+                    true);
+                }
+            }
+            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
+        }
         const scheduledNotes = channel.scheduledNotes;
         if (scheduledNotes.has(noteNumber)) {
             scheduledNotes.get(noteNumber).push(note);
@@ -1004,15 +1057,15 @@ class MidyGM2 {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now, portamento);
     }
-    stopNote(stopTime, endTime, scheduledNotes, index) {
+    stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
         note.volumeNode.gain
-            .cancelScheduledValues(stopTime)
-            .linearRampToValueAtTime(0, endTime);
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
         this.scheduleTask(() => {
             note.bufferSource.loop = false;
-        }, endTime);
+        }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
                 scheduledNotes[index] = null;
@@ -1028,12 +1081,18 @@ class MidyGM2 {
                     note.vibratoDepth.disconnect();
                     note.vibratoLFO.stop();
                 }
+                if (note.reverbEffectsSend) {
+                    note.reverbEffectsSend.disconnect();
+                }
+                if (note.chorusEffectsSend) {
+                    note.chorusEffectsSend.disconnect();
+                }
                 resolve();
             };
-            note.bufferSource.stop(endTime);
+            note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, portamentoNoteNumber, force) {
+    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, portamentoNoteNumber, force) {
         const channel = this.channels[channelNumber];
         if (!force) {
             if (channel.sustainPedal)
@@ -1051,21 +1110,22 @@ class MidyGM2 {
             if (note.ending)
                 continue;
             if (portamentoNoteNumber === undefined) {
-                const volEndTime = stopTime + note.instrumentKey.volRelease;
-                const modRelease = stopTime + note.instrumentKey.modRelease;
+                const volRelease = endTime + note.instrumentKey.volRelease;
+                const modRelease = endTime + note.instrumentKey.modRelease;
                 note.filterNode.frequency
-                    .cancelScheduledValues(stopTime)
+                    .cancelScheduledValues(endTime)
                     .linearRampToValueAtTime(0, modRelease);
-                return this.stopNote(stopTime, volEndTime, scheduledNotes, i);
+                const stopTime = Math.min(volRelease, modRelease);
+                return this.stopNote(endTime, stopTime, scheduledNotes, i);
             }
             else {
-                const portamentoTime = stopTime + channel.portamentoTime;
+                const portamentoTime = endTime + channel.portamentoTime;
                 const detuneChange = (portamentoNoteNumber - noteNumber) * 100;
                 const detune = note.bufferSource.detune.value + detuneChange;
                 note.bufferSource.detune
-                    .cancelScheduledValues(stopTime)
+                    .cancelScheduledValues(endTime)
                     .linearRampToValueAtTime(detune, portamentoTime);
-                return this.stopNote(stopTime, portamentoTime, scheduledNotes, i);
+                return this.stopNote(endTime, portamentoTime, scheduledNotes, i);
             }
         }
     }
@@ -1280,20 +1340,44 @@ class MidyGM2 {
             if (0 < reverbSendLevel) {
                 const now = this.audioContext.currentTime;
                 channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, now);
             }
             else {
-                channel.merger.disconnect(reverbEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.reverbEffectsSend <= 0)
+                            continue;
+                        note.reverbEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < reverbSendLevel) {
-                channel.merger.connect(reverbEffect.input);
                 const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.reverbEffectsSend <= 0)
+                            continue;
+                        if (!note.reverbEffectsSend) {
+                            note.reverbEffectsSend = new GainNode(this.audioContext, {
+                                gain: note.instrumentKey.reverbEffectsSend,
+                            });
+                            note.volumeNode.connect(note.reverbEffectsSend);
+                        }
+                        note.reverbEffectsSend.connect(reverbEffect.input);
+                    }
+                });
                 channel.reverbSendLevel = reverbSendLevel / 127;
-                reverbEffect.output.gain.cancelScheduledValues(now);
-                reverbEffect.output.gain.setValueAtTime(channel.reverbSendLevel, now);
+                reverbEffect.input.gain.cancelScheduledValues(now);
+                reverbEffect.input.gain.setValueAtTime(channel.reverbSendLevel, now);
             }
         }
     }
@@ -1304,20 +1388,44 @@ class MidyGM2 {
             if (0 < chorusSendLevel) {
                 const now = this.audioContext.currentTime;
                 channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, now);
             }
             else {
-                channel.merger.disconnect(chorusEffect.input);
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.chorusEffectsSend <= 0)
+                            continue;
+                        note.chorusEffectsSend.disconnect();
+                    }
+                });
             }
         }
         else {
             if (0 < chorusSendLevel) {
-                channel.merger.connect(chorusEffect.input);
                 const now = this.audioContext.currentTime;
+                channel.scheduledNotes.forEach((noteList) => {
+                    for (let i = 0; i < noteList.length; i++) {
+                        const note = noteList[i];
+                        if (!note)
+                            continue;
+                        if (note.instrumentKey.chorusEffectsSend <= 0)
+                            continue;
+                        if (!note.chorusEffectsSend) {
+                            note.chorusEffectsSend = new GainNode(this.audioContext, {
+                                gain: note.instrumentKey.chorusEffectsSend,
+                            });
+                            note.volumeNode.connect(note.chorusEffectsSend);
+                        }
+                        note.chorusEffectsSend.connect(chorusEffect.input);
+                    }
+                });
                 channel.chorusSendLevel = chorusSendLevel / 127;
-                chorusEffect.output.gain.cancelScheduledValues(now);
-                chorusEffect.output.gain.setValueAtTime(channel.chorusSendLevel, now);
+                chorusEffect.input.gain.cancelScheduledValues(now);
+                chorusEffect.input.gain.setValueAtTime(channel.chorusSendLevel, now);
             }
         }
     }
@@ -1659,10 +1767,8 @@ class MidyGM2 {
     }
     setReverbTime(value) {
         this.reverb.time = this.getReverbTime(value);
-        const { audioContext, channels, options } = this;
-        for (let i = 0; i < channels.length; i++) {
-            channels[i].reverbEffect = options.reverbAlgorithm(audioContext);
-        }
+        const { audioContext, options } = this;
+        this.reverbEffect = options.reverbAlgorithm(audioContext);
     }
     getReverbTime(value) {
         return Math.pow(Math.E, (value - 40) * 0.025);
@@ -1739,10 +1845,7 @@ class MidyGM2 {
         const now = this.audioContext.currentTime;
         const modRate = this.getChorusModRate(value);
         this.chorus.modRate = modRate;
-        for (let i = 0; i < this.channels.length; i++) {
-            const lfo = this.channels[i].chorusEffect.lfo;
-            lfo.frequency.setValueAtTime(modRate, now);
-        }
+        this.chorusEffect.lfo.frequency.setValueAtTime(modRate, now);
     }
     getChorusModRate(value) {
         return value * 0.122; // Hz
@@ -1751,12 +1854,9 @@ class MidyGM2 {
         const now = this.audioContext.currentTime;
         const modDepth = this.getChorusModDepth(value);
         this.chorus.modDepth = modDepth;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            chorusEffect.lfoGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(modDepth / 2, now);
-        }
+        this.chorusEffect.lfoGain.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(modDepth / 2, now);
     }
     getChorusModDepth(value) {
         return (value + 1) / 3200; // second
@@ -1765,14 +1865,11 @@ class MidyGM2 {
         const now = this.audioContext.currentTime;
         const feedback = this.getChorusFeedback(value);
         this.chorus.feedback = feedback;
-        for (let i = 0; i < this.channels.length; i++) {
-            const chorusEffect = this.channels[i].chorusEffect;
-            for (let j = 0; j < chorusEffect.feedbackGains.length; j++) {
-                const feedbackGain = chorusEffect.feedbackGains[j];
-                feedbackGain.gain
-                    .cancelScheduledValues(now)
-                    .setValueAtTime(feedback, now);
-            }
+        const chorusEffect = this.chorusEffect;
+        for (let i = 0; i < chorusEffect.feedbackGains.length; i++) {
+            chorusEffect.feedbackGains[i].gain
+                .cancelScheduledValues(now)
+                .setValueAtTime(feedback, now);
         }
     }
     getChorusFeedback(value) {
@@ -1780,15 +1877,28 @@ class MidyGM2 {
     }
     setChorusSendToReverb(value) {
         const sendToReverb = this.getChorusSendToReverb(value);
-        if (0 < sendToReverb) {
-            const now = this.audioContext.currentTime;
+        const sendGain = this.chorusEffect.sendGain;
+        if (0 < this.chorus.sendToReverb) {
             this.chorus.sendToReverb = sendToReverb;
-            this.chorusEffect.sendGain.gain
-                .cancelScheduledValues(now)
-                .setValueAtTime(sendToReverb, now);
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
+            else {
+                sendGain.disconnect();
+            }
         }
-        else if (this.chorus.sendToReverb !== 0) {
-            this.chorusEffect.sendGain.disconnect(this.reverbEffect.input);
+        else {
+            this.chorus.sendToReverb = sendToReverb;
+            if (0 < sendToReverb) {
+                const now = this.audioContext.currentTime;
+                sendGain.connect(this.reverbEffect.input);
+                sendGain.gain
+                    .cancelScheduledValues(now)
+                    .setValueAtTime(sendToReverb, now);
+            }
         }
     }
     getChorusSendToReverb(value) {

package/script/midy-GMLite.d.ts

@@ -35,6 +35,7 @@ export class MidyGMLite {
     timeline: any[];
     instruments: any[];
     notePromises: any[];
+    exclusiveClassMap: Map<any, any>;
     audioContext: any;
     masterGain: any;
     controlChangeHandlers: {
@@ -96,11 +97,11 @@ export class MidyGMLite {
     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>;
-    stopNote(stopTime: any, endTime: any, scheduledNotes: any, index: any): Promise<any>;
-    scheduleNoteRelease(channelNumber: any, noteNumber: any, _velocity: any, stopTime: any, force: any): void;
-    releaseNote(channelNumber: any, noteNumber: any, velocity: any): void;
+    stopNote(endTime: any, stopTime: any, scheduledNotes: any, index: any): Promise<any>;
+    scheduleNoteRelease(channelNumber: any, noteNumber: any, _velocity: any, endTime: any, force: any): Promise<any> | undefined;
+    releaseNote(channelNumber: any, noteNumber: any, velocity: any): Promise<any> | undefined;
     releaseSustainPedal(channelNumber: any, halfVelocity: any): any[];
-    handleMIDIMessage(statusByte: any, data1: any, data2: any): void | Promise<void>;
+    handleMIDIMessage(statusByte: any, data1: any, data2: any): void | Promise<any>;
     handleProgramChange(channelNumber: any, program: any): void;
     handlePitchBendMessage(channelNumber: any, lsb: any, msb: any): void;
     setPitchBend(channelNumber: any, pitchBend: any): void;

package/script/midy-GMLite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"midy-GMLite.d.ts","sourceRoot":"","sources":["../src/midy-GMLite.js"],"names":[],"mappings":"AAsBA;IAmBE;;;;;;;;;MASE;IAEF;;;;;;;MAOE;IAEF,+BAOC;IA7CD,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;IAuBhB,kBAAgC;IAChC,gBAA4C;IAC5C;;;;;;;;;;;;;MAA+D;IAC/D,gBAAiD;IAKnD,4BAMC;IAED,mCAWC;IAED,gDAMC;IAED,sCASC;IAED;;;;MAeC;IAED,yCAUC;IAED,+DAuBC;IAED,mEAWC;IAED,2EA+CC;IAED,mCAOC;IAED,0BA+CC;IAED,uDAEC;IAED,wDAEC;IAED;;;MAgEC;IAED,+EAmBC;IAED,qDAKC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBAOC;IAED,sBAGC;IAED,uDASC;IAED,6CAQC;IAED,2BAEC;IAED,4BAEC;IAED,yCAEC;IAED,mFAGC;IAED,mCAeC;IAED,+CAwBC;IAED,6CAIC;IAED,mCAsBC;IAED,+DA0BC;IAED,wHAgCC;IAED,kGA8BC;IAED,0EAGC;IAED,qFA4BC;IAED,0GAsBC;IAED,sEAGC;IAED,kEAeC;IAED,iFAiBC;IAED,4DAGC;IAED,qEAGC;IAED,uDAOC;IAED;;;;;;;;;;;;;MAeC;IAED,2EASC;IAED,qCAkBC;IAED,8DAIC;IACD,iDAIC;IAED;;;MAMC;IAED,2CAIC;IAED,yDAIC;IAED,mDAGC;IAED,wCAUC;IAED,sDAMC;IAED,oCAYC;IAED,gDAEC;IAED,gDAEC;IAED,mDAGC;IAED,oDAaC;IAED,kDAKC;IAED,iEAOC;IAED,+CAEC;IAED,8CAEC;IAED,+CAEC;IAED,4DAgBC;IAED,oBASC;IAED,yDAaC;IAED,yCAGC;IAED,mCAQC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF;AAj/BD;IAQE,gFAKC;IAZD,kBAAa;IACb,gBAAW;IACX,gBAAW;IACX,iBAAY;IACZ,mBAAc;IACd,qBAAgB;IAGd,gBAA4B;IAC5B,cAAwB;IACxB,eAA0B;IAC1B,mBAAkC;CAErC"}
+{"version":3,"file":"midy-GMLite.d.ts","sourceRoot":"","sources":["../src/midy-GMLite.js"],"names":[],"mappings":"AAmBA;IAoBE;;;;;;;;;MASE;IAEF;;;;;;;MAOE;IAEF,+BAOC;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;IAClB,iCAA8B;IAuB5B,kBAAgC;IAChC,gBAA4C;IAC5C;;;;;;;;;;;;;MAA+D;IAC/D,gBAAiD;IAKnD,4BAMC;IAED,mCAWC;IAED,gDAMC;IAED,sCASC;IAED;;;;MAeC;IAED,yCAUC;IAED,+DA2BC;IAED,mEAWC;IAED,2EA+CC;IAED,mCAOC;IAED,0BAkDC;IAED,uDAEC;IAED,wDAEC;IAED;;;MAgEC;IAED,+EAmBC;IAED,qDAKC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBAOC;IAED,sBAGC;IAED,uDASC;IAED,6CAQC;IAED,2BAEC;IAED,4BAEC;IAED,yCAEC;IAED,mFAGC;IAED,mCAeC;IAED,+CAwBC;IAED,6CAIC;IAED,mCAsBC;IAED,+DA0BC;IAED,wHAgCC;IAED,kGAgDC;IAED,0EAGC;IAED,qFA4BC;IAED,6HAuBC;IAED,0FAGC;IAED,kEAeC;IAED,gFAiBC;IAED,4DAGC;IAED,qEAGC;IAED,uDAOC;IAED;;;;;;;;;;;;;MAeC;IAED,2EASC;IAED,qCAkBC;IAED,8DAIC;IACD,iDAIC;IAED;;;MAMC;IAED,2CAIC;IAED,yDAIC;IAED,mDAGC;IAED,wCAUC;IAED,sDAMC;IAED,oCAYC;IAED,gDAEC;IAED,gDAEC;IAED,mDAGC;IAED,oDAaC;IAED,kDAKC;IAED,iEAOC;IAED,+CAEC;IAED,8CAEC;IAED,+CAEC;IAED,4DAgBC;IAED,oBASC;IAED,yDAaC;IAED,yCAGC;IAED,mCAQC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF;AA5gCD;IAQE,gFAKC;IAZD,kBAAa;IACb,gBAAW;IACX,gBAAW;IACX,iBAAY;IACZ,mBAAc;IACd,qBAAgB;IAGd,gBAA4B;IAC5B,cAAwB;IACxB,eAA0B;IAC1B,mBAAkC;CAErC"}

package/script/midy-GMLite.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidyGMLite = 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.6/+esm.js");
+const midi_file_1 = require("midi-file");
+const soundfont_parser_1 = require("@marmooo/soundfont-parser");
 class Note {
     constructor(noteNumber, velocity, startTime, instrumentKey) {
         Object.defineProperty(this, "bufferSource", {
@@ -151,6 +151,12 @@ class MidyGMLite {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "exclusiveClassMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         this.audioContext = audioContext;
         this.masterGain = new GainNode(audioContext);
         this.controlChangeHandlers = this.createControlChangeHandlers();
@@ -180,14 +186,14 @@ class MidyGMLite {
     async loadSoundFont(soundFontUrl) {
         const response = await fetch(soundFontUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const parsed = (0, _esm_js_2.parse)(new Uint8Array(arrayBuffer));
-        const soundFont = new _esm_js_2.SoundFont(parsed);
+        const parsed = (0, soundfont_parser_1.parse)(new Uint8Array(arrayBuffer));
+        const soundFont = new soundfont_parser_1.SoundFont(parsed);
         this.addSoundFont(soundFont);
     }
     async loadMIDI(midiUrl) {
         const response = await fetch(midiUrl);
         const arrayBuffer = await response.arrayBuffer();
-        const midi = (0, _esm_js_1.parseMidi)(new Uint8Array(arrayBuffer));
+        const midi = (0, midi_file_1.parseMidi)(new Uint8Array(arrayBuffer));
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
@@ -223,19 +229,25 @@ class MidyGMLite {
         const sampleStart = instrumentKey.start;
         const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
         if (isSF3) {
-            const sample = instrumentKey.sample.slice(sampleStart, sampleEnd);
-            const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
+            const audioBuffer = await this.audioContext.decodeAudioData(buffer);
             return audioBuffer;
         }
         else {
-            const sample = instrumentKey.sample.subarray(sampleStart, sampleEnd);
+            const sample = instrumentKey.sample;
+            const start = sample.byteOffset + sampleStart;
+            const end = sample.byteOffset + sampleEnd;
+            const buffer = sample.buffer.slice(start, end);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
                 sampleRate: instrumentKey.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
-            const int16Array = new Int16Array(sample.buffer);
+            const int16Array = new Int16Array(buffer);
             for (let i = 0; i < int16Array.length; i++) {
                 channelData[i] = int16Array[i] / 32768;
             }
@@ -309,6 +321,7 @@ class MidyGMLite {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
+                    this.exclusiveClassMap.clear();
                     resolve();
                     return;
                 }
@@ -324,6 +337,7 @@ class MidyGMLite {
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.notePromises = [];
                     resolve();
                     this.isStopping = false;
@@ -332,6 +346,7 @@ class MidyGMLite {
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true);
+                    this.exclusiveClassMap.clear();
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
                     offset = this.resumeTime - this.startTime;
@@ -637,6 +652,19 @@ class MidyGMLite {
         const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
         note.volumeNode.connect(channel.gainL);
         note.volumeNode.connect(channel.gainR);
+        const exclusiveClass = instrumentKey.exclusiveClass;
+        if (exclusiveClass !== 0) {
+            if (this.exclusiveClassMap.has(exclusiveClass)) {
+                const prevEntry = this.exclusiveClassMap.get(exclusiveClass);
+                const [prevNote, prevChannelNumber] = prevEntry;
+                if (!prevNote.ending) {
+                    this.scheduleNoteRelease(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                    startTime, undefined, // portamentoNoteNumber
+                    true);
+                }
+            }
+            this.exclusiveClassMap.set(exclusiveClass, [note, channelNumber]);
+        }
         const scheduledNotes = channel.scheduledNotes;
         if (scheduledNotes.has(noteNumber)) {
             scheduledNotes.get(noteNumber).push(note);
@@ -649,15 +677,15 @@ class MidyGMLite {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteOn(channelNumber, noteNumber, velocity, now);
     }
-    stopNote(stopTime, endTime, scheduledNotes, index) {
+    stopNote(endTime, stopTime, scheduledNotes, index) {
         const note = scheduledNotes[index];
         note.volumeNode.gain
-            .cancelScheduledValues(stopTime)
-            .linearRampToValueAtTime(0, endTime);
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, stopTime);
         note.ending = true;
         this.scheduleTask(() => {
             note.bufferSource.loop = false;
-        }, endTime);
+        }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
                 scheduledNotes[index] = null;
@@ -675,10 +703,10 @@ class MidyGMLite {
                 }
                 resolve();
             };
-            note.bufferSource.stop(endTime);
+            note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteRelease(channelNumber, noteNumber, _velocity, stopTime, force) {
+    scheduleNoteRelease(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         if (!force && channel.sustainPedal)
             return;
@@ -691,12 +719,13 @@ class MidyGMLite {
                 continue;
             if (note.ending)
                 continue;
-            const volEndTime = stopTime + note.instrumentKey.volRelease;
-            const modRelease = stopTime + note.instrumentKey.modRelease;
+            const volRelease = endTime + note.instrumentKey.volRelease;
+            const modRelease = endTime + note.instrumentKey.modRelease;
             note.filterNode.frequency
-                .cancelScheduledValues(stopTime)
+                .cancelScheduledValues(endTime)
                 .linearRampToValueAtTime(0, modRelease);
-            this.stopNote(stopTime, volEndTime, scheduledNotes, i);
+            const stopTime = Math.min(volRelease, modRelease);
+            return this.stopNote(endTime, stopTime, scheduledNotes, i);
         }
     }
     releaseNote(channelNumber, noteNumber, velocity) {