@marmooo/midy 0.0.2 → 0.0.4

package/script/midy-GMLite.js

@@ -11,12 +11,6 @@ class MidyGMLite {
             writable: true,
             value: 120
         });
-        Object.defineProperty(this, "secondsPerBeat", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0.5
-        });
         Object.defineProperty(this, "totalTime", {
             enumerable: true,
             configurable: true,
@@ -147,10 +141,10 @@ class MidyGMLite {
         const response = await fetch(midiUrl);
         const arrayBuffer = await response.arrayBuffer();
         const midi = (0, _esm_js_1.parseMidi)(new Uint8Array(arrayBuffer));
+        this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
         this.timeline = midiData.timeline;
-        this.ticksPerBeat = midi.header.ticksPerBeat;
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
@@ -229,28 +223,30 @@ class MidyGMLite {
     async scheduleTimelineEvents(t, offset, queueIndex) {
         while (queueIndex < this.timeline.length) {
             const event = this.timeline[queueIndex];
-            const time = this.ticksToSecond(event.ticks, this.secondsPerBeat);
-            if (time > t + this.lookAhead)
+            if (event.startTime > t + this.lookAhead)
                 break;
             switch (event.type) {
-                case "controller":
-                    this.handleControlChange(event.channel, event.controllerType, event.value);
-                    break;
                 case "noteOn":
-                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, time + this.startDelay - offset);
-                    break;
+                    if (event.velocity !== 0) {
+                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
+                        break;
+                    }
+                /* falls through */
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteRelease(event.channel, event.noteNumber, event.velocity, time + this.startDelay - offset);
+                    const notePromise = this.scheduleNoteRelease(event.channel, event.noteNumber, event.velocity, event.startTime + this.startDelay - offset);
                     if (notePromise) {
                         this.notePromises.push(notePromise);
                     }
                     break;
                 }
+                case "controller":
+                    this.handleControlChange(event.channel, event.controllerType, event.value);
+                    break;
                 case "programChange":
                     this.handleProgramChange(event.channel, event.programNumber);
                     break;
-                case "setTempo":
-                    this.secondsPerBeat = event.microsecondsPerBeat / 1000000;
+                case "pitchBend":
+                    this.handlePitchBend(event.channel, event.value);
                     break;
                 case "sysEx":
                     this.handleSysEx(event.data);
@@ -260,9 +256,8 @@ class MidyGMLite {
         return queueIndex;
     }
     getQueueIndex(second) {
-        const ticks = this.secondToTicks(second, this.secondsPerBeat);
         for (let i = 0; i < this.timeline.length; i++) {
-            if (ticks <= this.timeline[i].ticks) {
+            if (second <= this.timeline[i].startTime) {
                 return i;
             }
         }
@@ -370,18 +365,28 @@ class MidyGMLite {
                 timeline.push(event);
             });
         });
+        const priority = {
+            setTempo: 0,
+            controller: 1,
+        };
         timeline.sort((a, b) => {
-            if (a.ticks !== b.ticks) {
+            if (a.ticks !== b.ticks)
                 return a.ticks - b.ticks;
-            }
-            if (a.type !== "controller" && b.type === "controller") {
-                return -1;
-            }
-            if (a.type === "controller" && b.type !== "controller") {
-                return 1;
-            }
-            return 0;
+            return (priority[a.type] || 2) - (priority[b.type] || 2);
         });
+        let prevTempoTime = 0;
+        let prevTempoTicks = 0;
+        let secondsPerBeat = 0.5;
+        for (let i = 0; i < timeline.length; i++) {
+            const event = timeline[i];
+            const timeFromPrevTempo = this.ticksToSecond(event.ticks - prevTempoTicks, secondsPerBeat);
+            event.startTime = prevTempoTime + timeFromPrevTempo;
+            if (event.type === "setTempo") {
+                prevTempoTime += this.ticksToSecond(event.ticks - prevTempoTicks, secondsPerBeat);
+                secondsPerBeat = event.microsecondsPerBeat / 1000000;
+                prevTempoTicks = event.ticks;
+            }
+        }
         return { instruments, timeline };
     }
     stopNotes() {
@@ -433,32 +438,12 @@ class MidyGMLite {
         }
     }
     calcTotalTime() {
-        const endOfTracks = [];
-        let prevTicks = 0;
         let totalTime = 0;
-        let secondsPerBeat = 0.5;
         for (let i = 0; i < this.timeline.length; i++) {
             const event = this.timeline[i];
-            switch (event.type) {
-                case "setTempo": {
-                    const durationTicks = event.ticks - prevTicks;
-                    totalTime += this.ticksToSecond(durationTicks, secondsPerBeat);
-                    secondsPerBeat = event.microsecondsPerBeat / 1000000;
-                    prevTicks = event.ticks;
-                    break;
-                }
-                case "endOfTrack":
-                    endOfTracks.push(event);
-            }
+            if (totalTime < event.startTime)
+                totalTime = event.startTime;
         }
-        let maxTicks = 0;
-        for (let i = 0; i < endOfTracks.length; i++) {
-            const event = endOfTracks[i];
-            if (maxTicks < event.ticks)
-                maxTicks = event.ticks;
-        }
-        const durationTicks = maxTicks - prevTicks;
-        totalTime += this.ticksToSecond(durationTicks, secondsPerBeat);
         return totalTime;
     }
     currentTime() {
@@ -486,43 +471,8 @@ class MidyGMLite {
         const lfo = new OscillatorNode(audioContext, {
             frequency: 5,
         });
-        const lfoGain = new GainNode(audioContext);
-        lfo.connect(lfoGain);
         return {
             lfo,
-            lfoGain,
-        };
-    }
-    createReverbEffect(audioContext, options = {}) {
-        const { decay = 0.8, preDecay = 0, } = options;
-        const sampleRate = audioContext.sampleRate;
-        const length = sampleRate * decay;
-        const impulse = new AudioBuffer({
-            numberOfChannels: 2,
-            length,
-            sampleRate,
-        });
-        const preDecayLength = Math.min(sampleRate * preDecay, length);
-        for (let channel = 0; channel < impulse.numberOfChannels; channel++) {
-            const channelData = impulse.getChannelData(channel);
-            for (let i = 0; i < preDecayLength; i++) {
-                channelData[i] = Math.random() * 2 - 1;
-            }
-            for (let i = preDecayLength; i < length; i++) {
-                const attenuation = Math.exp(-(i - preDecayLength) / sampleRate / decay);
-                channelData[i] = (Math.random() * 2 - 1) * attenuation;
-            }
-        }
-        const convolverNode = new ConvolverNode(audioContext, {
-            buffer: impulse,
-        });
-        const dryGain = new GainNode(audioContext);
-        const wetGain = new GainNode(audioContext);
-        convolverNode.connect(wetGain);
-        return {
-            convolverNode,
-            dryGain,
-            wetGain,
         };
     }
     connectNoteEffects(channel, gainNode) {
@@ -534,19 +484,23 @@ class MidyGMLite {
     centToHz(cent) {
         return 8.176 * Math.pow(2, cent / 1200);
     }
+    calcSemitoneOffset(channel) {
+        return channel.pitchBend * channel.pitchBendRange + tuning;
+    }
+    calcPlaybackRate(noteInfo, noteNumber, semitoneOffset) {
+        return noteInfo.playbackRate(noteNumber) * Math.pow(2, semitoneOffset / 12);
+    }
     async createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3) {
-        const semitoneOffset = channel.pitchBend * channel.pitchBendRange;
-        const playbackRate = noteInfo.playbackRate(noteNumber) *
-            Math.pow(2, semitoneOffset / 12);
         const bufferSource = await this.createNoteBufferNode(noteInfo, isSF3);
-        bufferSource.playbackRate.value = playbackRate;
+        const semitoneOffset = this.calcSemitoneOffset(channel);
+        bufferSource.playbackRate.value = this.calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
         // volume envelope
         const gainNode = new GainNode(this.audioContext, {
             gain: 0,
         });
         let volume = (velocity / 127) * channel.volume * channel.expression;
         if (volume === 0)
-            volume = 1e-6; // exponentialRampToValueAtTime() requirea a non-zero value
+            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;
@@ -558,12 +512,6 @@ class MidyGMLite {
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
-        if (channel.modulation > 0) {
-            const lfoGain = channel.modulationEffect.lfoGain;
-            lfoGain.connect(bufferSource.detune);
-            lfoGain.gain.cancelScheduledValues(startTime + channel.vibratoDelay);
-            lfoGain.gain.setValueAtTime(channel.modulation, startTime + channel.vibratoDelay);
-        }
         // filter envelope
         const maxFreq = this.audioContext.sampleRate / 2;
         const baseFreq = this.centToHz(noteInfo.initialFilterFc);
@@ -587,10 +535,23 @@ class MidyGMLite {
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
+        let lfoGain;
+        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);
+        }
         bufferSource.connect(filterNode);
         filterNode.connect(gainNode);
         bufferSource.start(startTime, noteInfo.start / noteInfo.sampleRate);
-        return { bufferSource, gainNode, filterNode };
+        return { bufferSource, gainNode, filterNode, lfoGain };
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
@@ -603,16 +564,17 @@ class MidyGMLite {
         const noteInfo = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
         if (!noteInfo)
             return;
-        const { bufferSource, gainNode, filterNode } = await this
+        const { bufferSource, gainNode, filterNode, lfoGain } = await this
             .createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3);
         this.connectNoteEffects(channel, gainNode);
         const scheduledNotes = channel.scheduledNotes;
         const scheduledNote = {
-            gainNode,
-            filterNode,
             bufferSource,
-            noteNumber,
+            filterNode,
+            gainNode,
+            lfoGain,
             noteInfo,
+            noteNumber,
             startTime,
         };
         if (scheduledNotes.has(noteNumber)) {
@@ -639,7 +601,7 @@ class MidyGMLite {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
             const velocityRate = (velocity + 127) / 127;
             const volEndTime = stopTime + noteInfo.volRelease * velocityRate;
             gainNode.gain.cancelScheduledValues(stopTime);
@@ -661,6 +623,8 @@ class MidyGMLite {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
+                    if (lfoGain)
+                        lfoGain.disconnect(0);
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -671,28 +635,21 @@ class MidyGMLite {
         const now = this.audioContext.currentTime;
         return this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now);
     }
-    releaseSustainPedal(channelNumber) {
-        const now = this.audioContext.currentTime;
+    releaseSustainPedal(channelNumber, halfVelocity) {
+        const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
+        const promises = [];
         channel.sustainPedal = false;
         channel.scheduledNotes.forEach((scheduledNotes) => {
             scheduledNotes.forEach((scheduledNote) => {
                 if (scheduledNote) {
-                    const { bufferSource, gainNode, filterNode, noteInfo } = scheduledNote;
-                    const volEndTime = now + noteInfo.volRelease;
-                    gainNode.gain.cancelScheduledValues(now);
-                    gainNode.gain.linearRampToValueAtTime(0, volEndTime);
-                    const maxFreq = this.audioContext.sampleRate / 2;
-                    const baseFreq = this.centToHz(noteInfo.initialFilterFc);
-                    const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-                    const modEndTime = now + noteInfo.modRelease;
-                    filterNode.frequency
-                        .cancelScheduledValues(stopTime)
-                        .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
-                    bufferSource.stop(volEndTime);
+                    const { noteNumber } = scheduledNote;
+                    const promise = this.releaseNote(channelNumber, noteNumber, velocity);
+                    promises.push(promise);
                 }
             });
         });
+        return promises;
     }
     handleMIDIMessage(statusByte, data1, data2) {
         const channelNumber = statusByte & 0x0F;
@@ -702,46 +659,37 @@ class MidyGMLite {
                 return this.releaseNote(channelNumber, data1, data2);
             case 0x90:
                 return this.noteOn(channelNumber, data1, data2);
-            case 0xA0:
-                return this.handlePolyphonicKeyPressure(channelNumber, data1, data2);
             case 0xB0:
                 return this.handleControlChange(channelNumber, data1, data2);
             case 0xC0:
                 return this.handleProgramChange(channelNumber, data1);
-            case 0xD0:
-                return this.handleChannelPressure(channelNumber, data1);
             case 0xE0:
-                return this.handlePitchBend(channelNumber, data1, data2);
+                return this.handlePitchBendMessage(channelNumber, data1, data2);
             default:
                 console.warn(`Unsupported MIDI message: ${messageType.toString(16)}`);
         }
     }
-    handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure) {
-        const now = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const scheduledNotes = channel.scheduledNotes.get(noteNumber);
-        pressure /= 127;
-        if (scheduledNotes) {
-            scheduledNotes.forEach((scheduledNote) => {
-                if (scheduledNote) {
-                    const { initialAttenuation } = scheduledNote.noteInfo;
-                    const gain = this.cbToRatio(-initialAttenuation) * pressure;
-                    scheduledNote.gainNode.gain.cancelScheduledValues(now);
-                    scheduledNote.gainNode.gain.setValueAtTime(gain, now);
-                }
-            });
-        }
-    }
     handleProgramChange(channelNumber, program) {
         const channel = this.channels[channelNumber];
         channel.program = program;
     }
-    handleChannelPressure(channelNumber, pressure) {
-        this.channels[channelNumber].channelPressure = pressure;
+    handlePitchBendMessage(channelNumber, lsb, msb) {
+        const pitchBend = msb * 128 + lsb;
+        this.handlePitchBend(channelNumber, pitchBend);
     }
-    handlePitchBend(channelNumber, lsb, msb) {
-        const pitchBend = (msb * 128 + lsb - 8192) / 8192;
-        this.channels[channelNumber].pitchBend = pitchBend;
+    handlePitchBend(channelNumber, pitchBend) {
+        const now = this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        channel.pitchBend = (pitchBend - 8192) / 8192;
+        const semitoneOffset = this.calcSemitoneOffset(channel);
+        const activeNotes = this.getActiveNotes(channel);
+        activeNotes.forEach((activeNote) => {
+            const { bufferSource, noteInfo, noteNumber } = activeNote;
+            const playbackRate = calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
+            bufferSource.playbackRate
+                .cancelScheduledValues(now)
+                .setValueAtTime(playbackRate * pressure, now);
+        });
     }
     handleControlChange(channelNumber, controller, value) {
         switch (controller) {
@@ -774,13 +722,9 @@ class MidyGMLite {
         }
     }
     setModulation(channelNumber, modulation) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.modulation = (modulation * 100 / 127) *
-            channel.modulationDepthRange;
-        const lfoGain = channel.modulationEffect.lfoGain;
-        lfoGain.gain.cancelScheduledValues(now);
-        lfoGain.gain.setValueAtTime(channel.modulation, now);
+        channel.modulation = (modulation / 127) *
+            (channel.modulationDepthRange * 100);
     }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
@@ -809,7 +753,7 @@ class MidyGMLite {
         const isOn = value >= 64;
         this.channels[channelNumber].sustainPedal = isOn;
         if (!isOn) {
-            this.releaseSustainPedal(channelNumber);
+            this.releaseSustainPedal(channelNumber, value);
         }
     }
     setRPNMSB(channelNumber, value) {
@@ -905,13 +849,18 @@ class MidyGMLite {
         }
     }
     handleMasterVolumeSysEx(data) {
-        const volume = (data[5] * 128 + data[4] - 8192) / 8192;
+        const volume = (data[5] * 128 + data[4]) / 16383;
         this.handleMasterVolume(volume);
     }
     handleMasterVolume(volume) {
-        const now = this.audioContext.currentTime;
-        this.masterGain.gain.cancelScheduledValues(now);
-        this.masterGain.gain.setValueAtTime(volume * volume, now);
+        if (volume < 0 && 1 < volume) {
+            console.error("Master Volume is out of range");
+        }
+        else {
+            const now = this.audioContext.currentTime;
+            this.masterGain.gain.cancelScheduledValues(now);
+            this.masterGain.gain.setValueAtTime(volume * volume, now);
+        }
     }
     handleExclusiveMessage(data) {
         console.warn(`Unsupported Exclusive Message ${data}`);
@@ -944,7 +893,7 @@ Object.defineProperty(MidyGMLite, "channelSettings", {
     configurable: true,
     writable: true,
     value: {
-        volume: 1,
+        volume: 100 / 127,
         pan: 0,
         vibratoRate: 5,
         vibratoDepth: 0.5,
@@ -954,7 +903,7 @@ Object.defineProperty(MidyGMLite, "channelSettings", {
         dataLSB: 0,
         program: 0,
         pitchBend: 0,
-        modulationDepthRange: 2,
+        modulationDepthRange: 0.5,
     }
 });
 Object.defineProperty(MidyGMLite, "effectSettings", {

package/script/midy.d.ts

@@ -32,9 +32,16 @@ export class Midy {
         channelPressure: number;
         pitchBendRange: number;
     };
+    static controllerDestinationSettings: {
+        pitchControl: number;
+        filterCutoffControl: number;
+        amplitudeControl: number;
+        lfoPitchDepth: number;
+        lfoFilterDepth: number;
+        lfoAmplitudeDepth: number;
+    };
     constructor(audioContext: any);
     ticksPerBeat: number;
-    secondsPerBeat: number;
     totalTime: number;
     reverbFactor: number;
     masterFineTuning: number;
@@ -61,11 +68,26 @@ export class Midy {
     channels: {
         scheduledNotes: Map<any, any>;
         sostenutoNotes: Map<any, any>;
+        polyphonicKeyPressure: {
+            pitchControl: number;
+            filterCutoffControl: number;
+            amplitudeControl: number;
+            lfoPitchDepth: number;
+            lfoFilterDepth: number;
+            lfoAmplitudeDepth: number;
+        };
+        channelPressure: {
+            pitchControl: number;
+            filterCutoffControl: number;
+            amplitudeControl: number;
+            lfoPitchDepth: number;
+            lfoFilterDepth: number;
+            lfoAmplitudeDepth: number;
+        };
         gainNode: any;
         pannerNode: any;
         modulationEffect: {
             lfo: any;
-            lfoGain: any;
         };
         reverbEffect: {
             convolverNode: any;
@@ -86,7 +108,6 @@ export class Midy {
         softPedal: number;
         rpnMSB: number;
         rpnLSB: number;
-        channelPressure: number;
         pitchBendRange: number;
         currentBufferSource: null;
         volume: number;
@@ -117,7 +138,6 @@ export class Midy {
         pannerNode: any;
         modulationEffect: {
             lfo: any;
-            lfoGain: any;
         };
         reverbEffect: {
             convolverNode: any;
@@ -134,11 +154,26 @@ export class Midy {
     createChannels(audioContext: any): {
         scheduledNotes: Map<any, any>;
         sostenutoNotes: Map<any, any>;
+        polyphonicKeyPressure: {
+            pitchControl: number;
+            filterCutoffControl: number;
+            amplitudeControl: number;
+            lfoPitchDepth: number;
+            lfoFilterDepth: number;
+            lfoAmplitudeDepth: number;
+        };
+        channelPressure: {
+            pitchControl: number;
+            filterCutoffControl: number;
+            amplitudeControl: number;
+            lfoPitchDepth: number;
+            lfoFilterDepth: number;
+            lfoAmplitudeDepth: number;
+        };
         gainNode: any;
         pannerNode: any;
         modulationEffect: {
             lfo: any;
-            lfoGain: any;
         };
         reverbEffect: {
             convolverNode: any;
@@ -159,7 +194,6 @@ export class Midy {
         softPedal: number;
         rpnMSB: number;
         rpnLSB: number;
-        channelPressure: number;
         pitchBendRange: number;
         currentBufferSource: null;
         volume: number;
@@ -205,7 +239,6 @@ export class Midy {
     getActiveChannelNotes(scheduledNotes: any): any;
     createModulationEffect(audioContext: any): {
         lfo: any;
-        lfoGain: any;
     };
     createReverbEffect(audioContext: any, options?: {}): {
         convolverNode: any;
@@ -221,23 +254,27 @@ export class Midy {
     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;
     }>;
     calcBank(channel: any, channelNumber: any): any;
     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;
     releaseNote(channelNumber: any, noteNumber: any, velocity: any): Promise<any> | undefined;
-    releaseSustainPedal(channelNumber: any): void;
-    releaseSostenuto(channelNumber: any): void;
+    releaseSustainPedal(channelNumber: any, halfVelocity: any): any[];
+    releaseSostenutoPedal(channelNumber: any, halfVelocity: any): any[];
     handleMIDIMessage(statusByte: any, data1: any, data2: any): any;
     handlePolyphonicKeyPressure(channelNumber: any, noteNumber: any, pressure: any): void;
     handleProgramChange(channelNumber: any, program: any): void;
     handleChannelPressure(channelNumber: any, pressure: any): void;
-    handlePitchBend(channelNumber: any, lsb: any, msb: any): void;
+    handlePitchBendMessage(channelNumber: any, lsb: any, msb: any): void;
+    handlePitchBend(channelNumber: any, pitchBend: any): void;
     handleControlChange(channelNumber: any, controller: any, value: any): any;
     setBankMSB(channelNumber: any, msb: any): void;
     setModulation(channelNumber: any, modulation: any): void;

package/script/midy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"midy.d.ts","sourceRoot":"","sources":["../src/midy.js"],"names":[],"mappings":"AAMA;IAyBE;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF;;;;;;;;;;;MAWE;IAEF,+BAMC;IAjED,qBAAmB;IACnB,uBAAqB;IACrB,kBAAc;IACd,qBAAmB;IACnB,yBAAqB;IACrB,2BAAuB;IACvB,cAAa;IACb,cAAa;IACb,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;IAsChB,kBAAgC;IAChC,gBAA4C;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAiD;IAInD,4BAMC;IAED,mCASC;IAED,gDAMC;IAED,sCASC;IAED;;;;;;;;;;;;;;;;;;MAuBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWC;IAED,0DAyBC;IAED,8DAUC;IAED,qDAOC;IAED,2EA6CC;IAED,mCAQC;IAED,0BA+CC;IAED,uDAEC;IAED,wDAEC;IAED;;;MA4FC;IAED,4BAsBC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBA2BC;IAED,sBAGC;IAED,4CASC;IAED,gDAKC;IAED;;;MAUC;IAED;;;;MAoCC;IAED;;;;;MA2CC;IAED,sDA2BC;IAED,2BAEC;IAED,4BAEC;IAED;;;;OAiFC;IAED,gDAQC;IAED,kGA+CC;IAED,0EAGC;IAED,sIA2CC;IAED,0FAGC;IAED,8CAuBC;IAED,2CAYC;IAED,gEAqBC;IAED,sFAeC;IAED,4DAIC;IAED,+DAEC;IAED,8DAGC;IAED,0EAkEC;IAED,+CAEC;IAED,yDAQC;IAED,iEAEC;IAED,iDAIC;IAED,2CAMC;IAED,yDAIC;IAED,+CAEC;IAED,sCAKC;IAED,sDAMC;IAED,oDAEC;IAED,iDASC;IAED,iDAIC;IAED,wDAQC;IAED,uDAIC;IAED,2DAMC;IAED,6DAMC;IAED,6DASC;IAED,4CAkBC;IAED,4CAkBC;IAED,gDAEC;IAED,gDAEC;IAGD,+DAuBC;IAED,uCAoBC;IAED,8CAEC;IAED,uCAoBC;IAED,gBAEC;IAED,eAEC;IAED,eAEC;IAED,eAEC;IAED,4DAmBC;IAED,oBAQC;IAED,oBAQC;IAED,yDAgDC;IAED,yCAGC;IAED,sCAIC;IAED,6CAGC;IAED,8CAMC;IAED,+CAGC;IAED,kDAMC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF"}
+{"version":3,"file":"midy.d.ts","sourceRoot":"","sources":["../src/midy.js"],"names":[],"mappings":"AAMA;IAwBE;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF;;;;;;;;;;;MAWE;IAEF;;;;;;;MAOE;IAEF,+BAMC;IAzED,qBAAmB;IACnB,kBAAc;IACd,qBAAmB;IACnB,yBAAqB;IACrB,2BAAuB;IACvB,cAAa;IACb,cAAa;IACb,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;IA+ChB,kBAAgC;IAChC,gBAA4C;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAiD;IAInD,4BAMC;IAED,mCASC;IAED,gDAMC;IAED,sCASC;IAED;;;;;;;;;;;;;;;;;MAuBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBC;IAED,0DAyBC;IAED,8DAUC;IAED,qDAOC;IAED,2EAyDC;IAED,mCAOC;IAED,0BA+CC;IAED,uDAEC;IAED,wDAEC;IAED;;;MA2GC;IAED,4BAsBC;IAED,uBAKC;IAED,aAGC;IAED,cAKC;IAED,wBAIC;IAED,0BAKC;IAED,wBAOC;IAED,sBAGC;IAED,4CASC;IAED,gDAKC;IAED;;MAOC;IAED;;;;MAoCC;IAED;;;;;MA2CC;IAED,sDA2BC;IAED,2BAEC;IAED,4BAEC;IAED,sCAKC;IAED,8EAEC;IAED;;;;;OAqFC;IAED,gDAQC;IAED,kGAgDC;IAED,0EAGC;IAED,sIA6CC;IAED,0FAGC;IAED,kEAeC;IAED,oEAYC;IAED,gEAqBC;IAED,sFAcC;IAED,4DAIC;IAED,+DAcC;IAED,qEAGC;IAED,0DAiBC;IAED,0EAkEC;IAED,+CAEC;IAED,yDAIC;IAED,iEAEC;IAED,iDAIC;IAED,2CAMC;IAED,yDAIC;IAED,+CAEC;IAED,sCAKC;IAED,sDAMC;IAED,oDAEC;IAED,iDASC;IAED,iDAIC;IAED,wDAUC;IAED,uDAGC;IAED,2DAOC;IAED,6DAOC;IAED,6DASC;IAED,4CAkBC;IAED,4CAkBC;IAED,gDAEC;IAED,gDAEC;IAGD,+DAuBC;IAED,uCAoBC;IAED,8CAEC;IAED,uCAoBC;IAED,gBAEC;IAED,eAEC;IAED,eAEC;IAED,eAEC;IAED,4DAmBC;IAED,oBAQC;IAED,oBAQC;IAED,yDAgDC;IAED,yCAGC;IAED,sCAQC;IAED,6CAGC;IAED,8CAMC;IAED,+CAGC;IAED,kDAMC;IAED,wCAEC;IAED,6BASC;IAED,0DAUC;CACF"}