spessasynth_core 4.4.5 → 4.4.7

package/dist/index.js

@@ -90,7 +90,6 @@ function readLittleEndian(dataArray, bytesAmount, offset = 0) {
 * @param dataArray the IndexedByteArray to write to.
 * @param number the number to write.
 * @param byteTarget the amount of bytes to use. Excess bytes will be set to zero.
-* @returns the little endian representation of the number.
 */
 function writeLittleEndianIndexed(dataArray, number, byteTarget) {
 	for (let i = 0; i < byteTarget; i++) dataArray[dataArray.currentIndex++] = number >> i * 8 & 255;
@@ -359,8 +358,8 @@ var RIFFChunk = class RIFFChunk {
 	* Writes a RIFF chunk correctly.
 	* @param header the fourCC code of the header.
 	* @param data the binary chunk data.
-	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @param rf64 if the chunk uses a 64-bit size.
+	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @returns the binary data.
 	*/
 	static write(header, data, rf64 = false, isList = false) {
@@ -391,8 +390,8 @@ var RIFFChunk = class RIFFChunk {
 	* This allows avoiding large array allocations and only one writeParts call at the end.
 	* @param header  the fourCC code of the header.
 	* @param chunks binary chunk data parts, will be combined in order.
-	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @param rf64 if the chunk uses a 64-bit size.
+	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @returns the chunk as binary blobs.
 	*/
 	static getParts(header, chunks, rf64 = false, isList = false) {
@@ -421,8 +420,8 @@ var RIFFChunk = class RIFFChunk {
 	* It merges them together into data and allocates one large array.
 	* @param header  the fourCC code of the header.
 	* @param chunks binary chunk data parts, will be combined in order.
-	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @param rf64 if the chunk uses a 64-bit size.
+	* @param isList if a "LIST" should be set as the chunk type and the actual type should be written at the start of the data.
 	* @returns the binary data.
 	*/
 	static writeParts(header, chunks, rf64 = false, isList = false) {
@@ -673,8 +672,9 @@ var SpessaLog = class {
 	/**
 	* Enables or disables logging at various levels.
 	* All the input variables are booleans corresponding to the things SpessaSynth logs.
-	* @param enableInfo enables info: all general info such as parsing sound banks, MIDI files, RPN changes, etc.
-	* @param enableWarn enables warning: all messages unrecognized by the synthesizer, other warnings.
+	* @param enableInfo enables info: all general info such as parsing sound banks, MIDI files, RPN changes,
+	* messages unrecognized by the synthesizer, etc.
+	* @param enableWarn enables warning: unexpected and erroneous behavior, such as invalid data or missing presets.
 	* @param enableGroup enables groups: the groups for parsing the sound banks and MIDI files.
 	*/
 	static setLogLevel(enableInfo, enableWarn, enableGroup) {
@@ -831,7 +831,7 @@ const MIDIMessageTypes = {
 	sequenceSpecific: 127
 };
 /**
-* All MIDI 1.0 controller values.
+* All MIDI 1.0 controller numbers.
 *
 * > **Tip**
 * >
@@ -888,10 +888,10 @@ const MIDIControllers = {
 	effectControl2LSB: 45,
 	undefinedCC14LSB: 46,
 	undefinedCC15LSB: 47,
-	undefinedCC16LSB: 48,
-	undefinedCC17LSB: 49,
-	undefinedCC18LSB: 50,
-	undefinedCC19LSB: 51,
+	generalPurposeController1LSB: 48,
+	generalPurposeController2LSB: 49,
+	generalPurposeController3LSB: 50,
+	generalPurposeController4LSB: 51,
 	undefinedCC20LSB: 52,
 	undefinedCC21LSB: 53,
 	undefinedCC22LSB: 54,
@@ -942,32 +942,120 @@ const MIDIControllers = {
 	nonRegisteredParameterMSB: 99,
 	registeredParameterLSB: 100,
 	registeredParameterMSB: 101,
+	undefinedCC102: 102,
+	undefinedCC103: 103,
+	undefinedCC104: 104,
+	undefinedCC105: 105,
+	undefinedCC106: 106,
+	undefinedCC107: 107,
+	undefinedCC108: 108,
+	undefinedCC109: 109,
+	undefinedCC110: 110,
+	undefinedCC111: 111,
+	undefinedCC112: 112,
+	undefinedCC113: 113,
+	undefinedCC114: 114,
+	undefinedCC115: 115,
+	undefinedCC116: 116,
+	undefinedCC117: 117,
+	undefinedCC118: 118,
+	undefinedCC119: 119,
+	allSoundOff: 120,
+	resetAllControllers: 121,
+	localControlOnOff: 122,
+	allNotesOff: 123,
+	omniModeOff: 124,
+	omniModeOn: 125,
+	monoModeOn: 126,
+	polyModeOn: 127,
+	/**
+	* @deprecated Use {@link MIDIControllers.generalPurposeController1LSB} instead.
+	*/
+	undefinedCC16LSB: 48,
+	/**
+	* @deprecated Use {@link MIDIControllers.generalPurposeController2LSB} instead.
+	*/
+	undefinedCC17LSB: 49,
+	/**
+	* @deprecated Use {@link MIDIControllers.generalPurposeController3LSB} instead.
+	*/
+	undefinedCC18LSB: 50,
+	/**
+	* @deprecated Use {@link MIDIControllers.generalPurposeController4LSB} instead.
+	*/
+	undefinedCC19LSB: 51,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC102} instead.
+	*/
 	undefinedCC102LSB: 102,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC103} instead.
+	*/
 	undefinedCC103LSB: 103,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC104} instead.
+	*/
 	undefinedCC104LSB: 104,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC105} instead.
+	*/
 	undefinedCC105LSB: 105,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC106} instead.
+	*/
 	undefinedCC106LSB: 106,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC107} instead.
+	*/
 	undefinedCC107LSB: 107,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC108} instead.
+	*/
 	undefinedCC108LSB: 108,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC109} instead.
+	*/
 	undefinedCC109LSB: 109,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC110} instead.
+	*/
 	undefinedCC110LSB: 110,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC111} instead.
+	*/
 	undefinedCC111LSB: 111,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC112} instead.
+	*/
 	undefinedCC112LSB: 112,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC113} instead.
+	*/
 	undefinedCC113LSB: 113,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC114} instead.
+	*/
 	undefinedCC114LSB: 114,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC115} instead.
+	*/
 	undefinedCC115LSB: 115,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC116} instead.
+	*/
 	undefinedCC116LSB: 116,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC117} instead.
+	*/
 	undefinedCC117LSB: 117,
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC118} instead.
+	*/
 	undefinedCC118LSB: 118,
-	undefinedCC119LSB: 119,
-	allSoundOff: 120,
-	resetAllControllers: 121,
-	localControlOnOff: 122,
-	allNotesOff: 123,
-	omniModeOff: 124,
-	omniModeOn: 125,
-	monoModeOn: 126,
-	polyModeOn: 127
+	/**
+	* @deprecated Use {@link MIDIControllers.undefinedCC119} instead.
+	*/
+	undefinedCC119LSB: 119
 };
 /**
 * General MIDI Registered Parameter Numbers.
@@ -1024,7 +1112,7 @@ const NonRegisteredParameterTypesLSB = {
 // src/midi/midi_message.ts
 /**
 * Midi_message.ts
-* purpose: contains enums for midi events and controllers and functions to parse them
+* purpose: contains the MIDIMessage class and functions to create common messages
 */
 /**
 * This class represents a single MIDI 1.0 message.
@@ -1251,7 +1339,7 @@ const EMBEDDED_SOUND_BANK_ID = `SPESSASYNTH_EMBEDDED_BANK_${Math.random()}_DO_NO
 const GENERATOR_OVERRIDE_NO_CHANGE_VALUE = 32767;
 const DEFAULT_SYNTH_METHOD_OPTIONS = { time: 0 };
 /**
-* If the note is released faster than that, it forced to last that long
+* If the note is released faster than that, it is forced to last that long
 * This is used mostly for drum channels, where a lot of midis like to send instant note off after a note on
 * @internal
 */
@@ -1900,13 +1988,13 @@ const GeneratorLimits = Object.freeze({
 	},
 	[GeneratorTypes.vibLfoWaveform]: {
 		min: 0,
-		max: 1,
+		max: 2,
 		def: 0,
 		nrpn: 0
 	},
 	[GeneratorTypes.modLfoWaveform]: {
 		min: 0,
-		max: 1,
+		max: 2,
 		def: 0,
 		nrpn: 0
 	},
@@ -2051,7 +2139,7 @@ const ModulatorControllerSources = {
 	*/
 	pitchWheel: 14,
 	/**
-	* The current pitch wheel range (where 1 means 127 semitones) on the channel.
+	* The current pitch wheel range (where 1 means 128 semitones) on the channel.
 	*/
 	pitchWheelRange: 16,
 	/**
@@ -2074,7 +2162,7 @@ const ModulatorCurveTypes = {
 	*/
 	concave: 1,
 	/**
-	* Inverse of concave.
+	* Exponential ramp, the inverse of concave.
 	*/
 	convex: 2,
 	/**
@@ -2136,6 +2224,7 @@ DEFAULT_DRUM_REVERB[36] = 0;
 * Reset all controllers for channel.
 * This will reset all controllers to their default values,
 * except for the locked controllers.
+* @param sendCCEvents If controller change events should be emitted for the reset controllers.
 */
 function resetChannelInternal(sendCCEvents = true) {
 	for (let cc = 0; cc < 128; cc++) {
@@ -2157,6 +2246,7 @@ function resetChannelInternal(sendCCEvents = true) {
 	this.resetMIDIParameter("modulationDepth");
 	this.resetMIDIParameter("rxChannel");
 	this.resetMIDIParameter("efxAssign");
+	this.resetMIDIParameter("eqEnabled");
 	this.resetMIDIParameter("polyMode");
 	this.resetMIDIParameter("keyShift");
 	this.resetMIDIParameter("fineTune");
@@ -2170,6 +2260,7 @@ function resetChannelInternal(sendCCEvents = true) {
 	this.resetMIDIParameter("dryLevel");
 	this.octaveTuning.fill(0);
 	this.lastPortamentoNote = this.channelSystem === "xg" ? 60 : -1;
+	this.portamentoForce = false;
 	this.resetDrumParams();
 	this.resetGeneratorOverrides();
 	this.resetGeneratorOffsets();
@@ -2293,7 +2384,7 @@ var DrumParameterUtils = class {
 		dest.rxNoteOn = source.rxNoteOn;
 	}
 	/**
-	* Checks if this user drum parameter is the default.
+	* Checks if this drum parameter is the default.
 	* @param param the param to check.
 	* @param midiNote the MIDI note of this parameter.
 	*/
@@ -2377,6 +2468,7 @@ function applySnapshotInternal(midi, snapshot) {
 		gsReverbParams: snapshot.systemParameters.gsReverbLock ? snapshot.gsReverbProcessor : void 0,
 		gsChorusParams: snapshot.systemParameters.gsChorusLock ? snapshot.gsChorusProcessor : void 0,
 		gsDelayParams: snapshot.systemParameters.gsDelayLock ? snapshot.gsDelayProcessor : void 0,
+		gsEqualizerParams: snapshot.systemParameters.gsEqualizerLock ? snapshot.gsEqualizerProcessor : void 0,
 		gsInsertionParams: snapshot.systemParameters.gsInsertionLock ? snapshot.gsInsertionBlock : void 0,
 		xgReverbParams: snapshot.systemParameters.xgReverbLock ? snapshot.xgReverbBlock : void 0,
 		xgChorusParams: snapshot.systemParameters.xgChorusLock ? snapshot.xgChorusBlock : void 0,
@@ -2389,6 +2481,7 @@ function applySnapshotInternal(midi, snapshot) {
 // src/midi/midi_tools/get_note_times.ts
 /**
 * Calculates all note times in seconds.
+* MIDI ports are ignored, every port is merged into the same 16 channels.
 * @param midi the midi to use
 * @param minDrumLength the shortest a drum note (channel 10) can be, in seconds.
 * @returns an array of 16 channels, each channel containing its notes,
@@ -2462,26 +2555,32 @@ var MIDIPatchTools = class MIDIPatchTools {
 	/**
 	* Converts a given {@link MIDIPatch} to a string.
 	* The format is:
-	* - `DRUM:program` for `isGMGSDrum` set to `true`.
+	* - `DRUM:bankMSB:bankLSB:program` for `isGMGSDrum` set to `true`.
 	* - `bankLSB:bankMSB:program` for `isGMGSDrum` set to `false`.
+	* @param patch The patch to convert.
 	*/
 	static toMIDIString(patch) {
-		if (patch.isGMGSDrum) return `DRUM:${patch.program}`;
+		if (patch.isGMGSDrum) return `DRUM:${patch.bankMSB}:${patch.bankLSB}:${patch.program}`;
 		return `${patch.bankLSB}:${patch.bankMSB}:${patch.program}`;
 	}
 	/**
 	* Gets {@link MIDIPatch} from a given string.
+	* @param string The string in the {@link MIDIPatchTools.toMIDIString} format.
 	*/
 	static fromMIDIString(string) {
 		const parts = string.split(":");
-		const isDrum = string.startsWith("DRUM");
-		if (parts.length !== (isDrum ? 2 : 3)) throw new Error(`Invalid MIDI string: ${string}`);
-		return isDrum ? {
-			bankMSB: 0,
-			bankLSB: 0,
-			program: Number.parseInt(parts[1]),
-			isGMGSDrum: true
-		} : {
+		if (string.startsWith("DRUM")) {
+			if (parts.length !== 4 && parts.length !== 2) throw new Error(`Invalid MIDI string: ${string}`);
+			const long = parts.length === 4;
+			return {
+				bankMSB: long ? Number.parseInt(parts[1]) : 0,
+				bankLSB: long ? Number.parseInt(parts[2]) : 0,
+				program: Number.parseInt(parts[parts.length - 1]),
+				isGMGSDrum: true
+			};
+		}
+		if (parts.length !== 3) throw new Error(`Invalid MIDI string: ${string}`);
+		return {
 			bankLSB: Number.parseInt(parts[0]),
 			bankMSB: Number.parseInt(parts[1]),
 			program: Number.parseInt(parts[2]),
@@ -2493,12 +2592,14 @@ var MIDIPatchTools = class MIDIPatchTools {
 	* The format is:
 	* - `<MIDIPatch string> D <name>` for `isDrum` set to `true`.
 	* - `<MIDIPatch string> M <name>` for `isDrum` set to `false`.
+	* @param patch The patch to convert.
 	*/
 	static toFullMIDIString(patch) {
 		return `${this.toMIDIString(patch)} ${patch.isDrum ? "D" : "M"} ${patch.name}`;
 	}
 	/**
 	* Gets {@link MIDIPatchFull} from a given string.
+	* @param string The string in the {@link MIDIPatchTools.toFullMIDIString} format.
 	*/
 	static fromFullMIDIString(string) {
 		const firstSpace = string.indexOf(" ");
@@ -2515,14 +2616,18 @@ var MIDIPatchTools = class MIDIPatchTools {
 	}
 	/**
 	* Checks if two MIDI patches represent the same one.
+	* @param patch1 The first patch.
+	* @param patch2 The second patch.
 	*/
 	static matches(patch1, patch2) {
-		if (patch1.isGMGSDrum || patch2.isGMGSDrum) return patch1.isGMGSDrum === patch2.isGMGSDrum && patch1.program === patch2.program;
+		if (patch1.isGMGSDrum || patch2.isGMGSDrum) return patch1.isGMGSDrum === patch2.isGMGSDrum && patch1.program === patch2.program && patch1.bankMSB === patch2.bankMSB && patch1.bankLSB === patch2.bankLSB;
 		return patch1.program === patch2.program && patch1.bankLSB === patch2.bankLSB && patch1.bankMSB === patch2.bankMSB;
 	}
 	/**
 	* A comparison function for `.sort()` or `.toSorted()`,
-	* ordering the patches in ascending order.
+	* ordering the patches in ascending order: by program, then bank MSB, then bank LSB, with GM/GS drums last.
+	* @param a The first patch.
+	* @param b The second patch.
 	*/
 	static compare(a, b) {
 		if (a.isGMGSDrum && !b.isGMGSDrum) return 1;
@@ -2533,6 +2638,7 @@ var MIDIPatchTools = class MIDIPatchTools {
 	}
 	/**
 	* Checks if the given {@link MIDIPatchFull} is an XG/GM2 drum patch.
+	* @param p The patch to check.
 	*/
 	static isXGDrum(p) {
 		return p.isDrum && !p.isGMGSDrum;
@@ -2544,7 +2650,7 @@ var MIDIPatchTools = class MIDIPatchTools {
 	* @param patch The {@link MIDIPatch} to select.
 	* @param system The MIDI system to select for.
 	* @returns The selected patch.
-	* @throws Error An error if the array is empty,
+	* @throws Error An error if the array is empty.
 	*/
 	static selectPatch(patches, patch, system) {
 		if (patches.length === 0) throw new Error("No presets!");
@@ -2563,7 +2669,7 @@ var MIDIPatchTools = class MIDIPatchTools {
 			SpessaLog.info(`%cPreset %c${MIDIPatchTools.toMIDIString(patch)}%c not found. (${system}) Replaced with %c${this.toFullMIDIString(pres)}`, ConsoleColors.warn, ConsoleColors.unrecognized, ConsoleColors.warn, ConsoleColors.value);
 		};
 		if (isGMGSDrum) {
-			let p = patches.find((p) => p.isGMGSDrum && p.program === program);
+			let p = patches.find((p) => p.isGMGSDrum && p.program === program && p.bankLSB === bankLSB) ?? patches.find((p) => p.isGMGSDrum && p.program === program);
 			if (p) {
 				returnReplacement(p);
 				return p;
@@ -2675,7 +2781,8 @@ const GSInsertionAddressMap = {
 	controlSource1: 27,
 	controlDepth1: 28,
 	controlSource2: 29,
-	controlDepth2: 30
+	controlDepth2: 30,
+	sendEQSwitch: 31
 };
 const GSChorusAddressMap = {
 	macro: 56,
@@ -2701,6 +2808,12 @@ const GSDelayAddressMap = {
 	feedback: 89,
 	sendLevelToReverb: 90
 };
+const GSEqualizerAddressMap = {
+	lowFrequency: 0,
+	lowGain: 1,
+	highFrequency: 2,
+	highGain: 3
+};
 /**
 * The SysEx addresses of the channel MIDI parameters that GS and XG both set per part.
 * `gs` is the third address byte of GS PATCH PART (`40 1x xx`) and `xg` is the third address byte of
@@ -2771,6 +2884,10 @@ const NRPNDrumParamMap = {
 const NRPNDrumParamByMSB = new Map(Object.entries(NRPNDrumParamMap).map(([parameter, msb]) => [msb, parameter]));
 // src/midi/midi_tools/midi_utils.ts
 /**
+* The GS equalizer parameters by their address (`40 02 xx`).
+*/
+const GS_EQUALIZER_PARAMETER_BY_ADDRESS = new Map(Object.entries(GSEqualizerAddressMap).map(([name, address]) => [address, name]));
+/**
 * The named GS insertion parameters by their address (`40 03 xx`).
 */
 const GS_INSERTION_PARAMETER_BY_ADDRESS = new Map(Object.entries(GSInsertionAddressMap).map(([name, address]) => [address, name]));
@@ -2811,7 +2928,7 @@ var MIDIUtils = class MIDIUtils {
 	* @param channel The MIDI channel number.
 	* @param rpn The 14-bit RPN number.
 	* @param value The 14-bit value for that number.
-	* @returns The analysis result(s) of the message.
+	* @returns The analysis result of the message.
 	*/
 	static analyzeRPN(channel, rpn, value) {
 		switch (rpn) {
@@ -2850,7 +2967,7 @@ var MIDIUtils = class MIDIUtils {
 	* @param value The 14-bit value for that number.
 	* @param drumPitchStep The drum pitch coarse resolution in semitones.
 	* 0.5 for GS (SC-88 and above), 1 for XG and the SC-55 drum map (bank LSB 1).
-	* @returns The analysis result(s) of the message.
+	* @returns The analysis result of the message.
 	*/
 	static analyzeNRPN(channel, nrpn, value, drumPitchStep = .5) {
 		const msb = nrpn >> 7;
@@ -2913,20 +3030,33 @@ var MIDIUtils = class MIDIUtils {
 		return this.gsMessage(ticks, 64, 1, a3, [value]);
 	}
 	/**
+	* Returns a MIDI event needed to set the given GS Equalizer Parameter.
+	* @param ticks The MIDI tick time for the output event.
+	* @param parameter The parameter to set.
+	* @param value The value to set it to.
+	* @returns The {@link MIDIMessage} needed to set this GS Equalizer Parameter.
+	*/
+	static setGSEqualizerParameter(ticks, parameter, value) {
+		const a3 = GSEqualizerAddressMap[parameter];
+		if (a3 === void 0) throw new Error(`Invalid equalizer parameter: ${parameter}`);
+		return this.gsMessage(ticks, 64, 2, a3, [value]);
+	}
+	/**
 	* Returns a MIDI event needed to set the given GS Insertion Parameter.
 	* @param ticks The MIDI tick time for the output event.
 	* @param parameter The parameter to set: `"type"`, a send level or EFX control name (see {@link GSInsertionParameter}),
 	* or a 0-based effect-specific parameter number (0-19).
-	* @param value The value to set it to.
+	* @param value The value to set it to. A boolean for `"sendEQSwitch"`.
 	* @returns The {@link MIDIMessage} needed to set this GS Insertion Parameter.
 	*/
 	static setGSInsertionParameter(ticks, parameter, value) {
+		const data = typeof value === "boolean" ? value ? 1 : 0 : value;
 		switch (parameter) {
-			case "type": return this.gsMessage(ticks, 64, 3, 0, [value >> 8 & 127, value & 127]);
+			case "type": return this.gsMessage(ticks, 64, 3, 0, [data >> 8 & 127, data & 127]);
 			default:
-				if (typeof parameter === "string") return this.gsMessage(ticks, 64, 3, GSInsertionAddressMap[parameter], [value]);
+				if (typeof parameter === "string") return this.gsMessage(ticks, 64, 3, GSInsertionAddressMap[parameter], [data]);
 				if (!Number.isInteger(parameter) || parameter < 0 || parameter > 19) throw new Error(`Invalid insertion parameter: ${parameter}`);
-				return this.gsMessage(ticks, 64, 3, parameter + 3, [value]);
+				return this.gsMessage(ticks, 64, 3, parameter + 3, [data]);
 		}
 	}
 	/**
@@ -3134,6 +3264,7 @@ var MIDIUtils = class MIDIUtils {
 			case "drumMap":
 			case "velocitySenseDepth":
 			case "velocitySenseOffset": return [MIDIUtils.partParamMessage(ticks, channel, system, parameter, value)];
+			case "eqEnabled": return [MIDIUtils.gsMessage(ticks, 64, 64 | MIDIUtils.channelToGSPart(channel), 32, [value ? 1 : 0])];
 			case "efxAssign": return [MIDIUtils.gsMessage(ticks, 64, 64 | MIDIUtils.channelToGSPart(channel), 34, [value ? 1 : 0])];
 			case "dryLevel": return [MIDIUtils.xgMessage(ticks, 8, channel, 17, [value])];
 		}
@@ -4334,6 +4465,15 @@ var MIDIUtils = class MIDIUtils {
 				value
 			}];
 		}
+		if (a2 === 2) {
+			const parameter = GS_EQUALIZER_PARAMETER_BY_ADDRESS.get(a3);
+			if (parameter === void 0) return [OTHER];
+			return [{
+				type: "GS Equalizer Param",
+				parameter,
+				value
+			}];
+		}
 		if (a2 === 3) {
 			switch (a3) {
 				case 0: return [{
@@ -4343,6 +4483,11 @@ var MIDIUtils = class MIDIUtils {
 				}];
 			}
 			const named = GS_INSERTION_PARAMETER_BY_ADDRESS.get(a3);
+			if (named === "sendEQSwitch") return [{
+				type: "GS Insertion Param",
+				parameter: named,
+				value: value !== 0
+			}];
 			if (named !== void 0) return [{
 				type: "GS Insertion Param",
 				parameter: named,
@@ -4546,6 +4691,12 @@ var MIDIUtils = class MIDIUtils {
 						controller: MIDIControllers.bankSelectLSB,
 						value
 					}];
+					case 32: return [{
+						type: "Channel MIDI Param",
+						channel,
+						parameter: "eqEnabled",
+						value: value === 1
+					}];
 					case 34: return [{
 						type: "Channel MIDI Param",
 						channel,
@@ -4877,7 +5028,7 @@ var MIDIEditor = class {
 	* GM -> GS -> note data
 	*
 	* That GM reset is meaningless, so it can stay unmodified as the actual reset that matters is GS.
-	* Meaningful ones are replaced with GS in-place
+	* Meaningful GM ones are replaced with the fallback reset in-place
 	* (unless the `system` parameter is explicitly set).
 	*/
 	meaningfulResets = new Array();
@@ -4919,6 +5070,7 @@ var MIDIEditor = class {
 	gsReverbParams;
 	gsChorusParams;
 	gsDelayParams;
+	gsEqualizerParams;
 	gsInsertionParams;
 	xgReverbParams;
 	xgChorusParams;
@@ -4946,10 +5098,11 @@ var MIDIEditor = class {
 	constructor(midi, opts) {
 		this.midi = midi;
 		SpessaLog.groupCollapsed("%cApplying changes to the MIDI file...", ConsoleColors.info);
-		const { channels, gsReverbParams, gsChorusParams, gsDelayParams, gsInsertionParams, xgReverbParams, xgChorusParams, xgVariationParams, xgInsertionParams, userDrumParams, midiParams } = opts;
+		const { channels, gsReverbParams, gsChorusParams, gsDelayParams, gsEqualizerParams, gsInsertionParams, xgReverbParams, xgChorusParams, xgVariationParams, xgInsertionParams, userDrumParams, midiParams } = opts;
 		this.gsReverbParams = gsReverbParams;
 		this.gsChorusParams = gsChorusParams;
 		this.gsDelayParams = gsDelayParams;
+		this.gsEqualizerParams = gsEqualizerParams;
 		this.gsInsertionParams = gsInsertionParams;
 		this.xgReverbParams = xgReverbParams;
 		this.xgChorusParams = xgChorusParams;
@@ -5022,12 +5175,12 @@ var MIDIEditor = class {
 			}
 			if (this.lastReset !== void 0 && replacedEvents.has(this.lastReset)) this.system = this.fallbackReset ?? "gs";
 		}
-		if (!this.addedReset && this.midiParams?.system !== "clear" && (this.midiParams?.system !== void 0 || this.fallbackReset !== void 0 || this.gsReverbParams && this.gsReverbParams !== "clear" || this.gsChorusParams && this.gsChorusParams !== "clear" || this.gsDelayParams && this.gsDelayParams !== "clear" || this.gsInsertionParams && this.gsInsertionParams !== "clear" || this.xgReverbParams && this.xgReverbParams !== "clear" || this.xgChorusParams && this.xgChorusParams !== "clear" || this.xgVariationParams && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear") || this.userDrumSetParams?.size || [...this.channelChanges.values()].some((c) => c.patch && c.patch !== "clear"))) {
+		if (!this.addedReset && this.midiParams?.system !== "clear" && (this.midiParams?.system !== void 0 || this.fallbackReset !== void 0 || this.gsReverbParams && this.gsReverbParams !== "clear" || this.gsChorusParams && this.gsChorusParams !== "clear" || this.gsDelayParams && this.gsDelayParams !== "clear" || this.gsEqualizerParams && this.gsEqualizerParams !== "clear" || this.gsInsertionParams && this.gsInsertionParams !== "clear" || this.xgReverbParams && this.xgReverbParams !== "clear" || this.xgChorusParams && this.xgChorusParams !== "clear" || this.xgVariationParams && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear") || this.userDrumSetParams?.size || [...this.channelChanges.values()].some((c) => c.patch && c.patch !== "clear"))) {
 			let index = 0;
 			const firstTrack = this.midi.tracks[0];
 			while (index < firstTrack.events.length && firstTrack.events[index].statusByte < MIDIMessageTypes.noteOff) index++;
 			const hasXG = this.xgReverbParams !== void 0 && this.xgReverbParams !== "clear" || this.xgChorusParams !== void 0 && this.xgChorusParams !== "clear" || this.xgVariationParams !== void 0 && this.xgVariationParams !== "clear" || [...this.xgInsertionParams?.values() ?? []].some((p) => p !== "clear");
-			const hasGS = this.gsReverbParams !== void 0 && this.gsReverbParams !== "clear" || this.gsChorusParams !== void 0 && this.gsChorusParams !== "clear" || this.gsDelayParams !== void 0 && this.gsDelayParams !== "clear" || this.gsInsertionParams !== void 0 && this.gsInsertionParams !== "clear";
+			const hasGS = this.gsReverbParams !== void 0 && this.gsReverbParams !== "clear" || this.gsChorusParams !== void 0 && this.gsChorusParams !== "clear" || this.gsDelayParams !== void 0 && this.gsDelayParams !== "clear" || this.gsEqualizerParams !== void 0 && this.gsEqualizerParams !== "clear" || this.gsInsertionParams !== void 0 && this.gsInsertionParams !== "clear";
 			const targetSystem = this.midiParams?.system ?? this.fallbackReset ?? (hasXG && !hasGS ? "xg" : "gs");
 			const event = MIDIUtils.reset(0, targetSystem);
 			firstTrack.addEvents(index, event);
@@ -5267,6 +5420,12 @@ var MIDIEditor = class {
 								return;
 							}
 							break;
+						case "GS Equalizer Param":
+							if (this.gsEqualizerParams) {
+								this.deleteCurrentEvent();
+								return;
+							}
+							break;
 						case "GS Insertion Param":
 							if (this.gsInsertionParams) {
 								this.deleteCurrentEvent();
@@ -5681,6 +5840,10 @@ var MIDIEditor = class {
 				const p = this.gsDelayParams;
 				output.push(MIDIUtils.setGSDelayParameter(targetTicks, "level", p.level), MIDIUtils.setGSDelayParameter(targetTicks, "preLowpass", p.preLowpass), MIDIUtils.setGSDelayParameter(targetTicks, "timeCenter", p.timeCenter), MIDIUtils.setGSDelayParameter(targetTicks, "timeRatioLeft", p.timeRatioLeft), MIDIUtils.setGSDelayParameter(targetTicks, "timeRatioRight", p.timeRatioRight), MIDIUtils.setGSDelayParameter(targetTicks, "levelCenter", p.levelCenter), MIDIUtils.setGSDelayParameter(targetTicks, "levelLeft", p.levelLeft), MIDIUtils.setGSDelayParameter(targetTicks, "levelRight", p.levelRight), MIDIUtils.setGSDelayParameter(targetTicks, "feedback", p.feedback), MIDIUtils.setGSDelayParameter(targetTicks, "sendLevelToReverb", p.sendLevelToReverb));
 			}
+			if (this.gsEqualizerParams && this.gsEqualizerParams !== "clear") {
+				const p = this.gsEqualizerParams;
+				for (const name of Object.keys(GSEqualizerAddressMap)) output.push(MIDIUtils.setGSEqualizerParameter(targetTicks, name, p[name]));
+			}
 			if (this.gsInsertionParams && this.gsInsertionParams !== "clear") {
 				const p = this.gsInsertionParams;
 				output.push(MIDIUtils.setGSInsertionParameter(targetTicks, "type", p.type));
@@ -5946,7 +6109,7 @@ var MIDITrack = class MIDITrack {
 	*/
 	port = 0;
 	/**
-	* A set that contains the MIDI channel numbers used by this track.
+	* A set that contains the MIDI channel numbers (0-15) that have note on events in this track.
 	*/
 	channels = /* @__PURE__ */ new Set();
 	/**
@@ -5975,7 +6138,7 @@ var MIDITrack = class MIDITrack {
 	}
 	/**
 	* Adds events to the track.
-	* @param index The index at which to add these event.
+	* @param index The index at which to add these events.
 	* @param events The events to add.
 	*/
 	addEvents(index, ...events) {
@@ -7043,7 +7206,7 @@ var BasicSample = class {
 	*
 	* > **Warning**
 	* >
-	* > Do not change this value directly. use {@link BasicSample.setSampleType},
+	* > Do not change this value directly. Use {@link BasicSample.setSampleType},
 	* > {@link BasicSample.setLinkedSample} or {@link BasicSample.unlinkSample} instead.
 	*/
 	sampleType;
@@ -7105,7 +7268,7 @@ var BasicSample = class {
 	* @param sampleRate The sample's rate in Hz.
 	* @param originalKey The sample's pitch as a MIDI note number.
 	* @param pitchCorrection The sample's pitch correction in cents.
-	* @param sampleType The sample's type, an enum that defines the sample type/compression.
+	* @param sampleType The sample's type, one of the {@link SampleTypes}.
 	* @param loopStart The sample's loop start relative to the sample start in sample points.
 	* @param loopEnd The sample's loop end relative to the sample start in sample points. Exclusive.
 	*/
@@ -7705,7 +7868,7 @@ var ModulatorSource = class ModulatorSource {
 	/**
 	* If this field is set true, the direction of the controller should be from the maximum value to the minimum value. So, for
 	* example, if the controller source is Key Number, then a Key Number value of 0 corresponds to the maximum possible
-	* controller output, and the Key Number value of 127 corresponds to the minimum possible controller input.
+	* controller output, and the Key Number value of 127 corresponds to the minimum possible controller output.
 	*/
 	isNegative;
 	/**
@@ -8519,7 +8682,7 @@ var BasicPreset = class BasicPreset {
 	* >
 	* > Consider reading about [the DLS conversion problem](../../../docs/extra/dls-conversion-problem.md).
 	*
-	* @returns The instrument containing the flattened zones. If flattening was successful, it should exactly the same as this preset.
+	* @returns The instrument containing the flattened zones. If flattening was successful, it should sound exactly the same as this preset.
 	*/
 	toFlattenedInstrument() {
 		const addUnique = (main, adder) => {
@@ -8710,7 +8873,7 @@ var BasicInstrument = class {
 		return zone;
 	}
 	/**
-	* Links the instrument ta a given preset.
+	* Links the instrument to a given preset.
 	* @param preset The preset to link to.
 	* @internal
 	*/
@@ -10170,8 +10333,8 @@ var DownloadableSoundsArticulation = class extends DLSVerifier {
 		for (const modulator of zone.modulators) ConnectionBlock.fromSFModulator(modulator, this);
 	}
 	/**
-	* Chunk list for the region/instrument (containing lar2 or lart)
-	* @param chunks
+	* Reads the articulation from a chunk list.
+	* @param chunks Chunk list for the region/instrument (containing lar2 or lart)
 	*/
 	read(chunks) {
 		const lart = RIFFChunk.findListType(chunks, "lart");
@@ -10493,7 +10656,6 @@ var DownloadableSoundsRegion = class DownloadableSoundsRegion extends DLSVerifie
 // src/soundbank/downloadable_sounds/instrument.ts
 /**
 * Represents a proper DLS instrument, with regions and articulation.
-* DLS
 */
 var DownloadableSoundsInstrument = class DownloadableSoundsInstrument extends DLSVerifier {
 	articulation = new DownloadableSoundsArticulation();
@@ -10765,7 +10927,7 @@ var DownloadableSounds = class DownloadableSounds extends DLSVerifier {
 		for (let i = 0; i < bank.samples.length; i++) {
 			const s = bank.samples[i];
 			dls.samples.push(DownloadableSoundsSample.fromSFSample(s));
-			progressFunc?.(i / bank.samples.length);
+			progressFunc?.((i + 1) / bank.samples.length);
 		}
 		for (const p of bank.presets) dls.instruments.push(DownloadableSoundsInstrument.fromSFPreset(p, bank.samples));
 		SpessaLog.info("%cConversion complete!", ConsoleColors.recognized);
@@ -10799,12 +10961,12 @@ var DownloadableSounds = class DownloadableSounds extends DLSVerifier {
 		let written = 0;
 		for (const s of this.samples) {
 			const out = s.write();
+			written++;
 			options.progressFunction?.(written / this.samples.length);
 			SpessaLog.info(`%cWrote sample %c${written}. ${s.name}%c of %c${this.samples.length}.`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, ConsoleColors.recognized);
 			ptblOffsets.push(currentIndex);
 			currentIndex += out.reduce((sum, cur) => sum + cur.length, 0);
 			samples.push(...out);
-			written++;
 		}
 		const wvpl = RIFFChunk.getParts("wvpl", samples, false, true);
 		SpessaLog.info("%cSucceeded!", ConsoleColors.recognized);
@@ -11016,9 +11178,8 @@ var SoundBankCloner = class {
 * This module handles parsing and writing SoundFont2 (`.sf2`, `.sf3` and `.sfogg`) files.
 * It represents a single sound bank.
 *
-* It also contains support for `.dls` files and experimental read and write support for [64-bit SFE](https://github.com/SFe-Team-was-taken/SFE).
+* It also contains support for `.dls` files and experimental read and write support for [64-bit SFE](https://sfe-team-was-taken.github.io/SFE/).
 *
-
 * **Specifications:**
 *
 * - [SoundFont2 Specification](http://www.synthfont.com/sfspec24.pdf)
@@ -11062,7 +11223,7 @@ var BasicSoundBank = class BasicSoundBank {
 		}
 	};
 	/**
-	* An array of all presets in the bank, ordered by bank and preset number.
+	* An array of all presets in the bank, ordered by program and bank number, with GM/GS drum presets last.
 	*/
 	presets = [];
 	/**
@@ -11129,8 +11290,9 @@ var BasicSoundBank = class BasicSoundBank {
 		return b;
 	}
 	/**
-	* Creates a simple sound bank with a single saw wave preset.
+	* Creates a simple SF2 file with a single saw wave preset.
 	* Useful for testing synthesizer's functionality without providing a file.
+	* @returns The binary representation of the SF2 file.
 	*/
 	static getSampleSoundBankFile() {
 		const font = new BasicSoundBank();
@@ -11158,12 +11320,17 @@ var BasicSoundBank = class BasicSoundBank {
 		return font.writeSF2();
 	}
 	/**
-	* Copies a given sound bank, deeply cloning all presets instruments and samples.
+	* Copies a given sound bank, cloning all presets, instruments and samples.
+	* The sample data is shared with the original, not copied.
+	* Elements sharing a name are all copied, the repeats get a free name like `Piano-1`.
 	* @param bank The sound bank to copy.
 	*/
 	static copyFrom(bank) {
 		const copied = new BasicSoundBank(bank.type);
-		const cloner = new SoundBankCloner(copied);
+		const cloner = new SoundBankCloner(copied, {
+			reuseByName: false,
+			reuseChildrenByName: false
+		});
 		for (const p of bank.presets) cloner.clonePreset(p);
 		copied.soundBankInfo = { ...bank.soundBankInfo };
 		copied.defaultModulators = bank.defaultModulators.map((m) => Modulator.copyFrom(m));
@@ -11189,8 +11356,8 @@ var BasicSoundBank = class BasicSoundBank {
 	*
 	* > **Warning**
 	* >
-	* > Note that decompressing (sample format `pcm`) usually results
-	* > in permanent sample quality loss!
+	* > Note that compressing (sample format `compressed`) usually results
+	* > in permanent sample quality loss! Decompressing does not restore it.
 	* > This method is memory and CPU intensive with large sound banks.
 	*
 	* @param options Options associated with setting the sample format.
@@ -11234,7 +11401,7 @@ var BasicSoundBank = class BasicSoundBank {
 	}
 	/**
 	* Writes out a DLS Level 2 sound bank. This may not be 100% accurate.
-	* Samples data is always written in the S16LE PCM encoding.
+	* Sample data is always written in the S16LE PCM encoding.
 	*
 	* > **Note**
 	* >
@@ -11357,16 +11524,15 @@ var BasicSoundBank = class BasicSoundBank {
 	/**
 	* Trims the sound bank _in-place_ to only contain samples in a given MIDI file.
 	*
-	
 	* Absent presets will be removed from the sound bank,
 	* and samples that don't get activated in the remaining presets will be removed as well.
 	*
 	* > **Note**
 	* >
-	* > This exact type is returned from {@link BasicMIDI.getUsedProgramsAndKeys}
+	* > This exact type is returned from {@link BasicMIDI.getUsedProgramsAndKeys}.
 	* > Consider reading the page for more explanation about the parameter.
 	*
-	* @param presetData - A `Map`: `BasicPreset` -> `Set<"key-velocity">`.
+	* @param presetData A `Map`: `BasicPreset` -> `Map<MIDI note, Set<velocity>>`.
 	* Absent presets will be removed from the sound bank,
 	* and samples that don't get activated in the remaining presets will be removed as well.
 	*/
@@ -13766,11 +13932,13 @@ const DEFAULT_RMIDI_WRITE_OPTIONS = {
 */
 function writeRMIDIInternal(mid, soundBankBinary, options) {
 	const metadata = { ...options.metadata };
-	if (options.correctBankOffset && !options.soundBank) throw new Error("Sound bank must be provided if correcting bank offset.");
 	SpessaLog.group("%cWriting the RMIDI File...", ConsoleColors.info);
 	SpessaLog.info("metadata", metadata);
 	SpessaLog.info("Initial bank offset", mid.bankOffset);
-	if (options.correctBankOffset && options.soundBank) correctBankOffsetInternal(mid, options.bankOffset, options.soundBank);
+	if (options.correctBankOffset) {
+		if (options.soundBank) correctBankOffsetInternal(mid, options.bankOffset, options.soundBank);
+		else SpessaLog.warn("No sound bank provided, skipping the bank offset correction.");
+	}
 	const newMid = new IndexedByteArray(mid.writeMIDI());
 	metadata.name ??= mid.getName();
 	metadata.creationDate ??= /* @__PURE__ */ new Date();
@@ -13958,7 +14126,8 @@ var BasicMIDI = class BasicMIDI {
 	* The loop points (in ticks) of the sequence, including both start and end points.
 	*
 	* If there's nothing detected, the loop will start from the first note on event and end will be the last voice message.
-	* Current looping detection is: CC 2/4, 116/117 and "start," "loopStart" and "loopEnd" markers.
+	* Current looping detection is: CC 2/4 (Touhou), CC 111 (RPG Maker), CC 116/117 and 118/119 (EMIDI/XMI)
+	* and the "start", "loopStart" and "loopEnd" markers.
 	*/
 	loop = {
 		start: 0,
@@ -13976,6 +14145,7 @@ var BasicMIDI = class BasicMIDI {
 	format = 0;
 	/**
 	* The RMID (Resource-Interchangeable MIDI) info data, if the file is RMID formatted.
+	* XMF metadata and converted tracker modules are stored here as well.
 	* Otherwise, this object is empty.
 	* Info type: Chunk data as a binary array.
 	*
@@ -14047,7 +14217,7 @@ var BasicMIDI = class BasicMIDI {
 	* This function reads the MIDI file format, extracts the header and track chunks,
 	* and populates the BasicMIDI instance with the parsed data.
 	* It supports Standard MIDI Files (SMF), RIFF MIDI (RMIDI), and Extensible Music Format (XMF).
-	* It also handles embedded soundbanks in RMIDI files.
+	* It also handles embedded soundbanks in RMIDI and XMF files.
 	* Tracker modules (ProTracker MOD, Fast Tracker 2 XM, Scream Tracker 3 S3M) are converted
 	* into MIDI with an embedded sound bank.
 	*/
@@ -14086,7 +14256,7 @@ var BasicMIDI = class BasicMIDI {
 		return m;
 	}
 	/**
-	* Copies another instance this `BasicMIDI` instance, including track data.
+	* Copies another instance into this `BasicMIDI` instance, including track data.
 	* @param mid The MIDI to copy.
 	*/
 	copyFrom(mid) {
@@ -14159,7 +14329,7 @@ var BasicMIDI = class BasicMIDI {
 	}
 	/**
 	* Preloads all voices for this sequence in a given {@link SpessaSynthProcessor}.
-	* This caches all the needed voices for playing back this sequencer, resulting in a smooth playback.
+	* This caches all the needed voices for playing back this sequence, resulting in a smooth playback.
 	* The sequencer calls this function by default when loading the songs. (it can be disabled: {@link SpessaSynthSequencer.preload}).
 	* @param synth The synthesizer to preload.
 	*/
@@ -14189,6 +14359,12 @@ var BasicMIDI = class BasicMIDI {
 	}
 	/**
 	* Calculates all note times in seconds.
+	*
+	* > **Note**
+	* >
+	* > MIDI ports are ignored, so the channels of every port are merged into the 16 channels.
+	* > For example, channel 1 of port 2 is returned as channel 1.
+	*
 	* @param minDrumLength In seconds, represents the minimum allowed time for a drum note,
 	*   since they sometimes have a length of 0.
 	* @returns An array of 16 channels, each channel containing its notes,
@@ -14241,7 +14417,7 @@ var BasicMIDI = class BasicMIDI {
 		return writeMIDIInternal(this);
 	}
 	/**
-	* Writes out an RMIDI file (MIDI + SF2).
+	* Writes out an RMIDI file (MIDI + SF2 or DLS).
 	* [See more info about this format](https://github.com/spessasus/sf2-rmidi-specification#readme).
 	*
 	* Note that this method modifies the MIDI file in-place.
@@ -14250,11 +14426,16 @@ var BasicMIDI = class BasicMIDI {
 	* The method is called on a `BasicMIDI` instance;
 	* that instance is the MIDI file to embed.
 	*
+	* > **Warning**
+	* >
+	* > Do not call in audioWorkletGlobalScope as it uses TextDecoder and TextEncoder.
+	* > Bank offset correction (on by default) needs `soundBank`. Without it, the correction is skipped with a warning.
+	*
 	* > **Tip**
 	* >
 	* > Use {@link BasicSoundBank.trim} to drastically reduce the file size.
-	* > consider also using compression (like shown in example) to save even more space.
-	* > (using these both methods, I managed to shrink a 1GB sound bank into a 5MB RMIDI!)
+	* > Consider also using compression (like shown in example) to save even more space.
+	* > (using both of these methods, I managed to shrink a 1GB sound bank into a 5MB RMIDI!)
 	*
 	* @param soundBankBinary The binary sound bank (SF2 or DLS) to embed into the file.
 	* @param configuration Extra options for writing the file.
@@ -14292,7 +14473,7 @@ var BasicMIDI = class BasicMIDI {
 	*
 	*     // trim the soundfont
 	*     soundBank.trim(midi.getUsedProgramsAndKeys(soundBank));
-	*     // write out with compression to save space (0.5 is medium quality)
+	*     // write out with compression to save space
 	*     await soundBank.setSampleFormat({
 	*         format: "compressed",
 	*         compressionFunction: SampleEncodingFunction // Remember to get your compression function
@@ -14330,6 +14511,8 @@ var BasicMIDI = class BasicMIDI {
 	* and inserts/deletes messages appropriately.
 	*
 	* This modifies the MIDI sequence _in-place_.
+	*
+	* @param opts The modifications to apply.
 	*/
 	modify(opts) {
 		new MIDIEditor(this, opts).apply();
@@ -14339,8 +14522,10 @@ var BasicMIDI = class BasicMIDI {
 	* This means changing the programs and controllers if they are locked.
 	*
 	* For example, if channel 1 has locked preset on `Drawbar Organ`,
-	* this will remove all program changes for channel 1 and add one at the start to change the program to
+	* this will remove all program changes for channel 1 and add one before the channel's first note on
+	* (and again after every system reset) to change the program to
 	* `Drawbar organ` (using bank MSB/LSB and program change).
+	* Muted channels are removed from the sequence.
 	*
 	* > **Warning**
 	* >
@@ -14413,11 +14598,31 @@ var BasicMIDI = class BasicMIDI {
 	* > **Note**
 	* >
 	* > This sets the Info encoding to `utf-8`.
+	* > Text chunks that are already present get re-encoded from their old encoding (IENC) to UTF-8,
+	* > so they stay readable. Without IENC, they are assumed to be UTF-8 already, like {@link BasicMIDI.getRMIDInfo} does.
+	*
+	* > **Warning**
+	* >
+	* > Do not call in audioWorkletGlobalScope as it uses TextDecoder and TextEncoder.
 	*
 	* @param infoType The type to set.
 	* @param infoData The value to set it to.
 	*/
 	setRMIDInfo(infoType, infoData) {
+		const oldEncoding = this.infoEncoding;
+		if (oldEncoding !== void 0 && !/^utf-?8$/i.test(oldEncoding.trim())) try {
+			const decoder = new TextDecoder(oldEncoding.trim());
+			const encoder = new TextEncoder();
+			for (const key of Object.keys(this.rmidiInfo)) {
+				if (key === "picture" || key === "creationDate" || key === "infoEncoding") continue;
+				const data = this.rmidiInfo[key];
+				if (!data) continue;
+				const text = decoder.decode(data[data.length - 1] === 0 ? data.subarray(0, -1) : data);
+				this.rmidiInfo[key] = new Uint8Array([...encoder.encode(text), 0]);
+			}
+		} catch (error) {
+			SpessaLog.warn(`Failed to re-encode the RMIDI info from ${oldEncoding}: ${error}`);
+		}
 		this.rmidiInfo.infoEncoding = getStringBytes("utf-8", true);
 		if (infoType === "picture") this.rmidiInfo.picture = new Uint8Array(infoData);
 		else if (infoType === "creationDate") this.rmidiInfo.creationDate = getStringBytes(toISODateString(infoData), true);
@@ -14428,6 +14633,11 @@ var BasicMIDI = class BasicMIDI {
 	}
 	/**
 	* Gets a given chunk from the RMIDI information.
+	*
+	* > **Warning**
+	* >
+	* > Do not call in audioWorkletGlobalScope as it uses TextDecoder.
+	*
 	* @param infoType The metadata type.
 	* @returns `string`, `Date`, `ArrayBuffer` or undefined if the info is not set.
 	*/
@@ -14455,7 +14665,7 @@ var BasicMIDI = class BasicMIDI {
 	* > if you are not editing the MIDI file in your loop.
 	* > It is usually a faster solution and allows custom loops.
 	*
-	*     If the track data is being edited, remember to call {@link BasicMIDI.flush} it after editing!
+	* If the track data is being edited, remember to call {@link BasicMIDI.flush} after editing!
 	*
 	* @param callback The callback function to process each event.
 	*/
@@ -14562,11 +14772,15 @@ var BasicMIDI = class BasicMIDI {
 						case MIDIMessageTypes.controllerChange:
 							switch (e.data[0]) {
 								case MIDIControllers.breathController:
-								case MIDIControllers.undefinedCC111LSB:
 									if (e.data[1] === 0) loopStart = e.ticks;
 									break;
-								case MIDIControllers.undefinedCC116LSB:
-								case MIDIControllers.undefinedCC118LSB:
+								case MIDIControllers.undefinedCC111:
+									if (e.data[1] !== 0) break;
+									loopStart = e.ticks;
+									loopType = "soft";
+									break;
+								case MIDIControllers.undefinedCC116:
+								case MIDIControllers.undefinedCC118:
 									loopStart = e.ticks;
 									break;
 								case MIDIControllers.footController:
@@ -14579,8 +14793,8 @@ var BasicMIDI = class BasicMIDI {
 										loopType = "hard";
 									}
 									break;
-								case MIDIControllers.undefinedCC117LSB:
-								case MIDIControllers.undefinedCC119LSB:
+								case MIDIControllers.undefinedCC117:
+								case MIDIControllers.undefinedCC119:
 									loopEnd = loopEnd === null ? e.ticks : 0;
 									loopType = "hard";
 									break;
@@ -14776,6 +14990,7 @@ const DEFAULT_MIDI_BUILDER_OPTIONS = {
 * > **Warning**
 * >
 * > Remember to call {@link BasicMIDI.flush} after you're done building the file!
+* > Do not use in audioWorkletGlobalScope as it uses TextEncoder.
 *
 * @group MIDI.Files
 */
@@ -15071,7 +15286,7 @@ function processEventInternal(event, trackIndex) {
 }
 // src/sequencer/process_tick.ts
 /**
-* Processes a single MIDI tick.
+* Processes a single sequencer tick, playing all MIDI events up to the current time.
 * Call this every rendering quantum to process the sequencer events in real-time.
 */
 function processTick() {
@@ -17958,7 +18173,8 @@ function wordToFloat(word, mode) {
 	return mode === 1 ? signed / 128 : signed / 512;
 }
 /**
-* Rounds a scaled coefficient half away from zero, like the DLL's biased truncation.
+* Adds the DLL's half step bias (away from zero) to a scaled coefficient.
+* Truncating the result rounds half away from zero, like the DLL's biased truncation.
 * @param value The exact scaled value.
 */
 function biasedRound(value) {
@@ -18487,6 +18703,8 @@ var XGDSPProgram = class {
 var DefaultXGEffect = class {
 	/**
 	* The currently used processor.
+	* Hidden from the docs as the processor types are internal.
+	* @hidden
 	*/
 	processor;
 	outputLeft;
@@ -18506,8 +18724,9 @@ var DefaultXGEffect = class {
 	* @param defaultType The default effect type.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	* @param variation True for the variation and insertion blocks.
+	* @hidden
 	*/
 	constructor(effectMap, fallbackProcessor, defaultType, sampleRate, maxBufferSize, variation) {
 		let memoryLength = getMemorySize(sampleRate, fallbackProcessor.memorySize);
@@ -18569,11 +18788,17 @@ for (let pan = MIN_PAN$1; pan <= MAX_PAN$1; pan++) {
 var DefaultXGSystemEffect = class extends DefaultXGEffect {
 	return = 64;
 	pan = 64;
+	/**
+	* Resets this block to default values, including the processor type.
+	*/
 	reset() {
 		super.reset();
 		this.return = 64;
 		this.pan = 64;
 	}
+	/**
+	* Gets a snapshot of this XG effect block.
+	*/
 	getSnapshot() {
 		return {
 			...super.getSnapshot(),
@@ -18581,6 +18806,10 @@ var DefaultXGSystemEffect = class extends DefaultXGEffect {
 			pan: this.pan
 		};
 	}
+	/**
+	* Restores this XG effect block from a snapshot.
+	* @param snapshot The snapshot to restore.
+	*/
 	applySnapshot(snapshot) {
 		super.applySnapshot(snapshot);
 		this.return = snapshot.return;
@@ -18721,9 +18950,9 @@ const TIME_OFFSETS = new Int8Array([
 	107
 ]);
 /**
-* Damping line feedback coefficient words.
+* Damping line input gain coefficient words.
 */
-const DAMP_FEEDBACK = new Uint16Array([
+const DAMP_INPUT = new Uint16Array([
 	105,
 	105,
 	105,
@@ -18982,9 +19211,9 @@ const DAMP_FEEDBACK = new Uint16Array([
 	2
 ]);
 /**
-* Damping line filter coefficient words.
+* Damping line feedback coefficient words, used for both taps of the two-tap feedback filter.
 */
-const DAMP_FILTER = new Uint16Array([
+const DAMP_FEEDBACK = new Uint16Array([
 	1,
 	1,
 	1,
@@ -19756,7 +19985,7 @@ const LIST_LPF = [
 	50
 ];
 /**
-* Diffusion allpass addresses, 4 per line: base, density tap, write, read.
+* Damped delay line addresses, 4 per line: write, feedback read, left output tap, right output tap.
 */
 const LIST_DIFFUSION = [
 	31,
@@ -19777,7 +20006,7 @@ const LIST_DIFFUSION = [
 	7
 ];
 /**
-* Damping line coefficients, 3 per line: feedback, filter, filter.
+* Damping line coefficients, 3 per line: input, read and previous read gains.
 */
 const LIST_TIME = [
 	91,
@@ -20059,13 +20288,14 @@ var XGReverb = class extends XGDSPProgram {
 	* @param offset The first list index.
 	*/
 	writeDamping(index, list, offset) {
-		this.coefficientWords[list[offset]] = DAMP_FEEDBACK[index];
-		const filter = index > 202 ? 255 : DAMP_FILTER[index];
-		this.coefficientWords[list[offset + 1]] = filter;
-		this.coefficientWords[list[offset + 2]] = filter;
+		this.coefficientWords[list[offset]] = DAMP_INPUT[index];
+		const feedback = index > 202 ? 255 : DAMP_FEEDBACK[index];
+		this.coefficientWords[list[offset + 1]] = feedback;
+		this.coefficientWords[list[offset + 2]] = feedback;
 	}
 	/**
-	* Places the diffusion allpasses from the diffusion parameter.
+	* Places the delay line read and output taps from the diffusion parameter.
+	* The diffusion spreads the left and right output taps of each line apart.
 	*/
 	diffusion() {
 		const scale = DIFFUSION_SCALE[this.params[1]];
@@ -20221,7 +20451,7 @@ var XGRoomReverb = class extends XGReverb {
 		this.writeDamping(extra + base & 255, LIST_TIME, offset);
 	}
 	/**
-	* Places a diffusion allpass from a room dimension.
+	* Places a delay line's length and output taps from a room dimension.
 	* @param step The room diffusion step index.
 	* @param size The dimension size.
 	* @param offset The first diffusion list index.
@@ -20242,7 +20472,7 @@ var XGRoomReverb = class extends XGReverb {
 		}
 	}
 	/**
-	* Updates one dimension's damping line and allpass, then pushes them.
+	* Updates one dimension's delay line (damping, length and taps), then pushes it.
 	* @param dimension 0 width, 1 height, 2 depth.
 	* @param step The room diffusion step index.
 	* @param size The dimension size.
@@ -22066,6 +22296,8 @@ const REVERB_MAP = /* @__PURE__ */ new Map([
 /**
 * The default implementation for {@link XGReverbBlock}.
 *
+* The default type is HALL 1. Unknown types use the type with LSB 0, or NO EFFECT (silence) if that is missing too.
+*
 * @group Synthesizer.XG Effects
 * @sealed
 */
@@ -22074,7 +22306,7 @@ var DefaultXGReverb = class extends DefaultXGSystemEffect {
 	* Constructs a new default XG reverb processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		super(REVERB_MAP, XGNoEffect, 256, sampleRate, maxBufferSize, false);
@@ -22166,7 +22398,7 @@ const LIST_RIGHT_TAPS = [
 	25,
 	26
 ];
-const LIST_DRY_WET = [
+const LIST_DRY_WET$4 = [
 	95,
 	96,
 	97,
@@ -22407,7 +22639,7 @@ var XGChorusBase = class extends XGDSPProgram {
 				const w = this.coefficientWords;
 				w[95] = w[104] = dry & 1023;
 				w[96] = w[105] = w[97] = w[106] = wet & 1023;
-				this.pushCoefficients(LIST_DRY_WET);
+				this.pushCoefficients(LIST_DRY_WET$4);
 				break;
 			}
 		}
@@ -23679,6 +23911,8 @@ const CHORUS_MAP = /* @__PURE__ */ new Map([
 /**
 * The default implementation for {@link XGChorusBlock}.
 *
+* The default type is CHORUS 1. Unknown types use the type with LSB 0, or NO EFFECT (silence) if that is missing too.
+*
 * @group Synthesizer.XG Effects
 * @sealed
 */
@@ -23688,11 +23922,14 @@ var DefaultXGChorus = class extends DefaultXGSystemEffect {
 	* Constructs a new default XG chorus processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		super(CHORUS_MAP, XGNoEffect, 16640, sampleRate, maxBufferSize, false);
 	}
+	/**
+	* Resets this block to default values, including the processor type.
+	*/
 	reset() {
 		super.reset();
 		this.sendToReverb = 0;
@@ -23707,12 +23944,19 @@ var DefaultXGChorus = class extends DefaultXGSystemEffect {
 			reverbRight[i] += this.outputRight[i] * gain;
 		}
 	}
+	/**
+	* Gets a snapshot of this XG effect block.
+	*/
 	getSnapshot() {
 		return {
 			...super.getSnapshot(),
 			sendToReverb: this.sendToReverb
 		};
 	}
+	/**
+	* Restores this XG effect block from a snapshot.
+	* @param snapshot The snapshot to restore.
+	*/
 	applySnapshot(snapshot) {
 		super.applySnapshot(snapshot);
 		this.sendToReverb = snapshot.sendToReverb;
@@ -24141,6 +24385,16 @@ const PARAMETER_RANGES$15 = {
 	13: [4, 124],
 	14: [0, 1]
 };
+const LIST_INPUT_COEFFICIENT = [
+	170,
+	180,
+	185
+];
+const LIST_INPUT_ADDRESS = [
+	59,
+	45,
+	46
+];
 /**
 * TREMOLO (`46 00`): amplitude and pitch modulation.
 */
@@ -24328,16 +24582,8 @@ var XGTremolo = class extends XGTremoloBase {
 					a[45] = 1025;
 					a[46] = 1026;
 				}
-				this.pushCoefficients([
-					170,
-					180,
-					185
-				]);
-				this.pushAddresses([
-					59,
-					45,
-					46
-				]);
+				this.pushCoefficients(LIST_INPUT_COEFFICIENT);
+				this.pushAddresses(LIST_INPUT_ADDRESS);
 				this.convert(5);
 				this.convert(7);
 				break;
@@ -24353,6 +24599,7 @@ const PARAMETER_RANGES$14 = {
 	7: [28, 58],
 	8: [52, 76]
 };
+const LIST_OUTPUT$3 = [180, 185];
 /**
 * LFO phases (left, right) per pan direction: L<->R, L->R, L<-R, L turn, R turn.
 */
@@ -24555,7 +24802,7 @@ var XGAutoPan = class extends XGTremoloBase {
 				break;
 			case 9:
 				w[185] = w[180] = this.outputWord(this.insertion ? 362 : 724);
-				this.pushCoefficients([180, 185]);
+				this.pushCoefficients(LIST_OUTPUT$3);
 		}
 	}
 };
@@ -24779,6 +25026,11 @@ const PARAMETER_RANGES$13 = {
 	8: [52, 76],
 	10: [6, 10]
 };
+const LIST_DRY_LEFT = [162];
+const LIST_MIX_RIGHT$1 = [166, 167];
+const LIST_WET_SECOND = [164];
+const LIST_WET_FOURTH = [165];
+const LIST_INPUT_MIX = [132, 133];
 /**
 * The converter index of the input mix level, which depends on the connection.
 */
@@ -25001,14 +25253,14 @@ var XGPhaser1 = class extends XGPhaserBase {
 			case 9:
 				w[166] = w[162] = PAN_LEFT[mix];
 				w[167] = PAN_RIGHT[mix];
-				this.pushCoefficients([162]);
-				this.pushCoefficients([166, 167]);
+				this.pushCoefficients(LIST_DRY_LEFT);
+				this.pushCoefficients(LIST_MIX_RIGHT$1);
 				if (p[10] < 9) {
 					w[164] = PAN_RIGHT[mix];
-					this.pushCoefficients([164]);
+					this.pushCoefficients(LIST_WET_SECOND);
 				} else {
 					w[165] = PAN_RIGHT[mix];
-					this.pushCoefficients([165]);
+					this.pushCoefficients(LIST_WET_FOURTH);
 				}
 				break;
 			case 10: {
@@ -25032,7 +25284,7 @@ var XGPhaser1 = class extends XGPhaserBase {
 			}
 			case INPUT_MIX:
 				w[132] = w[133] = this.insertion ? 256 : 512;
-				this.pushCoefficients([132, 133]);
+				this.pushCoefficients(LIST_INPUT_MIX);
 		}
 	}
 };
@@ -25046,6 +25298,8 @@ const PARAMETER_RANGES$12 = {
 	10: [3, 5],
 	12: [4, 124]
 };
+const LIST_MIX_LEFT = [162, 163];
+const LIST_MIX_RIGHT = [166, 167];
 /**
 * PHASER 2 (`48 08`): a stereo phaser with 3 to 5 stages and an LFO phase difference between the sides.
 */
@@ -25218,8 +25472,8 @@ var XGPhaser2 = class extends XGPhaserBase {
 				const mix = this.mixIndex();
 				w[166] = w[162] = PAN_LEFT[mix];
 				w[167] = w[163] = PAN_RIGHT[mix];
-				this.pushCoefficients([162, 163]);
-				this.pushCoefficients([166, 167]);
+				this.pushCoefficients(LIST_MIX_LEFT);
+				this.pushCoefficients(LIST_MIX_RIGHT);
 				break;
 			}
 			case 10: {
@@ -25616,6 +25870,8 @@ const LIST_HIGH_LEFT = [
 	131,
 	133
 ];
+const LIST_OUTPUT$2 = [185, 186];
+const LIST_DRY_WET$3 = [171, 173];
 /**
 * AUTO WAH (`4E 00`): a resonant filter per side, swept by an exponential LFO.
 */
@@ -25869,8 +26125,8 @@ var XGAutoWah = class extends XGFilterVariationProgram {
 				const mix = this.mixIndex();
 				w[171] = w[185] = PAN_LEFT[mix];
 				w[173] = w[186] = PAN_RIGHT[mix];
-				this.pushCoefficients([185, 186]);
-				this.pushCoefficients([171, 173]);
+				this.pushCoefficients(LIST_OUTPUT$2);
+				this.pushCoefficients(LIST_DRY_WET$3);
 				break;
 			}
 		}
@@ -25897,16 +26153,17 @@ const UNWRITTEN_CATEGORY_2 = [
 	128,
 	174
 ];
+const LIST_MONO_INPUT$1 = [109, 110];
 /**
 * The base for the S-YXG50 category 2 variation programs (3-band EQ, distortion, early reflections).
-* They process a mono sum of the input through a two-section low shelf, keeping scaled copies
+* They process a mono sum of the input through two first-order input sections, keeping scaled copies
 * of the dry input that the routines mix back in.
 * Any of 0x76, 0x7a, 0x7d and 0x80 sets 0x76 to their product.
 */
 var XGMonoVariationProgram = class extends XGVariationProgram {
 	unwrittenCoefficients = UNWRITTEN_CATEGORY_2;
 	/**
-	* The mono input after the low shelf.
+	* The mono input after the input sections.
 	*/
 	mono;
 	/**
@@ -26027,7 +26284,7 @@ var XGMonoVariationProgram = class extends XGVariationProgram {
 	monoInputLevel() {
 		const w = this.coefficientWords;
 		w[109] = w[110] = this.insertion ? 256 : 512;
-		this.pushCoefficients([109, 110]);
+		this.pushCoefficients(LIST_MONO_INPUT$1);
 	}
 };
 // src/synthesizer/audio_engine/effects/xg/implementation/dsp/equalizer/three_band_eq.ts
@@ -26387,6 +26644,12 @@ const LIST_MID = [
 	166,
 	165
 ];
+const LIST_DRY_WET$2 = [
+	173,
+	176,
+	177,
+	179
+];
 /**
 * The clipping range (the original works on a 16-bit scale, which is 4 times the full scale).
 */
@@ -26480,12 +26743,7 @@ var XGDistortionBase = class extends XGMonoVariationProgram {
 		if (this.insertion) wet >>= 1;
 		w[173] = w[177] = PAN_LEFT[mix];
 		w[176] = w[179] = VARIATION_GAIN * wet >> 6;
-		this.pushCoefficients([
-			173,
-			176,
-			177,
-			179
-		]);
+		this.pushCoefficients(LIST_DRY_WET$2);
 	}
 };
 // src/synthesizer/audio_engine/effects/xg/implementation/dsp/distortion/distortion.ts
@@ -28425,6 +28683,12 @@ const LIST_HIGH_DAMP = [
 	119,
 	121
 ];
+const LIST_DRY_WET$1 = [
+	173,
+	175,
+	177,
+	178
+];
 /**
 * The converter index of the mono input level, which depends on the connection.
 */
@@ -28544,12 +28808,7 @@ var XGEarlyReflectionsBase = class extends XGMonoVariationProgram {
 				const mix = this.mixIndex();
 				w[173] = w[177] = MIX_DRY[mix] & 1023;
 				w[175] = w[178] = MIX_WET[mix] & 1023;
-				this.pushCoefficients([
-					173,
-					175,
-					177,
-					178
-				]);
+				this.pushCoefficients(LIST_DRY_WET$1);
 				break;
 			}
 			case 10:
@@ -29308,7 +29567,7 @@ const DELAY_LEVEL = new Float32Array([
 ]);
 // src/synthesizer/audio_engine/effects/xg/implementation/dsp/delay/xg_delay.ts
 /**
-* The right line input position used by the two-line delays (in the upper half of the memory).
+* The right line input position used by the two-line delays (past the longest left line).
 */
 const RIGHT_LINE_START = 16384;
 const LIST_DAMP_A = [159, 158];
@@ -29373,7 +29632,7 @@ var XGDelayBase = class extends XGStereoVariationProgram {
 		this.pushAddresses([tap]);
 	}
 	/**
-	* Designs a feedback damping filter (a one-pole low-pass) from the high damp parameter.
+	* Designs a feedback damping filter (a two-tap low-pass) from the high damp parameter.
 	* @param damp The high damp value (1-10).
 	* @param list The coefficient indices for the input and feedback coefficients.
 	*/
@@ -29402,6 +29661,14 @@ const PARAMETER_RANGES$4 = {
 	14: [28, 58],
 	15: [52, 76]
 };
+const LIST_MIX$3 = [
+	178,
+	181,
+	184,
+	185,
+	187,
+	182
+];
 /**
 * DELAY L,C,R (`05 00`): left, right and center taps with a separate feedback tap.
 */
@@ -29575,14 +29842,7 @@ var XGDelayLCR = class extends XGDelayBase {
 				if (this.insertion) wet >>= 1;
 				w[185] = w[181] = wet & 1023;
 				w[187] = w[182] = Math.trunc(wet * DELAY_LEVEL[p[5]]) & 1023;
-				this.pushCoefficients([
-					178,
-					181,
-					184,
-					185,
-					187,
-					182
-				]);
+				this.pushCoefficients(LIST_MIX$3);
 				break;
 			}
 			case 6:
@@ -29611,6 +29871,12 @@ const PARAMETER_RANGES$3 = {
 	14: [28, 58],
 	15: [52, 76]
 };
+const LIST_MIX$2 = [
+	178,
+	181,
+	184,
+	187
+];
 /**
 * DELAY L,R (`06 00`): left and right taps with two feedback taps.
 */
@@ -29786,12 +30052,7 @@ var XGDelayLR = class extends XGDelayBase {
 				let wet = MIX_WET[mix];
 				if (this.insertion) wet >>= 1;
 				w[187] = w[181] = wet & 1023;
-				this.pushCoefficients([
-					178,
-					181,
-					184,
-					187
-				]);
+				this.pushCoefficients(LIST_MIX$2);
 				break;
 			}
 			case 12:
@@ -29818,6 +30079,14 @@ const PARAMETER_RANGES$2 = {
 	14: [28, 58],
 	15: [52, 76]
 };
+const LIST_MIX$1 = [
+	178,
+	180,
+	181,
+	184,
+	185,
+	187
+];
 /**
 * ECHO (`07 00`): two independent delay lines with feedback and a second tap each.
 */
@@ -29999,14 +30268,7 @@ var XGEcho = class extends XGDelayBase {
 				const wet = MIX_WET[mix];
 				w[185] = w[180] = wet & 1023;
 				w[187] = w[181] = Math.trunc(wet * DELAY_LEVEL[p[7]]) & 1023;
-				this.pushCoefficients([
-					178,
-					180,
-					181,
-					184,
-					185,
-					187
-				]);
+				this.pushCoefficients(LIST_MIX$1);
 				break;
 			}
 			case 12:
@@ -30031,6 +30293,12 @@ const PARAMETER_RANGES$1 = {
 	14: [28, 58],
 	15: [52, 76]
 };
+const LIST_MIX = [
+	178,
+	180,
+	184,
+	185
+];
 /**
 * CROSS DELAY (`08 00`): two delay lines feeding back into each other.
 */
@@ -30221,12 +30489,7 @@ var XGCrossDelay = class extends XGDelayBase {
 				let wet = MIX_WET[mix];
 				if (p[3] < 2) wet >>= 1;
 				w[185] = w[180] = wet & 1023;
-				this.pushCoefficients([
-					178,
-					180,
-					184,
-					185
-				]);
+				this.pushCoefficients(LIST_MIX);
 				break;
 			}
 			case 12:
@@ -30421,6 +30684,10 @@ const LIST_DENSITY_ADDRESS = [
 	54,
 	51
 ];
+const LIST_DRY = [185];
+const LIST_WET = [187];
+const LIST_DRY_WET = [174, 172];
+const LIST_MONO_INPUT = [109, 110];
 /**
 * The converter index of the mono input level, which depends on the connection.
 */
@@ -30543,9 +30810,9 @@ var XGKaraokeBase = class extends XGFilterVariationProgram {
 				const mix = this.mixIndex();
 				w[172] = w[185] = MIX_DRY[mix] & 1023;
 				w[174] = w[187] = MIX_WET[mix] & 1023;
-				this.pushCoefficients([185]);
-				this.pushCoefficients([187]);
-				this.pushCoefficients([174, 172]);
+				this.pushCoefficients(LIST_DRY);
+				this.pushCoefficients(LIST_WET);
+				this.pushCoefficients(LIST_DRY_WET);
 				break;
 			}
 			case 10:
@@ -30554,7 +30821,7 @@ var XGKaraokeBase = class extends XGFilterVariationProgram {
 				break;
 			case MONO_INPUT$1:
 				w[109] = w[110] = this.insertion ? 181 : 362;
-				this.pushCoefficients([109, 110]);
+				this.pushCoefficients(LIST_MONO_INPUT);
 		}
 	}
 };
@@ -31013,6 +31280,9 @@ const VARIATION_MAP = /* @__PURE__ */ new Map([
 /**
 * The default implementation for {@link XGVariationBlock}.
 *
+* The default type is DELAY L,C,R in the insertion connection.
+* Unknown types use the type with LSB 0, or THRU if that is missing too.
+*
 * @group Synthesizer.XG Effects
 * @sealed
 */
@@ -31025,11 +31295,14 @@ var DefaultXGVariation = class extends DefaultXGSystemEffect {
 	* Constructs a new default XG variation processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		super(VARIATION_MAP, XGThru, 1280, sampleRate, maxBufferSize, true);
 	}
+	/**
+	* Resets this block to default values, including the processor type.
+	*/
 	reset() {
 		super.reset();
 		this.insertionMode = true;
@@ -31063,6 +31336,9 @@ var DefaultXGVariation = class extends DefaultXGSystemEffect {
 			inputRight[i] = outputRight[i];
 		}
 	}
+	/**
+	* Gets a snapshot of this XG effect block.
+	*/
 	getSnapshot() {
 		return {
 			...super.getSnapshot(),
@@ -31072,6 +31348,10 @@ var DefaultXGVariation = class extends DefaultXGSystemEffect {
 			sendToChorus: this.sendToChorus
 		};
 	}
+	/**
+	* Restores this XG effect block from a snapshot.
+	* @param snapshot The snapshot to restore.
+	*/
 	applySnapshot(snapshot) {
 		super.applySnapshot(snapshot);
 		this.insertionMode = snapshot.insertionMode;
@@ -31124,6 +31404,10 @@ const INSERTION_MAP = /* @__PURE__ */ new Map([
 /**
 * The default implementation for {@link XGInsertionBlock}.
 *
+* The default type is DISTORTION. The EFFECT 2 types run on the same processors as the variation block types.
+* The early reflection types and PHASER 2 are variation only, so PHASER 2 falls back to PHASER 1 here.
+* Unknown types use the type with LSB 0, or THRU if that is missing too.
+*
 * @group Synthesizer.XG Effects
 * @sealed
 */
@@ -31133,11 +31417,14 @@ var DefaultXGInsertion = class extends DefaultXGEffect {
 	* Constructs a new default XG insertion processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		super(INSERTION_MAP, XGThru, 18688, sampleRate, maxBufferSize, true);
 	}
+	/**
+	* Resets this block to default values, including the processor type.
+	*/
 	reset() {
 		super.reset();
 		this.partNumber = 127;
@@ -31150,12 +31437,19 @@ var DefaultXGInsertion = class extends DefaultXGEffect {
 			inputRight[i] = outputRight[i];
 		}
 	}
+	/**
+	* Gets a snapshot of this XG effect block.
+	*/
 	getSnapshot() {
 		return {
 			...super.getSnapshot(),
 			partNumber: this.partNumber
 		};
 	}
+	/**
+	* Restores this XG effect block from a snapshot.
+	* @param snapshot The snapshot to restore.
+	*/
 	applySnapshot(snapshot) {
 		super.applySnapshot(snapshot);
 		this.partNumber = snapshot.partNumber;
@@ -31181,9 +31475,28 @@ const InterpolationTypes = {
 	*/
 	nearestNeighbor: 1,
 	/**
-	* Slowest, high quality with little artifacting. (Default)
+	* Cubic Hermite interpolation. Good quality with little artifacting. (Default)
+	*
+	* Recommended for most use-cases.
+	*/
+	hermite: 2,
+	/**
+	* 32-point windowed sinc interpolation.
+	*
+	* Very high quality with almost no aliasing or harmonic distortion,
+	* usable in real time, but at a significantly higher CPU cost.
+	*/
+	sinc32: 3,
+	/**
+	* 128-point windowed sinc interpolation with antialiasing.
+	*
+	* The best quality, but extremely high cpu cost.
+	*
+	* > **Warning**
+	* >
+	* > This is very slow (especially for pitched up samples) and is meant for offline rendering, not real time playback.
 	*/
-	hermite: 2
+	sinc128: 4
 };
 /**
 * The special EFX control sources of a {@link GSInsertionBlock} (EFX CONTROL SOURCE 1/2).
@@ -31612,7 +31925,7 @@ var DefaultGSReverb = class {
 	* Constructs a new default GS reverb processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		this.sampleRate = sampleRate;
@@ -31735,12 +32048,12 @@ var DefaultGSReverb = class {
 		this.updateLowpass();
 	}
 	/**
-	*
-	* @param input 0-based
-	* @param outputLeft startIndex-based
-	* @param outputRight startIndex-based
-	* @param startIndex
-	* @param sampleCount
+	* Process the effect and **adds** it to the output.
+	* @param input The input buffer to process. It always starts at index 0.
+	* @param outputLeft The left output buffer.
+	* @param outputRight The right output buffer.
+	* @param startIndex The index to start mixing at into the output buffers.
+	* @param sampleCount The amount of samples to mix.
 	*/
 	process(input, outputLeft, outputRight, startIndex, sampleCount) {
 		switch (this._character) {
@@ -31879,7 +32192,7 @@ var DefaultGSChorus = class {
 	* Constructs a new default GS chorus processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		this.sampleRate = sampleRate;
@@ -32138,7 +32451,7 @@ var DefaultGSDelay = class {
 	* Constructs a new default GS delay processor.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		this.sampleRate = sampleRate;
@@ -32330,6 +32643,148 @@ var DefaultGSDelay = class {
 		this.gainRight = this._levelRight / 127;
 	}
 };
+// src/synthesizer/audio_engine/effects/gs/implementation/equalizer.ts
+const LOW_FREQUENCIES = [225, 425];
+const HIGH_FREQUENCIES = [3e3, 6e3];
+/**
+* The default GS Equalizer implementation for {@link SpessaSynthProcessor}.
+*
+* @group Synthesizer.GS Effects
+*/
+var DefaultGSEqualizer = class {
+	sampleRate;
+	lowB0 = 1;
+	lowB1 = 0;
+	lowA1 = 0;
+	highB0 = 1;
+	highB1 = 0;
+	highA1 = 0;
+	lowZL = 0;
+	lowZR = 0;
+	highZL = 0;
+	highZR = 0;
+	/**
+	* Constructs a new default GS equalizer processor.
+	* @param sampleRate The sample rate, in Hertz.
+	*/
+	constructor(sampleRate) {
+		this.sampleRate = sampleRate;
+		this.updateLow();
+		this.updateHigh();
+	}
+	_lowFrequency = 0;
+	get lowFrequency() {
+		return this._lowFrequency;
+	}
+	set lowFrequency(value) {
+		this._lowFrequency = value;
+		this.updateLow();
+	}
+	_lowGain = 64;
+	get lowGain() {
+		return this._lowGain;
+	}
+	set lowGain(value) {
+		this._lowGain = value;
+		this.updateLow();
+	}
+	_highFrequency = 0;
+	get highFrequency() {
+		return this._highFrequency;
+	}
+	set highFrequency(value) {
+		this._highFrequency = value;
+		this.updateHigh();
+	}
+	_highGain = 64;
+	get highGain() {
+		return this._highGain;
+	}
+	set highGain(value) {
+		this._highGain = value;
+		this.updateHigh();
+	}
+	process(inputLeft, inputRight, outputLeft, outputRight, startIndex, sampleCount) {
+		const { lowB0, lowB1, lowA1, highB0, highB1, highA1 } = this;
+		let { lowZL, lowZR, highZL, highZR } = this;
+		for (let i = 0; i < sampleCount; i++) {
+			const o = startIndex + i;
+			let x = inputLeft[i];
+			let y = lowB0 * x + lowZL;
+			lowZL = lowB1 * x - lowA1 * y;
+			x = y;
+			y = highB0 * x + highZL;
+			highZL = highB1 * x - highA1 * y;
+			outputLeft[o] += y;
+			x = inputRight[i];
+			y = lowB0 * x + lowZR;
+			lowZR = lowB1 * x - lowA1 * y;
+			x = y;
+			y = highB0 * x + highZR;
+			highZR = highB1 * x - highA1 * y;
+			outputRight[o] += y;
+		}
+		this.lowZL = lowZL;
+		this.lowZR = lowZR;
+		this.highZL = highZL;
+		this.highZR = highZR;
+	}
+	getSnapshot() {
+		return {
+			lowFrequency: this._lowFrequency,
+			lowGain: this._lowGain,
+			highFrequency: this._highFrequency,
+			highGain: this._highGain
+		};
+	}
+	applySnapshot(snapshot) {
+		this.lowFrequency = snapshot.lowFrequency;
+		this.lowGain = snapshot.lowGain;
+		this.highFrequency = snapshot.highFrequency;
+		this.highGain = snapshot.highGain;
+	}
+	getBand(frequency, gain) {
+		const fc = Math.min(frequency, this.sampleRate * .45);
+		const dB = Math.max(-12, Math.min(12, gain - 64));
+		return {
+			k: Math.tan(Math.PI * fc / this.sampleRate),
+			g: 10 ** (Math.abs(dB) / 20),
+			cut: dB < 0
+		};
+	}
+	updateLow() {
+		const { k, g, cut } = this.getBand(LOW_FREQUENCIES[this._lowFrequency & 1], this._lowGain);
+		let b0 = 1 + k;
+		let b1 = k - 1;
+		let a0 = 1 + k / g;
+		let a1 = k / g - 1;
+		if (cut) [b0, b1, a0, a1] = [
+			a0,
+			a1,
+			b0,
+			b1
+		];
+		this.lowB0 = b0 / a0;
+		this.lowB1 = b1 / a0;
+		this.lowA1 = a1 / a0;
+	}
+	updateHigh() {
+		const { k, g, cut } = this.getBand(HIGH_FREQUENCIES[this._highFrequency & 1], this._highGain);
+		let b0 = g * (1 + k);
+		let b1 = g * (k - 1);
+		let a0 = 1 + g * k;
+		let a1 = g * k - 1;
+		if (cut) [b0, b1, a0, a1] = [
+			a0,
+			a1,
+			b0,
+			b1
+		];
+		this.highB0 = b0 / a0;
+		this.highB1 = b1 / a0;
+		this.highA1 = a1 / a0;
+	}
+};
 // src/synthesizer/audio_engine/effects/gs/implementation/dsp/gs_effect.ts
 /**
 * The number of EFX parameters (1-20 in the manuals, 0-19 here).
@@ -32838,6 +33293,16 @@ function prewarp(frequency, sampleRate) {
 	return Math.tan(Math.PI * Math.min(frequency, sampleRate * .49) / sampleRate);
 }
 /**
+* The corner of the hardware's one-pole low pass `(1 - B) x + B y[n-1]` at 32 kHz (-3 dB, the inverse of
+* `FirstOrderFilter.setDamp`).
+* @param pole B.
+* @internal
+*/
+function dampCorner(pole) {
+	const k = (1 + pole * pole) / (2 * pole);
+	return Math.acos(2 - k) * 32e3 / (2 * Math.PI);
+}
+/**
 * A first order section, `y = b0 x + b1 x[n-1] + a1 y[n-1]`, designed with the bilinear transform.
 * The tone filters, the shelves and the DC blockers of the Sound Canvas are all this section.
 * @internal
@@ -39632,7 +40097,7 @@ var GSEqualizer = class extends GSEffect {
 * @param x The argument.
 * @internal
 */
-function besselI0(x) {
+function besselI0$1(x) {
 	let sum = 1;
 	let term = 1;
 	for (let k = 1; k < 32; k++) {
@@ -39648,7 +40113,7 @@ function besselI0(x) {
 * @internal
 */
 function kaiser(t, beta) {
-	return besselI0(beta * Math.sqrt(1 - t * t)) / besselI0(beta);
+	return besselI0$1(beta * Math.sqrt(1 - t * t)) / besselI0$1(beta);
 }
 // src/synthesizer/audio_engine/effects/gs/implementation/dsp/blocks/delay_line.ts
 /**
@@ -42963,7 +43428,7 @@ function cutoff(value) {
 */
 const STEP_MS = 1 / 32;
 /**
-* The longest swing of `modulationDepth` (depth 127), in ms.
+* A bound on the swing of `modulationDepth` (12.4 ms at depth 127), in ms, for sizing the lines.
 * @internal
 */
 const SWING_MS = 12.5;
@@ -43526,7 +43991,8 @@ var Dynamics = class {
 };
 /**
 * The compressor: 1 ms lookahead, the gain recovers linearly, the output has a makeup gain (the "Attack" parameter,
-* which sets how far below the fixed output ceiling the knee sits) and a two-sample average.
+* which sets how far below the fixed output ceiling the knee sits, the manuals call it Sustain, see `GSCompressor`)
+* and a two-sample average.
 * @internal
 */
 var Compressor = class extends Dynamics {
@@ -43670,6 +44136,10 @@ var GSDynamicsEffect = class extends GSEffect {
 * Compressor (`01 30`).
 * Parameters: 1 sustain (how fast the gain comes back), 2 attack (the makeup gain: the output ceiling stays, the
 * knee moves), 3 post gain, then the EQ, pan and level.
+*
+* The SC-VA and SC-8850 manuals list parameter 1 as Attack and 2 as Sustain, the other way round from the names
+* here. Only the names differ: parameter 1 still sets how fast the gain recovers (0.09 to 2.25 per second) and
+* parameter 2 the makeup gain, like in Sound Canvas VA. The multis' compressors and Lo-Fi 1 use the same names.
 * @internal
 */
 var GSCompressor = class extends GSDynamicsEffect {
@@ -46868,7 +47338,7 @@ const LINE_LENGTHS = [
 ];
 /**
 * How many host samples later the whole forward path runs, and how much earlier the outputs read, so that even the
-* shortest pre delay is read band-limited (the interpolator needs 7 newer samples). The outputs read 141 32 kHz
+* shortest pre delay is read band-limited (the interpolator needs 7 newer samples). The outputs read 140 32 kHz
 * samples or more, so they have room.
 */
 const LOOKAHEAD$1 = 8;
@@ -46881,15 +47351,6 @@ const ALLPASS$1 = .5;
 */
 const PRE_GAIN$1 = (127 / 128) ** 2;
 /**
-* The corner of the hardware's one-pole low pass `(1 - B) x + B y[n-1]` at 32 kHz (-3 dB, the inverse of
-* `FirstOrderFilter.setDamp`).
-* @param pole B.
-*/
-function dampCorner(pole) {
-	const k = (1 + pole * pole) / (2 * pole);
-	return Math.acos(2 - k) * 32e3 / (2 * Math.PI);
-}
-/**
 * The Reverb: a mono input through a DC blocker and an input low pass into a pre delay, a diffuser of three
 * Schroeder allpasses and a delay, then two independent tanks (allpass, delay, allpass, delay, a damping low pass
 * and the time gain back to the start). The stereo image comes from the output taps alone, four per side spread
@@ -47597,7 +48058,7 @@ var LoFiQuantizer = class {
 };
 // src/synthesizer/audio_engine/effects/gs/implementation/dsp/effects/lo_fi_1.ts
 /**
-* The gain after the compressor per pre filter (1 bypasses the compressor).
+* The gain after the compressor per pre-ilter (1 bypasses the compressor).
 */
 const PRE_GAINS = [
 	1,
@@ -47652,9 +48113,9 @@ const POST_FILTERS = [
 	}
 ];
 /**
-* Lo-Fi 1 (`01 72`): `L+R -> compressor (pre filter) -> low pass -> quantizer -> high pass and dip (post filter)`,
+* Lo-Fi 1 (`01 72`): `L+R -> compressor (pre-filter) -> low pass -> quantizer -> high pass and dip (post filter)`,
 * mixed with the mono input by the balance, then the EQ and the pan.
-* Parameters: 1 pre filter (1 dry, 2-6 the compressor with a gain of 2 to 7.94, 3 and 5 with a 4 kHz low pass),
+* Parameters: 1 pre-filter (1 dry, 2-6 the compressor with a gain of 2 to 7.94, 3 and 5 with a 4 kHz low pass),
 * 2 lo-fi type (15 or 11 bits at 16000, 10667 or 8000 Hz), 3 post filter (high pass at 633 or 1595 Hz and a dip at
 * 1 kHz of Q 2, 1 or 0.5), 16 balance (the pan law), 17 low gain, 18 high gain, 19 pan, 20 level. EFX control source
 * 1 modulates the balance, source 2 the pan.
@@ -47692,7 +48153,7 @@ var GSLoFi1 = class extends GSEffect {
 	mix;
 	compressor;
 	/**
-	* The compressor's own DC blocker, for the dry path and the pre filter that bypasses it.
+	* The compressor's own DC blocker, for the dry path and the pre-filter that bypasses it.
 	*/
 	dcBlocker;
 	lowPass;
@@ -47891,7 +48352,7 @@ function clamp32(x) {
 *
 * - White (x 1/32) or "pink": the white noise times a 500 Hz saw (on the SC-88Pro too).
 * - Disc: one click per turn of a record at 33 1/3, 45 or 78 rpm, 0.125 + 0.25 abs(saw) while the turn's phase is
-*   within 0.012 % of its wrap. RND adds a second train whose phase is offset by twice the hum's (pseudo-random
+*   within 0.014 % of its wrap. RND adds a second train whose phase is offset by twice the hum's (pseudo-random
 *   times).
 * - Hum: a unipolar 50 or 60 Hz square, 0 or 1/16 (it carries DC, on the hardware too).
 *
@@ -48239,7 +48700,7 @@ var GSLoFi2 = class extends GSEffect {
 		this.chainR = new LoFiShaperChain(sampleRate);
 		this.noise = new NoiseGenerator(sampleRate);
 		this.radioNoise = new FirstOrderFilter(sampleRate);
-		this.radioNoise.setDamp(3500);
+		this.radioNoise.setDamp(dampCorner(.5));
 		this.shelvesL = new ShelfEQ(sampleRate);
 		this.shelvesR = new ShelfEQ(sampleRate);
 		this.pan = new MonoPan(sampleRate);
@@ -50683,8 +51144,9 @@ const MULTI_WAH_GAIN = 3.937744140625;
 const DRIVE_INPUT = 128 / 127;
 const DRIVE_OUTPUT = 127 / 128;
 /**
-* The compressor of the multis (parameters 1-4: sustain, attack, level, switch): the Compressor's dynamics with
-* its post gain at +6 dB and a level after it. The compressor runs when it is switched off too.
+* The compressor of the multis (parameters 1-4: sustain, attack, level, switch, the manuals swap the first two
+* names, see `GSCompressor`): the Compressor's dynamics with its post gain at +6 dB and a level after it. The
+* compressor runs when it is switched off too.
 * @internal
 */
 var MultiCompressor = class {
@@ -51466,10 +51928,10 @@ var GSDriveDelayMulti = class extends GSMulti {
 /**
 * GTR Multi 1 (`04 00`): `L+R -> compressor -> overdrive/distortion -> 2-band EQ -> amp simulator -> chorus/flanger
 * -> delay`.
-* Parameters: 1-4 compressor sustain, attack, level and switch, 5 drive type (OD, DS), 6 drive, 7 amp type, 8 amp
-* switch, 9 low gain, 10 high gain, 11 drive switch, 12 chorus or flanger, 13 rate (Rate2 column), 14 depth,
-* 15 flanger feedback, 16 chorus level, 17 delay time (Dly4 column), 18 feedback, 19 delay level, 20 level.
-* EFX control source 1 moves the drive, source 2 the delay level.
+* Parameters: 1-4 compressor sustain, attack (the manuals swap these two names, see `GSCompressor`), level and
+* switch, 5 drive type (OD, DS), 6 drive, 7 amp type, 8 amp switch, 9 low gain, 10 high gain, 11 drive switch,
+* 12 chorus or flanger, 13 rate (Rate2 column), 14 depth, 15 flanger feedback, 16 chorus level, 17 delay time (Dly4
+* column), 18 feedback, 19 delay level, 20 level. EFX control source 1 moves the drive, source 2 the delay level.
 * @internal
 */
 var GSGuitarMulti1 = class extends GSDriveDelayMulti {
@@ -51644,10 +52106,10 @@ var GSDriveEQMulti = class extends GSMulti {
 };
 /**
 * GTR Multi 2 (`04 01`): `L+R -> compressor -> overdrive/distortion -> amp simulator -> 3-band EQ -> chorus/flanger`.
-* Parameters: 1-4 compressor sustain, attack, level and switch, 5 drive type (OD, DS), 6 drive, 7 amp type, 8 amp
-* switch, 9 drive switch, 10 low gain, 11-13 mid frequency, Q and gain, 14 high gain, 15 chorus or flanger, 16 rate
-* (Rate2 column), 17 depth, 18 flanger feedback, 19 chorus level, 20 level. EFX control source 1 moves the drive,
-* source 2 the chorus level.
+* Parameters: 1-4 compressor sustain, attack (the manuals swap these two names, see `GSCompressor`), level and
+* switch, 5 drive type (OD, DS), 6 drive, 7 amp type, 8 amp switch, 9 drive switch, 10 low gain, 11-13 mid-frequency,
+* Q and gain, 14 high gain, 15 chorus or flanger, 16 rate (Rate2 column), 17 depth, 18 flanger feedback,
+* 19 chorus level, 20 level. EFX control source 1 moves the drive, source 2 the chorus level.
 * @internal
 */
 var GSGuitarMulti2 = class extends GSDriveEQMulti {
@@ -51755,10 +52217,10 @@ var BassAmpSimulator = class {
 /**
 * Bass Multi (`04 05`): `L+R -> compressor -> bass overdrive/distortion -> bass amp simulator -> 3-band EQ ->
 * chorus/flanger`.
-* Parameters: 1-4 compressor sustain, attack, level and switch, 5 drive type (OD, DS), 6 drive, 7 amp type (0-2),
-* 8 amp switch, 9 drive switch, 10 low gain, 11-13 mid frequency, Q and gain, 14 high gain, 15 chorus or flanger,
-* 16 rate (Rate2 column), 17 depth, 18 flanger feedback, 19 chorus level, 20 level. EFX control source 1 moves the
-* drive, source 2 the chorus level.
+* Parameters: 1-4 compressor sustain, attack (the manuals swap these two names, see `GSCompressor`), level and
+* switch, 5 drive type (OD, DS), 6 drive, 7 amp type (0-2), 8 amp switch, 9 drive switch, 10 low gain, 11-13 mid- * frequency,
+* Q and gain, 14 high gain, 15 chorus or flanger, 16 rate (Rate2 column), 17 depth, 18 flanger feedback,
+* 19 chorus level, 20 level. EFX control source 1 moves the drive, source 2 the chorus level.
 * @internal
 */
 var GSBassMulti = class extends GSDriveEQMulti {
@@ -51812,10 +52274,10 @@ var GSBassMulti = class extends GSDriveEQMulti {
 const LINEAR_INPUT = 127 / 128;
 /**
 * Clean GTR Multi 1 (`04 03`): `L+R -> compressor -> 3-band EQ -> chorus/flanger -> delay`.
-* Parameters: 1-4 compressor sustain, attack, level and switch, 5 low gain, 6-8 mid frequency, Q and gain, 9 high
-* gain, 10 chorus or flanger, 11 rate (Rate2 column), 12 depth, 13 flanger feedback, 14 chorus level, 15 delay time
-* (Dly4 column), 16 feedback, 17 HF damp, 18 delay level, 20 level. EFX control source 1 moves the chorus level,
-* source 2 the delay level.
+* Parameters: 1-4 compressor sustain, attack (the manuals swap these two names, see `GSCompressor`), level and
+* switch, 5 low gain, 6-8 mid-frequency, Q and gain, 9 high gain, 10 chorus or flanger, 11 rate (Rate2 column),
+* 12 depth, 13 flanger feedback, 14 chorus level, 15 delay time (Dly4 column), 16 feedback, 17 HF damp, 18 delay
+* level, 20 level. EFX control source 1 moves the chorus level, source 2 the delay level.
 * @internal
 */
 var GSCleanGuitarMulti1 = class extends GSMulti {
@@ -51889,7 +52351,7 @@ var GSCleanGuitarMulti1 = class extends GSMulti {
 * Clean GTR Multi 2 (`04 04`): `L+R -> wah -> 3-band EQ -> chorus/flanger -> delay`. The wah is the Auto Wah's without
 * the envelope follower, its LFO raises the cutoff (polarity up).
 * Parameters: 1 wah filter type (LPF, BPF), 2 manual, 3 peak, 4 rate (Rate1 column), 5 depth, 6 wah switch (SC-VA's
-* code calls it the EQ switch, but it bypasses the wah), 7 low gain, 8-10 mid frequency, Q and gain, 11 high gain,
+* code calls it the EQ switch, but it bypasses the wah), 7 low gain, 8-10 mid-frequency, Q and gain, 11 high gain,
 * 12 chorus or flanger, 13 rate (Rate2 column), 14 depth, 15 flanger feedback, 16 chorus level, 17 delay time (Dly4
 * column), 18 feedback, 19 delay level, 20 level. EFX control source 1 moves the wah manual, source 2 the delay
 * level.
@@ -52107,9 +52569,11 @@ const DEFAULT_CONTROL_DEPTH = 64;
 /**
 * The offset an EFX control source adds to its parameter, like Sound Canvas VA computes it:
 * `(depth - 64) * value / 63`, truncated and stored in a signed byte. Depth 0 counts as 1 (both are -100%).
+* The byte wraps without a clamp, like in SCCore.dll: pitch bend fully down (-128) at depth 0 or 1 gives +128,
+* which is stored as -128, so the offset flips sign there.
 * @param depth The control depth (0-127).
 * @param value The signed controller value.
-* @returns The signed offset.
+* @returns The signed offset (-128 to 127).
 */
 function controlOffset(depth, value) {
 	const amount = (depth === 0 ? 1 : depth) - 64;
@@ -52125,6 +52589,7 @@ var DefaultGSInsertion = class {
 	sendLevelToReverb = DEFAULT_SEND_LEVEL_TO_REVERB;
 	sendLevelToChorus = 0;
 	sendLevelToDelay = 0;
+	sendEQSwitch = true;
 	controlSource1 = GSInsertionControlSources.off;
 	controlDepth1 = DEFAULT_CONTROL_DEPTH;
 	controlSource2 = GSInsertionControlSources.off;
@@ -52167,7 +52632,7 @@ var DefaultGSInsertion = class {
 	* Constructs a new default GS insertion block.
 	* @param sampleRate The sample rate, in Hertz.
 	* @param maxBufferSize The maximum buffer size the synthesizer can render at once.
-	* Attempting to `.process()` more samples than this will result in an error.
+	* Processing more samples than this is not supported and produces undefined output.
 	*/
 	constructor(sampleRate, maxBufferSize) {
 		const memory = new DelayMemory();
@@ -52194,6 +52659,7 @@ var DefaultGSInsertion = class {
 		this.sendLevelToReverb = DEFAULT_SEND_LEVEL_TO_REVERB;
 		this.sendLevelToChorus = 0;
 		this.sendLevelToDelay = 0;
+		this.sendEQSwitch = true;
 	}
 	getType() {
 		return this.type;
@@ -52250,6 +52716,7 @@ var DefaultGSInsertion = class {
 			sendLevelToReverb: this.sendLevelToReverb,
 			sendLevelToChorus: this.sendLevelToChorus,
 			sendLevelToDelay: this.sendLevelToDelay,
+			sendEQSwitch: this.sendEQSwitch,
 			controlSource1: this.controlSource1,
 			controlDepth1: this.controlDepth1,
 			controlSource2: this.controlSource2,
@@ -52270,6 +52737,7 @@ var DefaultGSInsertion = class {
 		this.sendLevelToReverb = snapshot.sendLevelToReverb;
 		this.sendLevelToChorus = snapshot.sendLevelToChorus;
 		this.sendLevelToDelay = snapshot.sendLevelToDelay;
+		this.sendEQSwitch = snapshot.sendEQSwitch ?? true;
 	}
 	/**
 	* Sends the offsets of both control sources to the processor.
@@ -52532,8 +53000,9 @@ var SoundBankManager = class {
 			const bankOffset = s.bankOffset;
 			for (const p of bank.presets) {
 				const selectablePreset = new SoundBankManagerPreset(p, bankOffset);
-				if (!addedPresets.has(selectablePreset.toMIDIString())) {
-					addedPresets.add(selectablePreset.toMIDIString());
+				const key = selectablePreset.toMIDIString();
+				if (!addedPresets.has(key)) {
+					addedPresets.add(key);
 					presetList.push(selectablePreset);
 				}
 			}
@@ -52624,12 +53093,13 @@ for (let pan = MIN_PAN; pan <= MAX_PAN; pan++) {
 }
 /**
 * Computes the LFO value for the given phase.
-* Both waveforms are at zero and rising at the default start phase of 0.25.
+* All waveforms are at zero and rising at the default start phase of 0.25.
 * @param phase the LFO phase, from 0 to 1.
-* @param waveform 0 for triangle, 1 for sawtooth.
+* @param waveform 0 for triangle, 1 for sawtooth, 2 for sine.
 * @returns the LFO value, from -1 to 1.
 */
 function getLfoValue(phase, waveform) {
+	if (waveform === 2) return Math.sin(TWO_PI * (phase - .25));
 	if (waveform === 1) {
 		const p = phase + .25;
 		return 2 * (p >= 1 ? p - 1 : p) - 1;
@@ -52637,10 +53107,11 @@ function getLfoValue(phase, waveform) {
 	return 1 - 4 * Math.abs(phase - .5);
 }
 /**
-* Renders a voice to the stereo output buffer
+* Renders a voice into one of the channel's voice send buffers,
+* which are later mixed into the stereo output and the effect sends.
 * @param voice the voice to render
 * @param timeNow current time in seconds
-* @param sampleCount the only thing needed as it's 0-based
+* @param sampleCount the number of samples to render (the buffers are 0-based, so no offset is needed)
 */
 function renderVoice(voice, timeNow, sampleCount) {
 	if (timeNow < voice.startTime) {
@@ -52902,9 +53373,9 @@ var VoiceSendBuffer = class {
 };
 /**
 * Mixes a voice send buffer into the channel output and the effect sends, then clears it.
-* @param channel
-* @param buffer
-* @param sampleCount
+* @param channel The channel that owns the buffer.
+* @param buffer The voice send buffer to mix.
+* @param sampleCount The number of samples to mix.
 */
 function mixVoiceSendBuffer(channel, buffer, sampleCount) {
 	const core = channel.synthCore;
@@ -53203,7 +53674,7 @@ function handleAWE32NRPN(paramLSB, dataValue) {
 }
 // src/synthesizer/audio_engine/channel/data_entry.ts
 /**
-* Executes a data entry  change for the current channel.
+* Executes a data entry change for the current channel.
 */
 function dataEntry() {
 	const dataValue = this._midiControllers[MIDIControllers.dataEntryMSB];
@@ -53342,7 +53813,7 @@ function dataEntry() {
 			break;
 		case NonRegisteredParameterTypesMSB.drumVariation:
 			this.drumParams[parameterFine].variationSend = dataCoarse;
-			SpessaLog.coolInfo(`Drum ${parameterFine} Variation Send for ${this.channel}`, dataValue, "");
+			SpessaLog.coolInfo(`Drum ${parameterFine} Variation Send for ${this.channel}`, dataCoarse, "");
 			break;
 		case NonRegisteredParameterTypesMSB.awe32:
 			handleAWE32NRPN.call(this, parameterFine, dataValue);
@@ -53675,7 +54146,7 @@ function noteOn(midiNote, velocity, emit = true) {
 // src/synthesizer/audio_engine/channel/note_off.ts
 /**
 * Releases a note by its MIDI note number.
-* If the note is in high performance mode and the channel is not a drum channel,
+* If the synthesizer is in high performance mode and the channel is not a drum channel,
 * or the drum channel has an rxNoteOff enabled,
 * it kills the note instead of releasing it.
 * @param midiNote The MIDI note number to release (0-127).
@@ -53852,7 +54323,7 @@ var DynamicModulatorManager = class {
 			case 5:
 				this.setModulator(source, isCC, GeneratorTypes.vibLfoToVolume, normalizedNotCentered * 200, bipolar, false, true);
 				this.setModulator(source, isCC, GeneratorTypes.initialAttenuation, normalizedNotCentered * 200, bipolar, false, true);
-				SpessaLog.xgInfo(`Channel ${this.channel} ${sourceName} LFO amplitude depth control`, normalizedNotCentered * 200, "dB");
+				SpessaLog.xgInfo(`Channel ${this.channel} ${sourceName} LFO amplitude depth control`, normalizedNotCentered * 200, "cB");
 		}
 	}
 	setupReceiverGS(addr3, data, source, isCC, sourceName, bipolar = false) {
@@ -54099,6 +54570,7 @@ const DEFAULT_CHANNEL_MIDI_PARAMETERS = {
 	randomPan: false,
 	assignMode: 2,
 	efxAssign: false,
+	eqEnabled: true,
 	cc1: 16,
 	cc2: 17,
 	drumMap: 0,
@@ -54259,6 +54731,7 @@ var MIDIChannel = class {
 	/**
 	* If true, this skips sends as they all go through insertion.
 	* Set by {@link SpessaSynthProcessor}.
+	* @internal
 	*/
 	xgInsertionAssigned = false;
 	/**
@@ -54333,8 +54806,8 @@ var MIDIChannel = class {
 	*/
 	resetRP15 = resetRP15.bind(this);
 	/**
-	* Executes a data entry coarse (MSB) change for the current channel.
-	* @param dataValue The value to set for the data entry coarse controller (0-127).
+	* Executes a data entry (MSB or LSB) change for the current channel.
+	* The value is read from the controller table and applied to the selected RPN or NRPN.
 	* @internal
 	*/
 	dataEntry = dataEntry.bind(this);
@@ -54589,7 +55062,7 @@ var MIDIChannel = class {
 	noteOn(midiNote, velocity, emit = true) {}
 	/**
 	* Releases a note by its MIDI note number.
-	* If the note is in high performance mode and the channel is not a drum channel,
+	* If the synthesizer is in high performance mode and the channel is not a drum channel,
 	* or the drum channel has an rxNoteOff enabled,
 	* it kills the note instead of releasing it.
 	* @param midiNote The MIDI note number to release (0-127).
@@ -54618,14 +55091,16 @@ var MIDIChannel = class {
 	/**
 	* Reset this channel to its default state.
 	* Except for the locked controllers.
+	* @param sendEvent If controller change events should be emitted for the reset controllers.
 	* @internal
 	*/
 	reset(sendEvent = true) {}
 	/**
-	* Renders a voice to the stereo output buffer
+	* Renders a voice into one of the channel's voice send buffers,
+	* which are later mixed into the stereo output and the effect sends.
 	* @param voice the voice to render
 	* @param timeNow current time in seconds
-	* @param sampleCount the only thing needed as it's 0-based
+	* @param sampleCount the number of samples to render (the buffers are 0-based, so no offset is needed)
 	* @internal
 	*/
 	renderVoice(voice, timeNow, sampleCount) {}
@@ -54970,6 +55445,7 @@ const DEFAULT_GLOBAL_SYSTEM_PARAMETERS = {
 	xgChorusLock: false,
 	gsDelayGain: 1,
 	gsDelayLock: false,
+	gsEqualizerLock: false,
 	xgVariationGain: 1,
 	xgVariationLock: false,
 	gsInsertionLock: false,
@@ -55207,7 +55683,7 @@ var LowpassFilter = class LowpassFilter {
 		const qCb = this.resonanceCb;
 		let cutoffHz = absCentsToHz(cutoffCents);
 		cutoffHz = Math.min(cutoffHz, this.maxCutoff);
-		const resonanceGain = cbAttenuationToGain(-(qCb - 3.01));
+		const resonanceGain = cbAttenuationToGain(-(qCb - 30.1));
 		const qGain = 1 / Math.sqrt(cbAttenuationToGain(-qCb));
 		const w = 2 * Math.PI * cutoffHz / this.sampleRate;
 		const cosw = Math.cos(w);
@@ -55254,7 +55730,7 @@ var VolumeEnvelope = class {
 	/**
 	* The sample count between updates of the volume envelope.
 	* Since the volume envelope calculation runs once per rendering quantum,
-	* this effectively the buffer size.
+	* this is effectively the buffer size.
 	*/
 	updateInterval;
 	/**
@@ -55262,11 +55738,11 @@ var VolumeEnvelope = class {
 	*/
 	sampleTime = 0;
 	/**
-	* The dB attenuation of the envelope when it entered the release stage.
+	* The cB attenuation of the envelope when it entered the release stage.
 	*/
 	releaseStartCb = CB_SILENCE;
 	/**
-	* The time in samples relative to the start of the envelope.
+	* The time in samples when the release stage started, relative to the start of the envelope.
 	*/
 	releaseStartTimeSamples = 0;
 	/**
@@ -55405,10 +55881,10 @@ var VolumeEnvelope = class {
 	}
 	/**
 	* Calculates the gain value for the last sample in the block and writes it to `outputGain`.
-	* Essentially we use approach of 100dB is silence, 0dB is peak.
-	* @param sampleCount the amount of samples to write
+	* Essentially we use approach of 96 dB (CB_SILENCE) is silence, 0dB is peak.
+	* @param sampleCount the amount of samples in the block to advance the envelope by.
 	* @param gainTarget the gain to apply.
-	* @returns if the voice has finished.
+	* @returns if the voice is still active (false once the envelope has finished).
 	*/
 	process(sampleCount, gainTarget) {
 		const { releaseStartTimeSamples, releaseStartCb, releaseDuration, delayEnd, attackEnd, attackDuration, holdEnd, decayEnd, decayDuration, sustainCb, decay2End, decay2Duration, sustain2Cb } = this;
@@ -55566,7 +56042,7 @@ var ModulationEnvelope = class {
 	* Calculates the current modulation envelope value for the given time and voice.
 	* @param voice the voice we are working on.
 	* @param currentTime in seconds.
-	* @returns  mod env value, from 0 to 1.
+	* @returns mod env value, from 0 to 1.
 	*/
 	process(voice, currentTime) {
 		if (this.enteredRelease) {
@@ -55839,6 +56315,217 @@ var HermiteOscillator = class extends WavetableOscillator {
 		return true;
 	}
 };
+// src/synthesizer/audio_engine/voice/wavetable_oscillator/sinc.ts
+/**
+* Kernel resolution, the amount of table points per sample of distance.
+* The table is linearly interpolated, which keeps the error around -120 dB.
+*/
+const OVERSAMPLING = 256;
+/**
+* The highest playback step the anti-aliased kernel gets stretched to.
+* The tap count grows with the step, so this keeps extreme pitch ups from becoming too slow.
+* Above it, the content between the new Nyquist frequency and 1/16 of the old one folds back.
+*/
+const MAX_STRETCH = 16;
+/**
+* Zeroth order modified Bessel function of the first kind, for the Kaiser window.
+* @param x
+*/
+function besselI0(x) {
+	const q = x * x / 4;
+	let sum = 1;
+	let term = 1;
+	for (let k = 1; k < 100; k++) {
+		term *= q / (k * k);
+		sum += term;
+		if (term < sum * 1e-17) break;
+	}
+	return sum;
+}
+/**
+* Builds a Kaiser windowed sinc kernel.
+* @param halfWidth Half of the kernel width, in samples. The kernel uses `2 * halfWidth` taps.
+* @param bandwidth The cutoff (-6 dB point) of the kernel, relative to the Nyquist frequency.
+* @param beta The Kaiser window beta, controls the stopband attenuation.
+*/
+function buildKernel(halfWidth, bandwidth, beta) {
+	const windowNorm = besselI0(beta);
+	const kernel = (x) => {
+		const w = x / halfWidth;
+		if (w <= -1 || w >= 1) return 0;
+		const window = besselI0(beta * Math.sqrt(1 - w * w)) / windowNorm;
+		const u = Math.PI * bandwidth * x;
+		return bandwidth * (u === 0 ? 1 : Math.sin(u) / u) * window;
+	};
+	const taps = halfWidth * 2;
+	const rows = new Float64Array(taps * 257);
+	for (let q = 0; q <= OVERSAMPLING; q++) {
+		const row = q * taps;
+		let sum = 0;
+		for (let k = 0; k < taps; k++) {
+			const v = kernel(k + 1 - halfWidth - q / OVERSAMPLING);
+			rows[row + k] = v;
+			sum += v;
+		}
+		for (let k = 0; k < taps; k++) rows[row + k] /= sum;
+	}
+	const phases = new Float32Array(taps * OVERSAMPLING);
+	const phaseDeltas = new Float32Array(taps * OVERSAMPLING);
+	for (let i = 0; i < phases.length; i++) {
+		phases[i] = rows[i];
+		phaseDeltas[i] = rows[i + taps] - rows[i];
+	}
+	const tableLength = halfWidth * 2 * OVERSAMPLING + 2;
+	const table = new Float32Array(tableLength);
+	const tableDeltas = new Float32Array(tableLength);
+	for (let i = 0; i < tableLength; i++) table[i] = kernel(i / OVERSAMPLING - halfWidth);
+	for (let i = 0; i < tableLength - 1; i++) tableDeltas[i] = table[i + 1] - table[i];
+	return {
+		halfWidth,
+		phases,
+		phaseDeltas,
+		table,
+		tableDeltas
+	};
+}
+/**
+* 32 points, meant for real time playback.
+*/
+const KERNEL_FAST = buildKernel(16, .92, 9);
+/**
+* 128 points, for offline rendering.
+*/
+const KERNEL_BEST = buildKernel(64, .975, 12);
+var SincOscillator = class extends WavetableOscillator {
+	kernel;
+	/**
+	* If the kernel gets stretched when the playback step is above 1.
+	* This lowers the cutoff to the new Nyquist frequency so the sample content above it does not alias.
+	*/
+	antiAlias;
+	/**
+	* The points around the cursor, gathered here when they need wrapping around the loop
+	* or are outside the sample.
+	*/
+	scratch;
+	/**
+	* Creates a new windowed sinc oscillator.
+	* @param best If true, uses the larger, anti-aliased kernel. It is too slow for real time playback.
+	*/
+	constructor(best) {
+		super();
+		this.kernel = best ? KERNEL_BEST : KERNEL_FAST;
+		this.antiAlias = best;
+		this.scratch = new Float32Array(best ? Math.ceil(this.kernel.halfWidth * MAX_STRETCH) * 2 + 2 : this.kernel.halfWidth * 2);
+	}
+	process(sampleCount, tuningRatio, outputBuffer) {
+		const step = tuningRatio * this.playbackStep;
+		const sampleData = this.sampleData;
+		const scratch = this.scratch;
+		const { loopStart, loopEnd, loopLength, end, isLooping } = this;
+		const { halfWidth } = this.kernel;
+		let cursor = this.cursor;
+		let hasLooped = this.hasLooped;
+		const upperLimit = isLooping ? loopEnd : end;
+		const stretch = this.antiAlias && step > 1 ? Math.min(step, MAX_STRETCH) : 1;
+		if (stretch === 1) {
+			const { phases, phaseDeltas } = this.kernel;
+			const taps = halfWidth * 2;
+			for (let i = 0; i < sampleCount; i++) {
+				if (isLooping) {
+					if (cursor >= loopEnd) {
+						hasLooped = true;
+						while (cursor >= loopEnd) cursor -= loopLength;
+					}
+				} else if (cursor + 1 >= end) {
+					outputBuffer.fill(0, i, sampleCount);
+					this.cursor = cursor;
+					return false;
+				}
+				const y0 = cursor | 0;
+				let first = y0 + 1 - halfWidth;
+				let source = sampleData;
+				if (first < (isLooping && hasLooped ? loopStart : 0) || first + taps > upperLimit) {
+					this.gather(first, taps, hasLooped);
+					source = scratch;
+					first = 0;
+				}
+				const phase = (cursor - y0) * OVERSAMPLING;
+				const q = phase | 0;
+				let row = q * taps;
+				const fraction = phase - q;
+				const rowEnd = row + taps;
+				let out = 0;
+				for (; row < rowEnd; row++) out += source[first++] * (phases[row] + phaseDeltas[row] * fraction);
+				outputBuffer[i] = out;
+				cursor += step;
+			}
+		} else {
+			const { table, tableDeltas } = this.kernel;
+			const reach = halfWidth * stretch;
+			const tableStep = OVERSAMPLING / stretch;
+			const center = halfWidth * OVERSAMPLING;
+			const gain = 1 / stretch;
+			for (let i = 0; i < sampleCount; i++) {
+				if (isLooping) {
+					if (cursor >= loopEnd) {
+						hasLooped = true;
+						while (cursor >= loopEnd) cursor -= loopLength;
+					}
+				} else if (cursor + 1 >= end) {
+					outputBuffer.fill(0, i, sampleCount);
+					this.cursor = cursor;
+					return false;
+				}
+				let first = Math.floor(cursor - reach) + 1;
+				const taps = Math.floor(cursor + reach) - first + 1;
+				let position = (first - cursor) * tableStep + center;
+				let source = sampleData;
+				if (first < (isLooping && hasLooped ? loopStart : 0) || first + taps > upperLimit) {
+					this.gather(first, taps, hasLooped);
+					source = scratch;
+					first = 0;
+				}
+				let out = 0;
+				const last = first + taps;
+				for (; first < last; first++) {
+					const index = position | 0;
+					out += source[first] * (table[index] + tableDeltas[index] * (position - index));
+					position += tableStep;
+				}
+				outputBuffer[i] = out * gain;
+				cursor += step;
+			}
+		}
+		this.cursor = cursor;
+		this.hasLooped = hasLooped;
+		return true;
+	}
+	/**
+	* Copies the points into the scratch buffer, wrapping them around the loop.
+	* Points outside the sample are silent.
+	* @param first The index of the first point.
+	* @param count The amount of points.
+	* @param hasLooped If the cursor has already looped.
+	*/
+	gather(first, count, hasLooped) {
+		const sampleData = this.sampleData;
+		const scratch = this.scratch;
+		const { loopStart, loopEnd, loopLength, end } = this;
+		if (this.isLooping) {
+			let index = first;
+			if (index >= loopEnd) index = loopStart + (index - loopStart) % loopLength;
+			else if (index < loopStart && hasLooped) index = loopEnd - 1 - (loopStart - 1 - index) % loopLength;
+			for (let k = 0; k < count; k++) {
+				scratch[k] = index < 0 ? 0 : sampleData[index];
+				if (++index >= loopEnd) index = loopStart;
+			}
+		} else for (let k = 0; k < count; k++) {
+			const index = first + k;
+			scratch[k] = index >= 0 && index < end ? sampleData[index] : 0;
+		}
+	}
+};
 // src/synthesizer/audio_engine/voice/voice.ts
 /**
 * Voice.ts
@@ -55863,7 +56550,9 @@ var Voice = class {
 	oscillators = [
 		new LinearOscillator(),
 		new NearestOscillator(),
-		new HermiteOscillator()
+		new HermiteOscillator(),
+		new SincOscillator(false),
+		new SincOscillator(true)
 	];
 	/**
 	* The oscillator currently used by this voice.
@@ -55950,7 +56639,7 @@ var Voice = class {
 	* This is the effective MIDI note number,
 	* used to calculate scale tuning and envelope times,
 	* and can be overridden by generators.
-	* It is also used
+	* It is also used for the octave tuning and as the portamento target.
 	*/
 	targetKey = 0;
 	/**
@@ -56043,7 +56732,9 @@ var Voice = class {
 		this.filter = new LowpassFilter(sampleRate);
 	}
 	/**
-	* Releases the voice as exclusiveClass.
+	* Releases the voice as exclusiveClass, with a nearly instant release time.
+	* @param currentTime the current time in seconds.
+	* @param minExclusiveLength minimum note length in seconds.
 	*/
 	exclusiveRelease(currentTime, minExclusiveLength = MIN_EXCLUSIVE_LENGTH) {
 		this.overrideReleaseVolEnv = EXCLUSIVE_CUTOFF_TIME;
@@ -56051,8 +56742,9 @@ var Voice = class {
 		this.releaseVoice(currentTime, minExclusiveLength);
 	}
 	/**
-	* Stops the voice
-	* @param currentTime
+	* Releases the voice. The release phase starts on the first render at or after the release time,
+	* which is pushed back if the note would be shorter than the minimum length.
+	* @param currentTime the current time in seconds.
 	* @param minNoteLength minimum note length in seconds
 	*/
 	releaseVoice(currentTime, minNoteLength = MIN_NOTE_LENGTH) {
@@ -56190,7 +56882,7 @@ function lockMIDIParameterInternal(parameter, isLocked) {
 * @param byte1 The first byte (midi note).
 * @param byte2 The second byte (most significant bits).
 * @param byte3 The third byte (the least significant bits).
-* @return An object containing the MIDI note and the cent tuning value.
+* @returns The MIDI note with the fraction added (in semitones), or -1 for no change.
 */
 function getTuning(byte1, byte2, byte3) {
 	const midiNote = byte1;
@@ -56354,8 +57046,8 @@ function universalSystemExclusive(syx, channelOffset = 0) {
 					const program = syx[currentMessageIndex++];
 					const tuningName = readBinaryString(syx, 16, currentMessageIndex);
 					currentMessageIndex += 16;
-					if (syx.length < 384) {
-						SpessaLog.warn(`The Bulk Tuning Dump is too short! (${syx.length} bytes, at least 384 are expected)`);
+					if (syx.length < 405) {
+						SpessaLog.warn(`The Bulk Tuning Dump is too short! (${syx.length} bytes, at least 405 are expected)`);
 						return;
 					}
 					for (let midiNote = 0; midiNote < 128; midiNote++) this.tunings[program * 128 + midiNote] = getTuning(syx[currentMessageIndex++], syx[currentMessageIndex++], syx[currentMessageIndex++]);
@@ -56766,6 +57458,27 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 					}
 					break;
 				}
+				if (a2 === 2) {
+					if (this.systemParameters.gsEqualizerLock) return;
+					const parameter = [
+						"lowFrequency",
+						"lowGain",
+						"highFrequency",
+						"highGain"
+					][a3];
+					if (parameter === void 0) {
+						SpessaLog.gsFail("Equalizer", [a3]);
+						return;
+					}
+					this.gsEqualizerProcessor[parameter] = data;
+					SpessaLog.gsInfo(`EQ ${parameter}`, data);
+					this.callEvent("effectChange", {
+						effect: "gsEqualizer",
+						parameter,
+						value: data
+					});
+					return;
+				}
 				if (a2 === 3) {
 					if (this.systemParameters.gsInsertionLock) return;
 					const insertion = this.gsInsertionBlock;
@@ -56842,6 +57555,17 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							});
 							return;
 						}
+						case 31: {
+							const on = data !== 0;
+							insertion.sendEQSwitch = on;
+							SpessaLog.gsInfo("EFX Send EQ Switch", on ? "ON" : "OFF");
+							this.callEvent("effectChange", {
+								effect: "gsInsertion",
+								parameter: "sendEQSwitch",
+								value: on
+							});
+							return;
+						}
 					}
 				}
 				if (a2 >> 4 === 1) {
@@ -57028,6 +57752,12 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						case 1:
 							ch.controllerChange(MIDIControllers.bankSelectLSB, data);
 							break;
+						case 32: {
+							const eq = data === 1;
+							ch.setMIDIParameter("eqEnabled", eq);
+							SpessaLog.gsInfo(`EQ for ${channel}`, eq ? "ON" : "OFF");
+							break;
+						}
 						case 34: {
 							const efx = data === 1;
 							ch.setMIDIParameter("efxAssign", efx);
@@ -57799,8 +58529,8 @@ function yamahaSystemExclusive(syx, channelOffset = 0) {
 					for (const ch of this.midiChannels) {
 						if (ch.midiParameters.drumMap !== setupNumber) continue;
 						ch.drumParams[drumKey].pitchFine = pitch;
-						SpessaLog.xgInfo(`Drum Pitch Fine for key ${drumKey}`, pitch, "semitones");
 					}
+					SpessaLog.xgInfo(`Drum Pitch Fine for key ${drumKey}`, pitch, "cents");
 					break;
 				}
 				case 2:
@@ -57933,7 +58663,7 @@ function applyPresetZones(indexes, presetGens, presetMods, instruments, presets)
 }
 // src/soundbank/soundfont/read/presets.ts
 /**
-* Parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
+* Parses soundfont presets
 */
 var SoundFontPreset = class extends BasicPreset {
 	zoneStartIndex;
@@ -58030,7 +58760,7 @@ function readInstruments(instrumentChunk, keepTerminal = false) {
 }
 // src/soundbank/soundfont/read/modulators.ts
 /**
-* Reads the modulator read
+* Reads the modulators
 * @param modulatorChunk pmod, imod or DMOD
 * @param allowSFEGenerators if destinations above endOper are allowed (SFE banks)
 */
@@ -58375,11 +59105,16 @@ function applySnapshot(snapshot) {
 	this.gsReverbProcessor.applySnapshot(snapshot.gsReverbProcessor);
 	this.gsChorusProcessor.applySnapshot(snapshot.gsChorusProcessor);
 	this.gsDelayProcessor.applySnapshot(snapshot.gsDelayProcessor);
+	if (snapshot.gsEqualizerProcessor) this.gsEqualizerProcessor.applySnapshot(snapshot.gsEqualizerProcessor);
 	this.gsInsertionBlock.applySnapshot(snapshot.gsInsertionBlock);
 	this.xgReverbBlock.applySnapshot(snapshot.xgReverbBlock);
 	this.xgChorusBlock.applySnapshot(snapshot.xgChorusBlock);
 	this.xgVariationBlock.applySnapshot(snapshot.xgVariationBlock);
-	for (let i = 0; i < this.xgInsertionBlocks.length; i++) this.xgInsertionBlocks[i].applySnapshot(snapshot.xgInsertionBlocks[i]);
+	for (let i = 0; i < this.xgInsertionBlocks.length; i++) {
+		const insertion = this.xgInsertionBlocks[i];
+		if (i < snapshot.xgInsertionBlocks.length) insertion.applySnapshot(snapshot.xgInsertionBlocks[i]);
+		else insertion.reset();
+	}
 	for (let drumSet = 0; drumSet < snapshot.userDrumSets.length; drumSet++) {
 		const userDrumSet = snapshot.userDrumSets[drumSet];
 		for (let midiNote = 0; midiNote < userDrumSet.length; midiNote++) DrumParameterUtils.copyIntoUser(userDrumSet[midiNote], this.soundBankManager.userDrumSets[drumSet].keyParams[midiNote]);
@@ -58399,6 +59134,7 @@ function getSynthesizerSnapshot() {
 		gsReverbProcessor: this.gsReverbProcessor.getSnapshot(),
 		gsChorusProcessor: this.gsChorusProcessor.getSnapshot(),
 		gsDelayProcessor: this.gsDelayProcessor.getSnapshot(),
+		gsEqualizerProcessor: this.gsEqualizerProcessor.getSnapshot(),
 		gsInsertionBlock: this.gsInsertionBlock.getSnapshot(),
 		xgReverbBlock: this.xgReverbBlock.getSnapshot(),
 		xgChorusBlock: this.xgChorusBlock.getSnapshot(),
@@ -58411,7 +59147,8 @@ function getSynthesizerSnapshot() {
 /**
 * Keeps the decoded sample data under a size budget by releasing the least recently used samples.
 * A released sample decodes again the next time it plays.
-* Samples that cannot decode again (replaced float data) are never released.
+* Samples that cannot decode again (replaced float data) are never released
+* and are not tracked, so they do not count towards the budget.
 * @internal
 */
 var DecodedSampleCache = class {
@@ -58424,6 +59161,7 @@ var DecodedSampleCache = class {
 	*/
 	totalBytes = 0;
 	entries = /* @__PURE__ */ new Map();
+	unreleasable = /* @__PURE__ */ new WeakSet();
 	voiceCache;
 	/**
 	* @param budget The budget in bytes.
@@ -58444,7 +59182,11 @@ var DecodedSampleCache = class {
 	touch(sample, cacheKey) {
 		let entry = this.entries.get(sample);
 		if (entry) this.entries.delete(sample);
-		else {
+		if (this.unreleasable.has(sample) || sample.storedForm === "float32" && !(sample instanceof DLSSample)) {
+			if (entry) this.totalBytes -= entry.bytes;
+			return;
+		}
+		if (!entry) {
 			entry = {
 				bytes: sample.getAudioData().byteLength,
 				cacheKeys: /* @__PURE__ */ new Set()
@@ -58461,7 +59203,10 @@ var DecodedSampleCache = class {
 			if (sample === keep) continue;
 			this.entries.delete(sample);
 			this.totalBytes -= entry.bytes;
-			sample.releaseDecoded();
+			if (!sample.releaseDecoded()) {
+				this.unreleasable.add(sample);
+				continue;
+			}
 			for (const key of entry.cacheKeys) this.voiceCache.delete(key);
 		}
 	}
@@ -58504,6 +59249,16 @@ const GS_CHORUS_MACRO_PARAMETERS = [
 	"sendLevelToDelay"
 ];
 /**
+* The default GS equalizer parameters (SC-8850 manual p.236).
+*/
+const DEFAULT_GS_EQUALIZER = {
+	lowFrequency: 0,
+	lowGain: 64,
+	highFrequency: 0,
+	highGain: 64
+};
+const GS_EQUALIZER_PARAMETERS = Object.keys(DEFAULT_GS_EQUALIZER);
+/**
 * The GS delay parameters set by the delay macro.
 */
 const GS_DELAY_MACRO_PARAMETERS = [
@@ -58596,7 +59351,7 @@ var SpessaSynthProcessor = class {
 	*/
 	sharedVoiceSendBuffer;
 	/**
-	* The insertion processor's left input buffer.
+	* The GS insertion processor's left input buffer.
 	* @internal
 	*/
 	insertionInputL;
@@ -58606,6 +59361,16 @@ var SpessaSynthProcessor = class {
 	*/
 	insertionInputR;
 	/**
+	* The GS equalizer's left input buffer.
+	* @internal
+	*/
+	equalizerInputL;
+	/**
+	* The GS equalizer's right input buffer.
+	* @internal
+	*/
+	equalizerInputR;
+	/**
 	* The GS reverb processor's input buffer.
 	* @internal
 	*/
@@ -58801,11 +59566,6 @@ var SpessaSynthProcessor = class {
 	*/
 	cachedVoices = /* @__PURE__ */ new Map();
 	/**
-	* Keeps the decoded sample data under the budget from the options.
-	* @internal
-	*/
-	decodedSamples;
-	/**
 	* Insertion is not used outside SC-88Pro+ MIDIs, this is an optimization.
 	* @internal
 	*/
@@ -58828,6 +59588,11 @@ var SpessaSynthProcessor = class {
 	*/
 	gsInsertionBlock;
 	/**
+	* Keeps the decoded sample data under the budget from the options.
+	* @internal
+	*/
+	decodedSamples;
+	/**
 	* The synthesizer's GS reverb processor.
 	*
 	* Used when {@link GlobalMIDIParameter.system} is `gm` `gm2` or `gs`.
@@ -58849,6 +59614,13 @@ var SpessaSynthProcessor = class {
 	*/
 	gsDelayProcessor;
 	/**
+	* The synthesizer's GS equalizer processor.
+	*
+	* Used when {@link GlobalMIDIParameter.system} is `gm` `gm2` or `gs`.
+	* @internal
+	*/
+	gsEqualizerProcessor;
+	/**
 	* The synthesizer's XG reverb block.
 	*
 	* Used when {@link GlobalMIDIParameter.system} is `xg`.
@@ -58856,7 +59628,7 @@ var SpessaSynthProcessor = class {
 	*/
 	xgReverbBlock;
 	/**
-	* The synthesizer's XG reverb block.
+	* The synthesizer's XG chorus block.
 	*
 	* Used when {@link GlobalMIDIParameter.system} is `xg`.
 	* @internal
@@ -58932,6 +59704,7 @@ var SpessaSynthProcessor = class {
 		this.gsReverbProcessor = options.gsReverbProcessor ?? new DefaultGSReverb(sampleRate, bufSize);
 		this.gsChorusProcessor = options.gsChorusProcessor ?? new DefaultGSChorus(sampleRate, bufSize);
 		this.gsDelayProcessor = options.gsDelayProcessor ?? new DefaultGSDelay(sampleRate, bufSize);
+		this.gsEqualizerProcessor = options.gsEqualizerProcessor ?? new DefaultGSEqualizer(sampleRate);
 		this.gsInsertionBlock = options.gsInsertionBlock ?? new DefaultGSInsertion(sampleRate, bufSize);
 		this.xgReverbBlock = options.xgReverbBlock ?? new DefaultXGReverb(sampleRate, bufSize);
 		this.xgChorusBlock = options.xgChorusBlock ?? new DefaultXGChorus(sampleRate, bufSize);
@@ -58941,6 +59714,8 @@ var SpessaSynthProcessor = class {
 		this.sharedVoiceSendBuffer = new VoiceSendBuffer(bufSize);
 		this.insertionInputL = new Float32Array(bufSize);
 		this.insertionInputR = new Float32Array(bufSize);
+		this.equalizerInputL = new Float32Array(bufSize);
+		this.equalizerInputR = new Float32Array(bufSize);
 		this.gsReverbInput = new Float32Array(bufSize);
 		this.gsChorusInput = new Float32Array(bufSize);
 		this.gsDelayInput = new Float32Array(bufSize);
@@ -58978,6 +59753,13 @@ var SpessaSynthProcessor = class {
 		return this._voiceCount;
 	}
 	/**
+	* The decoded sample data kept under {@link SynthProcessorOptions.decodedSampleBudget}, in bytes.
+	* It is only counted when a budget is set.
+	*/
+	get decodedSampleBytes() {
+		return this.decodedSamples.totalBytes;
+	}
+	/**
 	* Locks or unlocks a given {@link GlobalMIDIParameter}.
 	* This prevents any changes to it until it's unlocked.
 	* @param parameter The Global MIDI Parameter to lock.
@@ -59010,7 +59792,7 @@ var SpessaSynthProcessor = class {
 	* > Refer to the [MIDI Implementation](../../docs/extra/midi-implementation.md)
 	* > for the list of supported System Exclusives.
 	*
-	* @param syx The system exclusive message as an array of bytes.
+	* @param syx The system exclusive message as an array of bytes, without the starting `F0` byte.
 	* @param channelOffset The channel offset for the message as they usually can only address the first 16 channels.
 	* For example, to send a system exclusive on channel 16,
 	* send a system exclusive for channel 0 and set an offset of 16.
@@ -59232,11 +60014,11 @@ var SpessaSynthProcessor = class {
 		for (const message of messages) this.processMessage(message, channelOffset, options);
 	}
 	/**
-	*  Destroy the synthesizer processor, clearing all channels and voices.
+	* Destroy the synthesizer processor, clearing all channels and voices.
 	*
-	*  > **Warning**
-	*  >
-	*  > This is irreversible, so use with caution.
+	* > **Warning**
+	* >
+	* > This is irreversible, so use with caution.
 	*/
 	destroy() {
 		this.voices.length = 0;
@@ -59264,6 +60046,9 @@ var SpessaSynthProcessor = class {
 	* >
 	* > This method overrides the existing System Parameters with the ones from the snapshot.
 	*
+	* If this processor has more XG insertion blocks than the snapshot,
+	* the blocks without snapshot data are reset to their defaults.
+	*
 	* @param snapshot The snapshot to apply.
 	*/
 	applySnapshot(snapshot) {
@@ -59325,6 +60110,17 @@ var SpessaSynthProcessor = class {
 		this.setReverbMacro(4);
 		this.setChorusMacro(2);
 		this.setDelayMacro(0);
+		if (!this.systemParameters.gsEqualizerLock) {
+			const eq = this.gsEqualizerProcessor;
+			for (const parameter of GS_EQUALIZER_PARAMETERS) {
+				eq[parameter] = DEFAULT_GS_EQUALIZER[parameter];
+				this.callEvent("effectChange", {
+					effect: "gsEqualizer",
+					parameter,
+					value: eq[parameter]
+				});
+			}
+		}
 		if (!this.systemParameters.gsInsertionLock) {
 			this.gsInsertionBlock.reset();
 			this.callEvent("effectChange", {
@@ -59481,10 +60277,10 @@ var SpessaSynthProcessor = class {
 		*              │          │ │    Chorus     │                │
 		*              │          │ │   Processor   ├──────────┐     │
 		*              │          │ └─┬──────────┬──┘          │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
+		*         ┌────┴────┐     │   │          │             │     │
+		*         │Equalizer│     │   │          │             │     │
+		*         │or Bypass│     │   │          │             │     │
+		*         └────┬────┘     │   │          │             │     │
 		*              │          │   │          𜸊             𜸊     𜸊
 		*              │          │   │ ┌────────┴───────┐   ┌─┴─────┴────────┐
 		*              │          └───┼>┤     Delay      ├─>>┤     Reverb     │
@@ -59513,6 +60309,7 @@ var SpessaSynthProcessor = class {
 		const isXG = this.midiParameters.system === "xg";
 		const variationInsertion = this.xgVariationBlock.insertionMode;
 		const fx = this.systemParameters.effectsEnabled;
+		const eq = fx && !isXG;
 		if (isXG && fx) {
 			for (const channel of this.midiChannels) channel.xgInsertionAssigned = false;
 			for (const insertion of this.xgInsertionBlocks) {
@@ -59528,6 +60325,10 @@ var SpessaSynthProcessor = class {
 			this.insertionInputL.fill(0);
 			this.insertionInputR.fill(0);
 		}
+		if (eq) {
+			this.equalizerInputL.fill(0);
+			this.equalizerInputR.fill(0);
+		}
 		for (const c of this.midiChannels) {
 			c.clearVoiceCount();
 			if (c.outputDirty) {
@@ -59573,10 +60374,11 @@ var SpessaSynthProcessor = class {
 				const channel = this.midiChannels[this.xgVariationBlock.partNumber];
 				if (channel) this.processXGInsertion(this.xgVariationBlock, channel, sampleCount);
 			}
+			const { reverbGain, chorusGain } = this.systemParameters;
 			for (const ch of this.midiChannels) {
 				if (!ch.xgInsertionAssigned) continue;
-				const revSend = (ch.midiControllers[MIDIControllers.reverbDepth] >> 7) / 127;
-				const choSend = (ch.midiControllers[MIDIControllers.chorusDepth] >> 7) / 127;
+				const revSend = reverbGain * (ch.midiControllers[MIDIControllers.reverbDepth] >> 7) / 127;
+				const choSend = chorusGain * (ch.midiControllers[MIDIControllers.chorusDepth] >> 7) / 127;
 				if (revSend <= 0 && choSend <= 0) continue;
 				const { outputLeft, outputRight } = ch;
 				for (let i = 0; i < sampleCount; i++) {
@@ -59612,6 +60414,15 @@ var SpessaSynthProcessor = class {
 				}
 				continue;
 			}
+			if (eq && midiParameters.eqEnabled) {
+				const equalizerL = this.equalizerInputL;
+				const equalizerR = this.equalizerInputR;
+				for (let i = 0; i < sampleCount; i++) {
+					equalizerL[i] += outputLeft[i];
+					equalizerR[i] += outputRight[i];
+				}
+				continue;
+			}
 			if (isXG && !variationInsertion) {
 				const gain = midiParameters.dryLevel / 127;
 				for (let i = 0; i < sampleCount; i++) {
@@ -59632,7 +60443,12 @@ var SpessaSynthProcessor = class {
 				this.xgChorusBlock.process(this.xgChorusInputL, this.xgChorusInputR, left, right, this.xgReverbInputL, this.xgReverbInputR, startIndex, sampleCount);
 				this.xgReverbBlock.process(this.xgReverbInputL, this.xgReverbInputR, left, right, startIndex, sampleCount);
 			} else {
-				if (this.gsInsertionActive) this.gsInsertionBlock.process(insertionInputL, insertionInputR, left, right, gsReverbInput, gsChorusInput, gsDelayInput, startIndex, sampleCount);
+				if (this.gsInsertionActive) {
+					const insertion = this.gsInsertionBlock;
+					const toEqualizer = eq && insertion.sendEQSwitch;
+					insertion.process(insertionInputL, insertionInputR, toEqualizer ? this.equalizerInputL : left, toEqualizer ? this.equalizerInputR : right, gsReverbInput, gsChorusInput, gsDelayInput, toEqualizer ? 0 : startIndex, sampleCount);
+				}
+				if (eq) this.gsEqualizerProcessor.process(this.equalizerInputL, this.equalizerInputR, left, right, startIndex, sampleCount);
 				this.gsChorusProcessor.process(gsChorusInput, left, right, gsReverbInput, gsDelayInput, startIndex, sampleCount);
 				if (this.gsDelayActive) this.gsDelayProcessor.process(gsDelayInput, left, right, gsReverbInput, startIndex, sampleCount);
 				this.gsReverbProcessor.process(gsReverbInput, left, right, startIndex, sampleCount);
@@ -59692,13 +60508,6 @@ var SpessaSynthProcessor = class {
 		this.soundBankManager.refresh();
 	}
 	/**
-	* The decoded sample data kept under {@link SynthProcessorOptions.decodedSampleBudget}, in bytes.
-	* It is only counted when a budget is set.
-	*/
-	get decodedSampleBytes() {
-		return this.decodedSamples.totalBytes;
-	}
-	/**
 	* Clears the synthesizer's voice cache.
 	* This can be used to hear the changes after editing a {@link BasicSoundBank}
 	*/
@@ -59730,7 +60539,7 @@ var SpessaSynthProcessor = class {
 	*/
 	purgeCachedPatch(patch) {
 		const patchKey = this.getCachedVoiceIndex(patch, 0, 0);
-		for (const key of this.cachedVoices.keys()) if (key % 2113536 === patchKey) this.cachedVoices.delete(key);
+		for (const key of this.cachedVoices.keys()) if (key % 4194304 === patchKey) this.cachedVoices.delete(key);
 	}
 	/**
 	* Sets a global MIDI parameter of the synthesizer.
@@ -60210,16 +61019,10 @@ var SpessaSynthProcessor = class {
 		}, "gs");
 	}
 	getCachedVoiceIndex(patch, midiNote, velocity) {
-		let bankMSB = patch.bankMSB;
-		let bankLSB = patch.bankLSB;
-		const { isGMGSDrum, program } = patch;
-		if (isGMGSDrum) {
-			bankMSB = 128;
-			bankLSB = 0;
-		}
-		return bankMSB + bankLSB * 129 + program * 16512 + 2113536 * midiNote + 270532608 * velocity;
+		const { isGMGSDrum, program, bankLSB } = patch;
+		return (isGMGSDrum ? 128 + patch.bankMSB : patch.bankMSB) + bankLSB * 256 + program * 32768 + 4194304 * midiNote + 536870912 * velocity;
 	}
 };
-export { BasicInstrument, BasicInstrumentZone, BasicLinkedZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, DEFAULT_CHANNEL_MIDI_PARAMETERS, DEFAULT_CHANNEL_SYSTEM_PARAMETERS, DEFAULT_DRUM_REVERB, DEFAULT_GLOBAL_MIDI_PARAMETERS, DEFAULT_GLOBAL_SYSTEM_PARAMETERS, DEFAULT_MIDI_CONTROLLERS, DEFAULT_SOUND_BANK_CLONE_OPTIONS, DEFAULT_SOUND_BANK_LOAD_OPTIONS, DEFAULT_SYNTH_MODE, DefaultGSChorus, DefaultGSDelay, DefaultGSInsertion, DefaultGSReverb, DefaultXGChorus, DefaultXGEffect, DefaultXGInsertion, DefaultXGReverb, DefaultXGSystemEffect, DefaultXGVariation, DrumParameterUtils, EmptySample, GENERATORS_AMOUNT, GSInsertionControlSources, Generator, GeneratorLimits, GeneratorTypes, INSTRUMENT_ONLY_GENERATORS, IndexedByteArray, InterpolationTypes, MAX_GENERATOR, MIDIBuilder, MIDIChannel, MIDIControllers, MIDIMessage, MIDIMessageTypes, MIDIPatchTools, MIDITrack, MIDIUtils, MIDI_DRUM_CHANNEL, Modulator, ModulatorControllerSources, ModulatorCurveTypes, ModulatorSource, ModulatorTransformTypes, NonRegisteredParameterTypesLSB, NonRegisteredParameterTypesMSB, RegisteredParameterTypes, SPESSASYNTH_GAIN_FACTOR, SPESSA_BUFSIZE, SampleTypes, SoundBankCloner, SoundBankLoader, SoundBankManager, SpessaLog, SpessaSynthCoreUtils, SpessaSynthProcessor, SpessaSynthSequencer, VOICE_CAP, audioToWav };
+export { BasicInstrument, BasicInstrumentZone, BasicLinkedZone, BasicMIDI, BasicPreset, BasicPresetZone, BasicSample, BasicSoundBank, BasicZone, DEFAULT_CHANNEL_MIDI_PARAMETERS, DEFAULT_CHANNEL_SYSTEM_PARAMETERS, DEFAULT_DRUM_REVERB, DEFAULT_GLOBAL_MIDI_PARAMETERS, DEFAULT_GLOBAL_SYSTEM_PARAMETERS, DEFAULT_MIDI_CONTROLLERS, DEFAULT_SOUND_BANK_CLONE_OPTIONS, DEFAULT_SOUND_BANK_LOAD_OPTIONS, DEFAULT_SYNTH_MODE, DefaultGSChorus, DefaultGSDelay, DefaultGSEqualizer, DefaultGSInsertion, DefaultGSReverb, DefaultXGChorus, DefaultXGEffect, DefaultXGInsertion, DefaultXGReverb, DefaultXGSystemEffect, DefaultXGVariation, DrumParameterUtils, EmptySample, GENERATORS_AMOUNT, GSInsertionControlSources, Generator, GeneratorLimits, GeneratorTypes, INSTRUMENT_ONLY_GENERATORS, IndexedByteArray, InterpolationTypes, MAX_GENERATOR, MIDIBuilder, MIDIChannel, MIDIControllers, MIDIMessage, MIDIMessageTypes, MIDIPatchTools, MIDITrack, MIDIUtils, MIDI_DRUM_CHANNEL, Modulator, ModulatorControllerSources, ModulatorCurveTypes, ModulatorSource, ModulatorTransformTypes, NonRegisteredParameterTypesLSB, NonRegisteredParameterTypesMSB, RegisteredParameterTypes, SPESSASYNTH_GAIN_FACTOR, SPESSA_BUFSIZE, SampleTypes, SoundBankCloner, SoundBankLoader, SoundBankManager, SpessaLog, SpessaSynthCoreUtils, SpessaSynthProcessor, SpessaSynthSequencer, VOICE_CAP, audioToWav };
 
 //# sourceMappingURL=index.js.map