spessasynth_lib 3.24.28 → 3.24.35

package/midi_parser/used_keys_loaded.js

@@ -1,20 +1,22 @@
 import { SpessaSynthGroupCollapsed, SpessaSynthGroupEnd, SpessaSynthInfo } from "../utils/loggin.js";
 import { consoleColors } from "../utils/other.js";
-import { DEFAULT_PERCUSSION } from "../synthetizer/synthetizer.js";
 import { messageTypes, midiControllers } from "./midi_message.js";
+import { DEFAULT_PERCUSSION } from "../synthetizer/synth_constants.js";
 
 /**
- * @param mid {BasicMIDI}
- * @param soundfont {{getPreset: function(number, number): BasicPreset}}
+ * Gets the used programs and keys for this MIDI file with a given sound bank
+ * @this {BasicMIDI}
+ * @param soundfont {{getPreset: function(number, number): BasicPreset}} - the sound bank
  * @returns {Object<string, Set<string>>}
  */
-export function getUsedProgramsAndKeys(mid, soundfont)
+export function getUsedProgramsAndKeys(soundfont)
 {
+    const mid = this;
     SpessaSynthGroupCollapsed(
         "%cSearching for all used programs and keys...",
         consoleColors.info
     );
-    // find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
+    // Find every bank:program combo and every key:velocity for each. Make sure to care about ports and drums
     const channelsAmount = 16 + mid.midiPortChannelOffsets.reduce((max, cur) => cur > max ? cur : max);
     /**
      * @type {{program: number, bank: number, drums: boolean, string: string}[]}
@@ -152,7 +154,7 @@ export function getUsedProgramsAndKeys(mid, soundfont)
                     continue;
                 }
                 channelPresets[channel].bank = realBank;
-                // do not update the data, bank change doesnt change the preset
+                // do not update the data, bank change doesn't change the preset
                 break;
             
             case messageTypes.noteOn:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.24.28",
+  "version": "3.24.35",
   "description": "MIDI and SoundFont2/DLS library with no compromises",
   "browser": "index.js",
   "type": "module",

package/sequencer/sequencer.js

@@ -8,7 +8,7 @@ import {
     WorkletSequencerReturnMessageType
 } from "./worklet_sequencer/sequencer_message.js";
 import { SpessaSynthWarn } from "../utils/loggin.js";
-import { DUMMY_MIDI_DATA, MidiData } from "../midi_parser/midi_data.js";
+import { DUMMY_MIDI_DATA, MIDIData } from "../midi_parser/midi_data.js";
 import { BasicMIDI } from "../midi_parser/basic_midi.js";
 import { readBytesAsUintBigEndian } from "../utils/byte_functions/big_endian.js";
 import { IndexedByteArray } from "../utils/indexed_array.js";
@@ -68,12 +68,12 @@ export class Sequencer
     
     /**
      * The sequence's data, except for the track data.
-     *  @type {MidiData}
+     *  @type {MIDIData}
      */
     midiData;
     
     /**
-     * @type {Object<string, function(MidiData)>}
+     * @type {Object<string, function(MIDIData)>}
      * @private
      */
     onSongChange = {};
@@ -398,7 +398,7 @@ export class Sequencer
     
     /**
      * Adds a new event that gets called when the song changes
-     * @param callback {function(MidiData)}
+     * @param callback {function(MIDIData)}
      * @param id {string} must be unique
      */
     addOnSongChangeEvent(callback, id)
@@ -538,8 +538,8 @@ export class Sequencer
             
             case WorkletSequencerReturnMessageType.songChange:
                 /**
-                 * messageData is expected to be {MidiData}
-                 * @type {MidiData}
+                 * messageData is expected to be {MIDIData}
+                 * @type {MIDIData}
                  */
                 let songChangeData = messageData[0];
                 this.songIndex = messageData[1];

package/sequencer/worklet_sequencer/events.js

@@ -4,7 +4,8 @@ import {
 } from "../../synthetizer/worklet_system/message_protocol/worklet_message.js";
 import { SongChangeType, WorkletSequencerMessageType, WorkletSequencerReturnMessageType } from "./sequencer_message.js";
 import { messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
-import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
+
+import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
 
 /**
  * @param messageType {WorkletSequencerMessageType}

package/sequencer/worklet_sequencer/play.js

@@ -1,6 +1,5 @@
 import { getEvent, messageTypes, midiControllers } from "../../midi_parser/midi_message.js";
 import { WorkletSequencerReturnMessageType } from "./sequencer_message.js";
-import { MIDIticksToSeconds } from "../../midi_parser/basic_midi.js";
 import { resetArray } from "../../synthetizer/worklet_system/worklet_utilities/controller_tables.js";
 import {
     nonResetableCCs
@@ -158,7 +157,7 @@ export function _playTo(time, ticks = undefined)
                     }
                     else if (controllerNumber === midiControllers.resetAllControllers)
                     {
-                        resetAllControlllers(savedControllers[channel]);
+                        resetAllControlllers(channel);
                     }
                     if (this.sendMIDIMessages)
                     {
@@ -324,7 +323,7 @@ export function setTimeTicks(ticks)
     this.pausedTime = undefined;
     this.post(
         WorkletSequencerReturnMessageType.timeChange,
-        currentTime - MIDIticksToSeconds(ticks, this.midiData)
+        currentTime - this.midiData.MIDIticksToSeconds(ticks)
     );
     const isNotFinished = this._playTo(0, ticks);
     this._recalculateStartTime(this.playedTime);

package/sequencer/worklet_sequencer/process_event.js

@@ -6,7 +6,7 @@ import { readBytesAsUintBigEndian } from "../../utils/byte_functions/big_endian.
 
 /**
  * Processes a single event
- * @param event {MidiMessage}
+ * @param event {MIDIMessage}
  * @param trackIndex {number}
  * @this {WorkletSequencer}
  * @private

package/sequencer/worklet_sequencer/process_tick.js

@@ -55,7 +55,7 @@ export function processTick()
             this.setTimeTicks(this.midiData.loop.start);
             return;
         }
-        // if the song has endeed
+        // if the song has ended
         else if (current >= this.duration)
         {
             if (canLoop)

package/sequencer/worklet_sequencer/sequencer_message.js

@@ -41,7 +41,7 @@ export const WorkletSequencerMessageType = {
  */
 export const WorkletSequencerReturnMessageType = {
     midiEvent: 0,               // [...midiEventBytes<number>]
-    songChange: 1,              // [midiData<MidiData>, songIndex<number>, isAutoPlayed<boolean>]
+    songChange: 1,              // [midiData<MIDIData>, songIndex<number>, isAutoPlayed<boolean>]
     textEvent: 2,               // [messageData<number[]>, statusByte<number>, lyricsIndex<number>]
     timeChange: 3,              // newAbsoluteTime<number>
     pause: 4,                   // no data

package/sequencer/worklet_sequencer/song_control.js

@@ -6,10 +6,9 @@ import {
     SpessaSynthInfo,
     SpessaSynthWarn
 } from "../../utils/loggin.js";
-import { MidiData } from "../../midi_parser/midi_data.js";
+import { MIDIData } from "../../midi_parser/midi_data.js";
 import { MIDI } from "../../midi_parser/midi_loader.js";
-import { getUsedProgramsAndKeys } from "../../midi_parser/used_keys_loaded.js";
-import { MIDIticksToSeconds } from "../../midi_parser/basic_midi.js";
+
 
 /**
  * @param trackNum {number}
@@ -80,7 +79,7 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
         }
         SpessaSynthGroupCollapsed("%cPreloading samples...", consoleColors.info);
         // smart preloading: load only samples used in the midi!
-        const used = getUsedProgramsAndKeys(this.midiData, this.synth.soundfontManager);
+        const used = this.midiData.getUsedProgramsAndKeys(this.synth.soundfontManager);
         for (const [programBank, combos] of Object.entries(used))
         {
             const bank = parseInt(programBank.split(":")[0]);
@@ -103,7 +102,7 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
     
     /**
      * the midi track data
-     * @type {MidiMessage[][]}
+     * @type {MIDIMessage[][]}
      */
     this.tracks = this.midiData.tracks;
     
@@ -124,10 +123,10 @@ export function loadNewSequence(parsedMidi, autoPlay = true)
      * @type {number}
      */
     this.duration = this.midiData.duration;
-    this.firstNoteTime = MIDIticksToSeconds(this.midiData.firstNoteOn, this.midiData);
+    this.firstNoteTime = this.midiData.MIDIticksToSeconds(this.midiData.firstNoteOn);
     SpessaSynthInfo(`%cTotal song time: ${formatTime(Math.ceil(this.duration)).time}`, consoleColors.recognized);
     
-    this.post(WorkletSequencerReturnMessageType.songChange, [new MidiData(this.midiData), this.songIndex, autoPlay]);
+    this.post(WorkletSequencerReturnMessageType.songChange, [new MIDIData(this.midiData), this.songIndex, autoPlay]);
     
     if (this.duration <= 1)
     {

package/sequencer/worklet_sequencer/worklet_sequencer.js

@@ -14,7 +14,8 @@ import {
     sendMIDIReset
 } from "./events.js";
 import { SpessaSynthWarn } from "../../utils/loggin.js";
-import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synthetizer.js";
+
+import { MIDI_CHANNEL_COUNT } from "../../synthetizer/synth_constants.js";
 
 class WorkletSequencer
 {

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -1,4 +1,10 @@
-import { SpessaSynthWarn } from "../../utils/loggin.js";
+import {
+    SpessaSynthGroup,
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo,
+    SpessaSynthWarn
+} from "../../utils/loggin.js";
 import { consoleColors } from "../../utils/other.js";
 import { write } from "./write_sf2/write.js";
 import { defaultModulators, Modulator } from "./modulator.js";
@@ -9,7 +15,7 @@ import { Generator, generatorTypes } from "./generator.js";
 import { BasicInstrument } from "./basic_instrument.js";
 import { BasicPreset } from "./basic_preset.js";
 
-class BasicSoundFont
+class BasicSoundBank
 {
     /**
      * Creates a new basic soundfont template
@@ -18,7 +24,7 @@ class BasicSoundFont
     constructor(data = undefined)
     {
         /**
-         * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g. 2.1)
+         * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g., 2.1)
          * @type {Object<string, string|IndexedByteArray>}
          */
         this.soundFontInfo = {};
@@ -56,10 +62,10 @@ class BasicSoundFont
     
     /**
      * Merges soundfonts with the given order. Keep in mind that the info read is copied from the first one
-     * @param soundfonts {...BasicSoundFont} the soundfonts to merge, the first overwrites the last
-     * @returns {BasicSoundFont}
+     * @param soundfonts {...BasicSoundBank} the soundfonts to merge, the first overwrites the last
+     * @returns {BasicSoundBank}
      */
-    static mergeSoundfonts(...soundfonts)
+    static mergeSoundBanks(...soundfonts)
     {
         const mainSf = soundfonts.shift();
         const presets = mainSf.presets;
@@ -77,7 +83,7 @@ class BasicSoundFont
             });
         }
         
-        return new BasicSoundFont({ presets: presets, info: mainSf.soundFontInfo });
+        return new BasicSoundBank({ presets: presets, info: mainSf.soundFontInfo });
     }
     
     /**
@@ -86,7 +92,7 @@ class BasicSoundFont
      */
     static getDummySoundfontFile()
     {
-        const font = new BasicSoundFont();
+        const font = new BasicSoundBank();
         const sample = new BasicSample(
             "Saw",
             44100,
@@ -139,6 +145,184 @@ class BasicSoundFont
         return font.write().buffer;
     }
     
+    /**
+     * Trims a sound bank to only contain samples in a given MIDI file
+     * @param mid {BasicMIDI} - the MIDI file
+     */
+    trimSoundBank(mid)
+    {
+        const soundfont = this;
+        
+        /**
+         * @param instrument {Instrument}
+         * @param combos {{key: number, velocity: number}[]}
+         * @returns {number}
+         */
+        function trimInstrumentZones(instrument, combos)
+        {
+            let trimmedIZones = 0;
+            for (let iZoneIndex = 0; iZoneIndex < instrument.instrumentZones.length; iZoneIndex++)
+            {
+                const iZone = instrument.instrumentZones[iZoneIndex];
+                if (iZone.isGlobal)
+                {
+                    continue;
+                }
+                const iKeyRange = iZone.keyRange;
+                const iVelRange = iZone.velRange;
+                let isIZoneUsed = false;
+                for (const iCombo of combos)
+                {
+                    if (
+                        (iCombo.key >= iKeyRange.min && iCombo.key <= iKeyRange.max) &&
+                        (iCombo.velocity >= iVelRange.min && iCombo.velocity <= iVelRange.max)
+                    )
+                    {
+                        isIZoneUsed = true;
+                        break;
+                    }
+                }
+                if (!isIZoneUsed)
+                {
+                    SpessaSynthInfo(
+                        `%c${iZone.sample.sampleName} %cremoved from %c${instrument.instrumentName}%c. Use count: %c${iZone.useCount - 1}`,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.recognized
+                    );
+                    if (instrument.safeDeleteZone(iZoneIndex))
+                    {
+                        trimmedIZones++;
+                        iZoneIndex--;
+                        SpessaSynthInfo(
+                            `%c${iZone.sample.sampleName} %cdeleted`,
+                            consoleColors.recognized,
+                            consoleColors.info
+                        );
+                    }
+                    if (iZone.sample.useCount < 1)
+                    {
+                        soundfont.deleteSample(iZone.sample);
+                    }
+                }
+                
+            }
+            return trimmedIZones;
+        }
+        
+        SpessaSynthGroup(
+            "%cTrimming soundfont...",
+            consoleColors.info
+        );
+        const usedProgramsAndKeys = mid.getUsedProgramsAndKeys(soundfont);
+        
+        SpessaSynthGroupCollapsed(
+            "%cModifying soundfont...",
+            consoleColors.info
+        );
+        SpessaSynthInfo("Detected keys for midi:", usedProgramsAndKeys);
+        // modify the soundfont to only include programs and samples that are used
+        for (let presetIndex = 0; presetIndex < soundfont.presets.length; presetIndex++)
+        {
+            const p = soundfont.presets[presetIndex];
+            const string = p.bank + ":" + p.program;
+            const used = usedProgramsAndKeys[string];
+            if (used === undefined)
+            {
+                SpessaSynthInfo(
+                    `%cDeleting preset %c${p.presetName}%c and its zones`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info
+                );
+                soundfont.deletePreset(p);
+                presetIndex--;
+            }
+            else
+            {
+                const combos = [...used].map(s =>
+                {
+                    const split = s.split("-");
+                    return {
+                        key: parseInt(split[0]),
+                        velocity: parseInt(split[1])
+                    };
+                });
+                SpessaSynthGroupCollapsed(
+                    `%cTrimming %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthInfo(`Keys for ${p.presetName}:`, combos);
+                let trimmedZones = 0;
+                // clean the preset to only use zones that are used
+                for (let zoneIndex = 0; zoneIndex < p.presetZones.length; zoneIndex++)
+                {
+                    const zone = p.presetZones[zoneIndex];
+                    if (zone.isGlobal)
+                    {
+                        continue;
+                    }
+                    const keyRange = zone.keyRange;
+                    const velRange = zone.velRange;
+                    // check if any of the combos matches the zone
+                    let isZoneUsed = false;
+                    for (const combo of combos)
+                    {
+                        if (
+                            (combo.key >= keyRange.min && combo.key <= keyRange.max) &&
+                            (combo.velocity >= velRange.min && combo.velocity <= velRange.max)
+                        )
+                        {
+                            // zone is used, trim the instrument zones
+                            isZoneUsed = true;
+                            const trimmedIZones = trimInstrumentZones(zone.instrument, combos);
+                            SpessaSynthInfo(
+                                `%cTrimmed off %c${trimmedIZones}%c zones from %c${zone.instrument.instrumentName}`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.recognized
+                            );
+                            break;
+                        }
+                    }
+                    if (!isZoneUsed)
+                    {
+                        trimmedZones++;
+                        p.deleteZone(zoneIndex);
+                        if (zone.instrument.useCount < 1)
+                        {
+                            soundfont.deleteInstrument(zone.instrument);
+                        }
+                        zoneIndex--;
+                    }
+                }
+                SpessaSynthInfo(
+                    `%cTrimmed off %c${trimmedZones}%c zones from %c${p.presetName}`,
+                    consoleColors.info,
+                    consoleColors.recognized,
+                    consoleColors.info,
+                    consoleColors.recognized
+                );
+                SpessaSynthGroupEnd();
+            }
+        }
+        soundfont.removeUnusedElements();
+        
+        soundfont.soundFontInfo["ICMT"] = `NOTE: This soundfont was trimmed by SpessaSynth to only contain presets used in "${mid.midiName}"\n\n`
+            + soundfont.soundFontInfo["ICMT"];
+        
+        SpessaSynthInfo(
+            "%cSoundfont modified!",
+            consoleColors.recognized
+        );
+        SpessaSynthGroupEnd();
+        SpessaSynthGroupEnd();
+    }
+    
     removeUnusedElements()
     {
         this.instruments.forEach(i =>
@@ -254,7 +438,7 @@ class BasicSoundFont
             }
             else
             {
-                // non drum preset: find any preset with the given program that is not a drum preset
+                // non-drum preset: find any preset with the given program that is not a drum preset
                 preset = this.presets.find(p => p.program === programNr && p.bank !== 128);
             }
             if (preset)
@@ -299,7 +483,7 @@ class BasicSoundFont
         throw new Error(`SF parsing error: ${error} The file may be corrupted.`);
     }
     
-    destroySoundfont()
+    destroySoundBank()
     {
         delete this.presets;
         delete this.instruments;
@@ -307,7 +491,7 @@ class BasicSoundFont
     }
 }
 
-BasicSoundFont.prototype.write = write;
-BasicSoundFont.prototype.writeDLS = writeDLS;
+BasicSoundBank.prototype.write = write;
+BasicSoundBank.prototype.writeDLS = writeDLS;
 
-export { BasicSoundFont };
+export { BasicSoundBank };

package/soundfont/basic_soundfont/generator.js

@@ -7,7 +7,7 @@ export const generatorTypes = {
     endAddrOffset: 1,                   // sample control - moves sample end point
     startloopAddrsOffset: 2,            // loop control - moves loop start point
     endloopAddrsOffset: 3,              // loop control - moves loop end point
-    startAddrsCoarseOffset: 4,          // sample control - moves sample start point in 32768 increments
+    startAddrsCoarseOffset: 4,          // sample control - moves sample start point in 32,768 increments
     modLfoToPitch: 5,                   // pitch modulation - modulation lfo pitch modulation in cents
     vibLfoToPitch: 6,                   // pitch modulation - vibrato lfo pitch modulation in cents
     modEnvToPitch: 7,                   // pitch modulation - modulation envelope pitch modulation in cents
@@ -15,7 +15,7 @@ export const generatorTypes = {
     initialFilterQ: 9,                  // filter - lowpass filter resonance
     modLfoToFilterFc: 10,               // filter modulation - modulation lfo lowpass filter cutoff in cents
     modEnvToFilterFc: 11,               // filter modulation - modulation envelope lowpass filter cutoff in cents
-    endAddrsCoarseOffset: 12,           // ample control - moves sample end point in 32768 increments
+    endAddrsCoarseOffset: 12,           // ample control - move sample end point in 32,768 increments
     modLfoToVolume: 13,                 // modulation lfo - volume (tremolo), where 100 = 10dB
     unused1: 14,                        // unused
     chorusEffectsSend: 15,              // effect send - how much is sent to chorus 0 - 1000
@@ -24,11 +24,11 @@ export const generatorTypes = {
     unused2: 18,                        // unused
     unused3: 19,                        // unused
     unused4: 20,                        // unused
-    delayModLFO: 21,                    // mod lfo - delay for mod lfo to start from zero (weird scale)
-    freqModLFO: 22,                     // mod lfo - frequency of mod lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
-    delayVibLFO: 23,                    // vib lfo - delay for vibrato lfo to start from zero (weird scale)
+    delayModLFO: 21,                    // mod lfo - delay for mod lfo to start from zero
+    freqModLFO: 22,                     // mod lfo - frequency of mod lfo, 0 = 8.176 Hz, units: f => 1200log2(f/8.176)
+    delayVibLFO: 23,                    // vib lfo - delay for vibrato lfo to start from zero
     freqVibLFO: 24,                     // vib lfo - frequency of vibrato lfo, 0 = 8.176Hz, unit: f => 1200log2(f/8.176)
-    delayModEnv: 25,                    // mod env - 0 = 1s declay till mod env starts
+    delayModEnv: 25,                    // mod env - 0 = 1 s decay till mod env starts
     attackModEnv: 26,                   // mod env - attack of mod env
     holdModEnv: 27,                     // mod env - hold of mod env
     decayModEnv: 28,                    // mod env - decay of mod env
@@ -48,16 +48,16 @@ export const generatorTypes = {
     reserved1: 42,                      // reserved
     keyRange: 43,                       // zone - key range for which preset / instrument zone is active
     velRange: 44,                       // zone - velocity range for which preset / instrument zone is active
-    startloopAddrsCoarseOffset: 45,     // sample control - moves sample loop start point in 32768 increments
+    startloopAddrsCoarseOffset: 45,     // sample control - moves sample loop start point in 32,768 increments
     keyNum: 46,                         // zone - instrument only: always use this midi number (ignore what's pressed)
     velocity: 47,                       // zone - instrument only: always use this velocity (ignore what's pressed)
     initialAttenuation: 48,             // zone - allows turning down the volume, 10 = -1dB
     reserved2: 49,                      // reserved
-    endloopAddrsCoarseOffset: 50,       // sample control - moves sample loop end point in 32768 increments
+    endloopAddrsCoarseOffset: 50,       // sample control - moves sample loop end point in 32,768 increments
     coarseTune: 51,                     // tune - pitch offset in semitones
     fineTune: 52,                       // tune - pitch offset in cents
     sampleID: 53,                       // sample - instrument zone only: which sample to use
-    sampleModes: 54,                    // sample - 0 = no loop, 1 = loop, 2 = reserved, 3 = loop and play till end in release phase
+    sampleModes: 54,                    // sample - 0 = no loop, 1 = loop, 2 = reserved, 3 = loop and play till the end in release phase
     reserved3: 55,                      // reserved
     scaleTuning: 56,                    // sample - the degree to which MIDI key number influences pitch, 100 = default
     exclusiveClass: 57,                 // sample - = cut = choke group
@@ -103,13 +103,14 @@ generatorLimits[generatorTypes.delayVibLFO] = { min: -12000, max: 5000, def: -12
 generatorLimits[generatorTypes.freqVibLFO] = { min: -16000, max: 4500, def: 0 };
 
 // mod env
-generatorLimits[generatorTypes.delayModEnv] = { min: -32768, max: 5000, def: -32768 }; // -32768 indicates instant phase, this is done to prevent click at the start of filter modenv
+generatorLimits[generatorTypes.delayModEnv] = { min: -32768, max: 5000, def: -32768 }; // -32,768 indicates instant phase,
+// this is done to prevent click at the start of filter modenv
 generatorLimits[generatorTypes.attackModEnv] = { min: -32768, max: 8000, def: -32768 };
 generatorLimits[generatorTypes.holdModEnv] = { min: -12000, max: 5000, def: -12000 };
 generatorLimits[generatorTypes.decayModEnv] = { min: -12000, max: 8000, def: -12000 };
 generatorLimits[generatorTypes.sustainModEnv] = { min: 0, max: 1000, def: 0 };
 generatorLimits[generatorTypes.releaseModEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 to prevent lowpass clicks
-// keynum to mod env
+// key num to mod env
 generatorLimits[generatorTypes.keyNumToModEnvHold] = { min: -1200, max: 1200, def: 0 };
 generatorLimits[generatorTypes.keyNumToModEnvDecay] = { min: -1200, max: 1200, def: 0 };
 
@@ -119,8 +120,8 @@ generatorLimits[generatorTypes.attackVolEnv] = { min: -12000, max: 8000, def: -1
 generatorLimits[generatorTypes.holdVolEnv] = { min: -12000, max: 5000, def: -12000 };
 generatorLimits[generatorTypes.decayVolEnv] = { min: -12000, max: 8000, def: -12000 };
 generatorLimits[generatorTypes.sustainVolEnv] = { min: 0, max: 1440, def: 0 };
-generatorLimits[generatorTypes.releaseVolEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200  prevent clicks
-// keynum to vol env
+generatorLimits[generatorTypes.releaseVolEnv] = { min: -7200, max: 8000, def: -12000 }; // min is set to -7200 prevent clicks
+// key num to vol env
 generatorLimits[generatorTypes.keyNumToVolEnvHold] = { min: -1200, max: 1200, def: 0 };
 generatorLimits[generatorTypes.keyNumToVolEnvDecay] = { min: -1200, max: 1200, def: 0 };
 
@@ -128,7 +129,7 @@ generatorLimits[generatorTypes.startloopAddrsCoarseOffset] = { min: -32768, max:
 generatorLimits[generatorTypes.keyNum] = { min: -1, max: 127, def: -1 };
 generatorLimits[generatorTypes.velocity] = { min: -1, max: 127, def: -1 };
 
-generatorLimits[generatorTypes.initialAttenuation] = { min: -250, max: 1440, def: 0 }; // soundblaster allows 10dB of gain (divide by 0.4)
+generatorLimits[generatorTypes.initialAttenuation] = { min: -250, max: 1440, def: 0 }; // sound blaster allows 10dB of gain (divide by 0.4)
 
 generatorLimits[generatorTypes.endloopAddrsCoarseOffset] = { min: -32768, max: 32768, def: 0 };
 
@@ -180,7 +181,8 @@ export class Generator
 
 /**
  * generator.js
- * purpose: contains enums for generators and their limis parses reads soundfont generators, sums them and applies limits
+ * purpose: contains enums for generators,
+ * and their limis parses reads soundfont generators, sums them and applies limits
  */
 /**
  * @param generatorType {number}
@@ -206,7 +208,7 @@ export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
     
     let value = instruValue + presetValue;
     
-    // special case, intial attenuation.
+    // Special case, initial attenuation.
     // Shall get clamped in the volume envelope,
     // so the modulators can be affected by negative generators (the "Brass" patch was problematic...)
     if (generatorType === generatorTypes.initialAttenuation)

package/soundfont/basic_soundfont/modulator.js

@@ -372,4 +372,7 @@ const customModulators = [
     )
 ];
 
+/**
+ * @type {Modulator[]}
+ */
 export const defaultModulators = soundFontModulators.concat(customModulators);

package/soundfont/basic_soundfont/riff_chunk.js

@@ -74,7 +74,7 @@ export function writeRIFFChunk(chunk, prepend = undefined)
         size += prepend.length;
     }
     const array = new IndexedByteArray(size);
-    // prepend data (for example type before the read)
+    // prepend data (for example, type before the read)
     if (prepend)
     {
         array.set(prepend, array.currentIndex);
@@ -82,7 +82,7 @@ export function writeRIFFChunk(chunk, prepend = undefined)
     }
     // write header
     writeStringAsBytes(array, chunk.header);
-    // write size (excluding header and the size itself) and the prepend if specified
+    // write size (excluding header and the size itself) and then prepend if specified
     writeDword(array, size - 8 - (prepend?.length || 0));
     // write data
     array.set(chunk.chunkData, array.currentIndex);

package/soundfont/basic_soundfont/write_dls/art2.js

@@ -66,7 +66,7 @@ export function writeArticulator(zone)
     
     // read_articulation.js:
     // according to viena and another strange (with modulators) rendition of gm.dls in sf2,
-    // it shall be divided by -128
+    // it shall be divided by -128,
     // and a strange correction needs to be applied to the real value:
     // real + (60 / 128) * scale
     // we invert this here