spessasynth_core 4.4.6 → 4.4.8

package/dist/index.js

@@ -411,7 +411,7 @@ var RIFFChunk = class RIFFChunk {
 		}
 		const parts = [getStringBytes(headerWritten), sizeBytes];
 		if (isList) parts.push(getStringBytes(header));
-		parts.push(...chunks);
+		for (const chunk of chunks) parts.push(chunk);
 		if (totalSize % 2 !== 0) parts.push(/* @__PURE__ */ new Uint8Array(1));
 		return parts;
 	}
@@ -511,8 +511,8 @@ function audioToWav(audioData, sampleRate, options = DEFAULT_WAV_WRITE_OPTIONS)
 	let cueChunk = new IndexedByteArray(0);
 	const cueOn = loop?.end !== void 0 && loop?.start !== void 0;
 	if (cueOn) {
-		const loopStartSamples = Math.floor(loop.start * sampleRate);
-		const loopEndSamples = Math.floor(loop.end * sampleRate);
+		const loopStartSamples = Math.round(loop.start * sampleRate);
+		const loopEndSamples = Math.round(loop.end * sampleRate);
 		const cueStart = new IndexedByteArray(24);
 		writeLittleEndianIndexed(cueStart, 0, 4);
 		writeLittleEndianIndexed(cueStart, 0, 4);
@@ -629,6 +629,105 @@ function audioToWav(audioData, sampleRate, options = DEFAULT_WAV_WRITE_OPTIONS)
 	if (cueOn) wavData.set(cueChunk, offset);
 	return wavData.buffer;
 }
+// src/utils/read_wav.ts
+/**
+* Reads a WAVE file into PCM audio data, the counterpart of {@link audioToWav}.
+*
+* It reads 8, 16, 24 and 32-bit integer PCM and 32 and 64-bit float files (including `WAVE_FORMAT_EXTENSIBLE`).
+* The loop is read from the first loop of the `smpl` chunk. Without one, the first two points of the `cue ` chunk
+* are taken as the loop start and end, which is how {@link audioToWav} writes it.
+* Other files may use cue points as plain markers, so such a loop is only reliable for files written by core.
+*
+* > **Note**
+* >
+* > The returned loop end is exclusive, like the SoundFont loop end.
+*
+* @param buffer The binary WAVE file.
+* @returns The audio data (one array per channel), the sample rate and the loop, if the file has one.
+* @throws Error if the file is not a valid or supported WAVE file.
+*
+* @group Utilities
+*/
+function wavToAudio(buffer) {
+	const view = new DataView(buffer);
+	const bytes = new Uint8Array(buffer);
+	const fourCC = (at) => String.fromCodePoint(bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]);
+	if (buffer.byteLength < 12 || fourCC(0) !== "RIFF" || fourCC(8) !== "WAVE") throw new Error("Not a WAVE file.");
+	let format = 0;
+	let channels = 0;
+	let sampleRate = 0;
+	let bitsPerSample = 0;
+	let dataStart = -1;
+	let dataSize = 0;
+	let smplLoop;
+	const cuePoints = new Array();
+	let pos = 12;
+	while (pos + 8 <= buffer.byteLength) {
+		const id = fourCC(pos);
+		const size = view.getUint32(pos + 4, true);
+		const body = pos + 8;
+		const available = Math.min(size, buffer.byteLength - body);
+		switch (id) {
+			case "fmt ":
+				format = view.getUint16(body, true);
+				channels = view.getUint16(body + 2, true);
+				sampleRate = view.getUint32(body + 4, true);
+				bitsPerSample = view.getUint16(body + 14, true);
+				if (format === 65534 && size >= 26) format = view.getUint16(body + 24, true);
+				break;
+			case "data":
+				dataStart = body;
+				dataSize = available;
+				break;
+			case "smpl":
+				if ((size >= 36 ? view.getUint32(body + 28, true) : 0) > 0 && size >= 60) smplLoop = {
+					start: view.getUint32(body + 36 + 8, true),
+					end: view.getUint32(body + 36 + 12, true) + 1
+				};
+				break;
+			case "cue ": {
+				const count = view.getUint32(body, true);
+				for (let i = 0; i < count && 4 + (i + 1) * 24 <= size; i++) cuePoints.push(view.getUint32(body + 4 + i * 24 + 20, true));
+				break;
+			}
+		}
+		pos = body + size + size % 2;
+	}
+	if (channels === 0 || dataStart === -1) throw new Error("The WAVE file has no fmt or data chunk!");
+	const bytesPerSample = bitsPerSample >> 3;
+	const isFloat = format === 3;
+	if (format !== 1 && format !== 3 || (isFloat ? ![4, 8].includes(bytesPerSample) : bytesPerSample < 1 || bytesPerSample > 4)) throw new Error(`Unsupported WAVE format ${format} with ${bitsPerSample} bits per sample.`);
+	const frames = Math.floor(dataSize / (bytesPerSample * channels));
+	const audioData = Array.from({ length: channels }, () => new Float32Array(frames));
+	for (let i = 0; i < frames; i++) for (let c = 0; c < channels; c++) {
+		const at = dataStart + (i * channels + c) * bytesPerSample;
+		let value;
+		if (isFloat) value = bytesPerSample === 4 ? view.getFloat32(at, true) : view.getFloat64(at, true);
+		else switch (bytesPerSample) {
+			case 1:
+				value = (view.getUint8(at) - 128) / 128;
+				break;
+			case 2:
+				value = view.getInt16(at, true) / 32768;
+				break;
+			case 3:
+				value = ((bytes[at + 2] << 24 | bytes[at + 1] << 16 | bytes[at] << 8) >> 8) / 8388608;
+				break;
+			default: value = view.getInt32(at, true) / 2147483648;
+		}
+		audioData[c][i] = value;
+	}
+	let loop = smplLoop;
+	if (!loop && cuePoints.length >= 2) loop = {
+		start: cuePoints[0],
+		end: cuePoints[1]
+	};
+	return {
+		audioData,
+		sampleRate,
+		loop
+	};
+}
 // src/utils/loggin.ts
 /**
 * SpessaSynth can print out additional info to the console or print nothing at all.
@@ -1603,56 +1702,43 @@ const GeneratorLimits = Object.freeze({
 		min: -12e3,
 		max: 12e3,
 		def: 0,
-		nrpn: 2,
-		presetMin: -24e3,
-		presetMax: 24e3
+		nrpn: 2
 	},
 	[GeneratorTypes.vibLfoToPitch]: {
 		min: -12e3,
 		max: 12e3,
 		def: 0,
-		nrpn: 2,
-		presetMin: -24e3,
-		presetMax: 24e3
+		nrpn: 2
 	},
 	[GeneratorTypes.modEnvToPitch]: {
 		min: -12e3,
 		max: 12e3,
 		def: 0,
-		nrpn: 2,
-		presetMin: -24e3,
-		presetMax: 24e3
+		nrpn: 2
 	},
 	[GeneratorTypes.initialFilterFc]: {
 		min: 1500,
 		max: 13500,
 		def: 13500,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.initialFilterQ]: {
 		min: 0,
 		max: 960,
 		def: 0,
-		nrpn: 1,
-		presetMin: -960
+		nrpn: 1
 	},
 	[GeneratorTypes.modLfoToFilterFc]: {
 		min: -12e3,
 		max: 12e3,
 		def: 0,
-		nrpn: 2,
-		presetMin: -24e3,
-		presetMax: 24e3
+		nrpn: 2
 	},
 	[GeneratorTypes.modEnvToFilterFc]: {
 		min: -12e3,
 		max: 12e3,
 		def: 0,
-		nrpn: 2,
-		presetMin: -24e3,
-		presetMax: 24e3
+		nrpn: 2
 	},
 	[GeneratorTypes.endAddrsCoarseOffset]: {
 		min: -32768,
@@ -1664,189 +1750,145 @@ const GeneratorLimits = Object.freeze({
 		min: -960,
 		max: 960,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1920,
-		presetMax: 1920
+		nrpn: 1
 	},
 	[GeneratorTypes.chorusEffectsSend]: {
 		min: 0,
 		max: 1e3,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1e3
+		nrpn: 1
 	},
 	[GeneratorTypes.reverbEffectsSend]: {
 		min: 0,
 		max: 1e3,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1e3
+		nrpn: 1
 	},
 	[GeneratorTypes.pan]: {
 		min: -500,
 		max: 500,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1e3,
-		presetMax: 1e3
+		nrpn: 1
 	},
 	[GeneratorTypes.delayModLFO]: {
 		min: -12e3,
 		max: 5e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.freqModLFO]: {
 		min: -16e3,
 		max: 4500,
 		def: 0,
-		nrpn: 4,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 4
 	},
 	[GeneratorTypes.delayVibLFO]: {
 		min: -12e3,
 		max: 5e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.freqVibLFO]: {
 		min: -16e3,
 		max: 4500,
 		def: 0,
-		nrpn: 4,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 4
 	},
 	[GeneratorTypes.delayModEnv]: {
 		min: -32768,
 		max: 5e3,
 		def: -32768,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.attackModEnv]: {
 		min: -32768,
 		max: 8e3,
 		def: -32768,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.holdModEnv]: {
 		min: -12e3,
 		max: 5e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.decayModEnv]: {
 		min: -12e3,
 		max: 8e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.sustainModEnv]: {
 		min: 0,
 		max: 1e3,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1e3
+		nrpn: 1
 	},
 	[GeneratorTypes.releaseModEnv]: {
 		min: -12e3,
 		max: 8e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.keyNumToModEnvHold]: {
 		min: -1200,
 		max: 1200,
 		def: 0,
-		nrpn: 1,
-		presetMin: -2400,
-		presetMax: 2400
+		nrpn: 1
 	},
 	[GeneratorTypes.keyNumToModEnvDecay]: {
 		min: -1200,
 		max: 1200,
 		def: 0,
-		nrpn: 1,
-		presetMin: -2400,
-		presetMax: 2400
+		nrpn: 1
 	},
 	[GeneratorTypes.delayVolEnv]: {
 		min: -12e3,
 		max: 5e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.attackVolEnv]: {
 		min: -12e3,
 		max: 8e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.holdVolEnv]: {
 		min: -12e3,
 		max: 5e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.decayVolEnv]: {
 		min: -12e3,
 		max: 8e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.sustainVolEnv]: {
 		min: 0,
 		max: 1440,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1440
+		nrpn: 1
 	},
 	[GeneratorTypes.releaseVolEnv]: {
 		min: -12e3,
 		max: 8e3,
 		def: -12e3,
-		nrpn: 2,
-		presetMin: -21e3,
-		presetMax: 21e3
+		nrpn: 2
 	},
 	[GeneratorTypes.keyNumToVolEnvHold]: {
 		min: -1200,
 		max: 1200,
 		def: 0,
-		nrpn: 1,
-		presetMin: -2400,
-		presetMax: 2400
+		nrpn: 1
 	},
 	[GeneratorTypes.keyNumToVolEnvDecay]: {
 		min: -1200,
 		max: 1200,
 		def: 0,
-		nrpn: 1,
-		presetMin: -2400,
-		presetMax: 2400
+		nrpn: 1
 	},
 	[GeneratorTypes.startloopAddrsCoarseOffset]: {
 		min: -32768,
@@ -1870,8 +1912,7 @@ const GeneratorLimits = Object.freeze({
 		min: 0,
 		max: 1440,
 		def: 0,
-		nrpn: 1,
-		presetMin: -1440
+		nrpn: 1
 	},
 	[GeneratorTypes.endloopAddrsCoarseOffset]: {
 		min: -32768,
@@ -1883,28 +1924,23 @@ const GeneratorLimits = Object.freeze({
 		min: -120,
 		max: 120,
 		def: 0,
-		nrpn: 1,
-		presetMin: -240,
-		presetMax: 240
+		nrpn: 1
 	},
 	[GeneratorTypes.fineTune]: {
 		min: -12700,
 		max: 12700,
 		def: 0,
-		nrpn: 1,
-		presetMin: -198,
-		presetMax: 198
+		nrpn: 1
 	},
 	[GeneratorTypes.scaleTuning]: {
 		min: 0,
 		max: 1200,
 		def: 100,
-		nrpn: 1,
-		presetMin: -1200
+		nrpn: 1
 	},
 	[GeneratorTypes.exclusiveClass]: {
 		min: 0,
-		max: 99999,
+		max: 32767,
 		def: 0,
 		nrpn: 0
 	},
@@ -2246,6 +2282,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");
@@ -2467,6 +2504,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,
@@ -2779,7 +2817,8 @@ const GSInsertionAddressMap = {
 	controlSource1: 27,
 	controlDepth1: 28,
 	controlSource2: 29,
-	controlDepth2: 30
+	controlDepth2: 30,
+	sendEQSwitch: 31
 };
 const GSChorusAddressMap = {
 	macro: 56,
@@ -2805,6 +2844,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
@@ -2875,6 +2920,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]));
@@ -3017,20 +3066,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]);
 		}
 	}
 	/**
@@ -3238,6 +3300,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])];
 		}
@@ -3970,6 +4033,12 @@ var MIDIUtils = class MIDIUtils {
 					controller: MIDIControllers.reverbDepth,
 					value
 				}];
+				case 20: return [{
+					type: "Controller Change",
+					channel,
+					controller: MIDIControllers.variationDepth,
+					value
+				}];
 				case 21: return [{
 					type: "Controller Change",
 					channel,
@@ -4438,6 +4507,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 [{
@@ -4447,6 +4525,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,
@@ -4650,6 +4733,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,
@@ -5023,6 +5112,7 @@ var MIDIEditor = class {
 	gsReverbParams;
 	gsChorusParams;
 	gsDelayParams;
+	gsEqualizerParams;
 	gsInsertionParams;
 	xgReverbParams;
 	xgChorusParams;
@@ -5050,10 +5140,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;
@@ -5126,12 +5217,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);
@@ -5371,6 +5462,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();
@@ -5785,6 +5882,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));
@@ -7278,6 +7379,22 @@ var BasicSample = class {
 		return this.linkedTo.length;
 	}
 	/**
+	* If the decoded float data is currently held in memory.
+	* Check it before {@link getAudioData} to know if the call has to decode,
+	* then use {@link releaseDecoded} to drop the copy again.
+	*/
+	get isDecoded() {
+		return this.audioData !== void 0;
+	}
+	/**
+	* If the decoded float data can be made again from the stored data.
+	* False for replaced data (set with {@link BasicSample.setAudioData}), which has nothing to decode from.
+	* @internal
+	*/
+	get canRedecode() {
+		return !this.dataOverridden && (this.compressedData !== void 0 || this.s16leData !== void 0);
+	}
+	/**
 	* Get raw data for writing the file, either a compressed bit stream or signed 16-bit little endian PCM data.
 	* @param allowVorbis if vorbis file data is allowed.
 	* @return either s16le or vorbis data.
@@ -7353,7 +7470,7 @@ var BasicSample = class {
 	* @returns True if the decoded data was dropped.
 	*/
 	releaseDecoded() {
-		if (this.audioData && !this.dataOverridden && (this.compressedData || this.s16leData)) {
+		if (this.audioData && this.canRedecode) {
 			this.audioData = void 0;
 			return true;
 		}
@@ -7385,12 +7502,13 @@ var BasicSample = class {
 		this.setAudioData(resampled, newSampleRate);
 	}
 	/**
-	* Compresses the audio data
+	* Compresses the audio data.
 	* @param encodeVorbis the compression function to use when compressing.
+	* @returns True if the sample is compressed afterward, false if the encoder failed and it stays uncompressed.
 	* @internal
 	*/
 	async compressSample(encodeVorbis) {
-		if (this.isCompressed) return;
+		if (this.isCompressed) return true;
 		try {
 			let audioData = this.getAudioData();
 			if (this.sampleRate < 8e3 || this.sampleRate > 96e3) {
@@ -7399,9 +7517,11 @@ var BasicSample = class {
 			}
 			const compressed = await encodeVorbis(audioData, this.sampleRate);
 			this.setCompressedData(compressed);
+			return true;
 		} catch (error) {
 			SpessaLog.warn(`Failed to compress ${this.name}. Leaving as uncompressed!`, error);
 			this.compressedData = void 0;
+			return false;
 		}
 	}
 	/**
@@ -7451,16 +7571,17 @@ var BasicSample = class {
 		}
 	}
 	/**
-	* Links the sample to a given instrument
-	* @param instrument the instrument to link to
+	* Links the sample to a given instrument.
+	* @param instrument the instrument to link to.
 	* @internal
 	*/
 	linkTo(instrument) {
 		this.linkedTo.push(instrument);
 	}
 	/**
-	* Unlinks the sample from a given instrument
-	* @param instrument the instrument to unlink from
+	* Unlinks the sample from a given instrument.
+	* @param instrument the instrument to unlink from.
+	* @internal
 	*/
 	unlinkFrom(instrument) {
 		const index = this.linkedTo.indexOf(instrument);
@@ -7827,12 +7948,12 @@ var ModulatorSource = class ModulatorSource {
 	*/
 	curveType;
 	/**
-	* @internal
-	* @param index
-	* @param curveType
-	* @param isCC
-	* @param isBipolar
-	* @param isNegative
+	* Creates a new modulator source.
+	* @param index The controller or MIDI CC number, see `isCC`.
+	* @param curveType How the minimum value approaches the maximum value.
+	* @param isCC If the index is a MIDI CC instead of a general controller.
+	* @param isBipolar If the source is bipolar (-1 to 1) instead of unipolar (0 to 1).
+	* @param isNegative If the direction of the source is flipped.
 	*/
 	constructor(index = ModulatorControllerSources.noController, curveType = ModulatorCurveTypes.linear, isCC = false, isBipolar = false, isNegative = false) {
 		this.isBipolar = isBipolar;
@@ -8300,14 +8421,13 @@ var BasicLinkedZone = class extends BasicZone {
 	}
 	/**
 	* Links the child to the parent, unless this zone was created without linking.
-	* @internal
+	* Use it to put a zone back after {@link unlinkChild}, for example when undoing a zone deletion.
 	*/
 	linkChild() {
 		if (this.linked) this.child.linkTo(this.parent);
 	}
 	/**
 	* Unlinks the child from the parent, unless this zone was created without linking.
-	* @internal
 	*/
 	unlinkChild() {
 		if (this.linked) this.child.unlinkFrom(this.parent);
@@ -8695,7 +8815,7 @@ var BasicPreset = class BasicPreset {
 					}
 				}
 				finalGenList = finalGenList.filter((g) => g.type !== GeneratorTypes.sampleID && g.type !== GeneratorTypes.keyRange && g.type !== GeneratorTypes.velRange && g.type !== GeneratorTypes.endOper && g.type !== GeneratorTypes.instrument && (!(g.type in GeneratorLimits) || g.value !== GeneratorLimits[g.type].def));
-				const zone = outputInstrument.createZone(instZone.sample);
+				const zone = outputInstrument.createZone(instZone.sample, false);
 				zone.keyRange = instZoneKeyRange;
 				zone.velRange = instZoneVelRange;
 				if (zone.keyRange.min === 0 && zone.keyRange.max === 127) zone.keyRange.min = -1;
@@ -8825,6 +8945,7 @@ var BasicInstrument = class {
 	/**
 	* Unlinks the instrument from a given preset.
 	* @param preset The preset to unlink from.
+	* @internal
 	*/
 	unlinkFrom(preset) {
 		const index = this.linkedTo.indexOf(preset);
@@ -9109,7 +9230,7 @@ function writeSF(bank, software, writeDefaultModulators, writeExtendedLimits, wr
 	*/
 	const infoArrays = [];
 	const writeSF2Info = (type, data) => {
-		if (!data) return;
+		if (data === void 0) return;
 		infoArrays.push(...RIFFChunk.getParts(type, [getStringBytes(data, true, true)], rf64));
 	};
 	const info = bank.soundBankInfo;
@@ -9120,7 +9241,7 @@ function writeSF(bank, software, writeDefaultModulators, writeExtendedLimits, wr
 		infoArrays.push(RIFFChunk.write("ifil", ifilData, rf64));
 	}
 	writeSF2Info("isng", info.soundEngine);
-	writeSF2Info("INAM", info.name);
+	writeSF2Info("INAM", info.name ?? "");
 	writeSF2Info("irom", info.romInfo);
 	if (info.romVersion) {
 		const ifilData = new IndexedByteArray(4);
@@ -9507,6 +9628,9 @@ var DLSSample = class extends BasicSample {
 		if (this.rawData && !this.audioData) return "float32";
 		return super.storedForm;
 	}
+	get canRedecode() {
+		return this.rawData !== void 0 && !this.dataOverridden || super.canRedecode;
+	}
 	getStoredData() {
 		if (this.rawData && !this.audioData) this.getAudioData();
 		return super.getStoredData();
@@ -9515,13 +9639,6 @@ var DLSSample = class extends BasicSample {
 		this.rawData = void 0;
 		super.setStoredData(stored);
 	}
-	releaseDecoded() {
-		if (this.rawData && this.audioData && !this.dataOverridden) {
-			this.audioData = void 0;
-			return true;
-		}
-		return super.releaseDecoded();
-	}
 	releaseData() {
 		if (this.hasData) this.releasedForm = this.storedForm;
 		this.cachedLength = this.sampleLength;
@@ -9599,7 +9716,7 @@ var DownloadableSoundsSample = class DownloadableSoundsSample extends DLSVerifie
 	}
 	static fromSFSample(sample) {
 		const raw = sample.getRawData(false);
-		const dlsSample = new DownloadableSoundsSample(1, 2, sample.sampleRate, new RIFFChunk("data", raw.length, new IndexedByteArray(raw.buffer)));
+		const dlsSample = new DownloadableSoundsSample(1, 2, sample.sampleRate, new RIFFChunk("data", raw.length, new IndexedByteArray(raw.buffer, raw.byteOffset, raw.byteLength)));
 		dlsSample.name = sample.name;
 		dlsSample.waveSample = WaveSample.fromSFSample(sample);
 		return dlsSample;
@@ -10687,8 +10804,8 @@ var DownloadableSoundsInstrument = class DownloadableSoundsInstrument extends DL
 		SpessaLog.groupCollapsed(`%cWriting %c${this.name}%c...`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info);
 		const chunks = [this.writeHeader()];
 		const regionChunks = this.regions.flatMap((r) => r.write());
-		chunks.push(...RIFFChunk.getParts("lrgn", regionChunks, false, true));
-		if (this.articulation.length > 0) chunks.push(...this.articulation.write());
+		for (const part of RIFFChunk.getParts("lrgn", regionChunks, false, true)) chunks.push(part);
+		if (this.articulation.length > 0) for (const part of this.articulation.write()) chunks.push(part);
 		const inam = RIFFChunk.write("INAM", getStringBytes(this.name, true));
 		chunks.push(RIFFChunk.write("INFO", inam, false, true));
 		SpessaLog.groupEnd();
@@ -10973,7 +11090,7 @@ var DownloadableSounds = class DownloadableSounds extends DLSVerifier {
 */
 const DEFAULT_SOUND_BANK_CLONE_OPTIONS = {
 	reuseByName: true,
-	reuseChildrenByName: true,
+	reuseChildren: "name",
 	addToBank: true
 };
 const MAX_BASE_NAME_LENGTH = 37;
@@ -11020,6 +11137,17 @@ var SoundBankCloner = class {
 		this.bank = bank;
 		this.options = fillWithDefaults(options, DEFAULT_SOUND_BANK_CLONE_OPTIONS);
 	}
+	get ownReuse() {
+		return this.options.reuseByName ? "name" : "none";
+	}
+	/**
+	* Gets the clone this session made of an element.
+	* @param source The sample or instrument that was cloned.
+	* @returns The clone, or undefined if the session has not cloned the element.
+	*/
+	getClone(source) {
+		return source instanceof BasicSample ? this.sampleClones.get(source) : this.instrumentClones.get(source);
+	}
 	/**
 	* Clones a sample and its stereo partner.
 	* The data is shared with the original, not copied.
@@ -11027,7 +11155,7 @@ var SoundBankCloner = class {
 	* @returns The clone, or the existing sample with the same name if it is reused.
 	*/
 	cloneSample(sample) {
-		return this.copySample(sample, this.options.reuseByName);
+		return this.copySample(sample, this.ownReuse);
 	}
 	/**
 	* Clones an instrument and the samples it uses.
@@ -11035,7 +11163,7 @@ var SoundBankCloner = class {
 	* @returns The clone, or the existing instrument with the same name if it is reused.
 	*/
 	cloneInstrument(instrument) {
-		return this.copyInstrument(instrument, this.options.reuseByName);
+		return this.copyInstrument(instrument, this.ownReuse);
 	}
 	/**
 	* Clones a preset and the instruments and samples it uses.
@@ -11044,10 +11172,8 @@ var SoundBankCloner = class {
 	*/
 	clonePreset(preset) {
 		const all = [...this.bank.presets, ...this.created.presets];
-		if (this.options.reuseByName) {
-			const existing = all.find((p) => p.name === preset.name);
-			if (existing) return existing;
-		}
+		const existing = this.findReused(preset, all, this.ownReuse);
+		if (existing) return existing;
 		const newPreset = new BasicPreset(this.bank);
 		newPreset.name = this.getFreeName(preset.name, all);
 		newPreset.bankMSB = preset.bankMSB;
@@ -11058,7 +11184,7 @@ var SoundBankCloner = class {
 		newPreset.genre = preset.genre;
 		newPreset.morphology = preset.morphology;
 		newPreset.globalZone.copyFrom(preset.globalZone);
-		for (const zone of preset.zones) newPreset.createZone(this.copyInstrument(zone.instrument, this.options.reuseChildrenByName)).copyFrom(zone);
+		for (const zone of preset.zones) newPreset.createZone(this.copyInstrument(zone.instrument, this.options.reuseChildren)).copyFrom(zone);
 		this.created.presets.push(newPreset);
 		if (this.options.addToBank) this.bank.addPresets(newPreset);
 		return newPreset;
@@ -11067,14 +11193,12 @@ var SoundBankCloner = class {
 		const cloned = this.instrumentClones.get(instrument);
 		if (cloned) return cloned;
 		const all = [...this.bank.instruments, ...this.created.instruments];
-		if (reuse) {
-			const existing = all.find((i) => i.name === instrument.name);
-			if (existing) return existing;
-		}
+		const existing = this.findReused(instrument, all, reuse);
+		if (existing) return existing;
 		const newInstrument = new BasicInstrument();
 		newInstrument.name = this.getFreeName(instrument.name, all);
 		newInstrument.globalZone.copyFrom(instrument.globalZone);
-		for (const zone of instrument.zones) newInstrument.createZone(this.copySample(zone.sample, this.options.reuseChildrenByName)).copyFrom(zone);
+		for (const zone of instrument.zones) newInstrument.createZone(this.copySample(zone.sample, this.options.reuseChildren)).copyFrom(zone);
 		this.instrumentClones.set(instrument, newInstrument);
 		this.created.instruments.push(newInstrument);
 		if (this.options.addToBank) this.bank.addInstruments(newInstrument);
@@ -11084,10 +11208,8 @@ var SoundBankCloner = class {
 		const cloned = this.sampleClones.get(sample);
 		if (cloned) return cloned;
 		const all = [...this.bank.samples, ...this.created.samples];
-		if (reuse) {
-			const existing = all.find((s) => s.name === sample.name);
-			if (existing) return existing;
-		}
+		const existing = this.findReused(sample, all, reuse);
+		if (existing) return existing;
 		const newSample = new BasicSample(this.getFreeName(sample.name, all), sample.sampleRate, sample.originalKey, sample.pitchCorrection, sample.sampleType, sample.loopStart, sample.loopEnd);
 		if (sample.hasData) newSample.setStoredData(sample.getStoredData());
 		else {
@@ -11101,10 +11223,20 @@ var SoundBankCloner = class {
 		if (linked) {
 			const newLinked = this.sampleClones.get(linked);
 			if (newLinked) newSample.setLinkedSample(newLinked, sample.sampleType);
-			else this.copySample(linked, false);
+			else this.copySample(linked, "none");
 		}
 		return newSample;
 	}
+	/**
+	* Finds the element to use instead of a copy, if the options allow one.
+	*/
+	findReused(element, elements, reuse) {
+		switch (reuse) {
+			case "none": return;
+			case "identity": return elements.includes(element) ? element : void 0;
+			case "name": return elements.find((e) => e.name === element.name);
+		}
+	}
 	getFreeName(name, elements) {
 		const taken = new Set(elements.map((e) => e.name));
 		if (!taken.has(name)) return name;
@@ -11270,7 +11402,7 @@ var BasicSoundBank = class BasicSoundBank {
 		const copied = new BasicSoundBank(bank.type);
 		const cloner = new SoundBankCloner(copied, {
 			reuseByName: false,
-			reuseChildrenByName: false
+			reuseChildren: "none"
 		});
 		for (const p of bank.presets) cloner.clonePreset(p);
 		copied.soundBankInfo = { ...bank.soundBankInfo };
@@ -11284,13 +11416,13 @@ var BasicSoundBank = class BasicSoundBank {
 	* @param presets The presets to add.
 	*/
 	addCompletePresets(presets) {
-		this.addPresets(...presets);
+		this.addElements(this.presets, presets);
 		const instrumentList = [];
 		for (const preset of presets) for (const zone of preset.zones) if (zone.instrument && !instrumentList.includes(zone.instrument)) instrumentList.push(zone.instrument);
-		this.addInstruments(...instrumentList);
+		this.addElements(this.instruments, instrumentList);
 		const sampleList = [];
 		for (const instrument of instrumentList) for (const zone of instrument.zones) if (zone.sample && !sampleList.includes(zone.sample)) sampleList.push(zone.sample);
-		this.addSamples(...sampleList);
+		this.addElements(this.samples, sampleList);
 	}
 	/**
 	* Sets the sound bank's sample format _in place_.
@@ -11304,9 +11436,11 @@ var BasicSoundBank = class BasicSoundBank {
 	* @param options Options associated with setting the sample format.
 	* @returns The samples whose sample rate or loop points changed.
 	* Compressing resamples samples outside 8000 to 96000 Hz.
+	* @throws Error if `rejectOnFailure` is set and one of the samples has failed to compress.
 	*/
 	async setSampleFormat(options) {
 		const changed = new Array();
+		const failed = new Array();
 		let writtenCount = 0;
 		const format = options.format;
 		const progressFunc = options.progressFunction;
@@ -11320,7 +11454,7 @@ var BasicSoundBank = class BasicSoundBank {
 					const f = options.compressionFunction;
 					if (!f) throw new Error(`No compression function supplied but '${format}' was requested.`);
 					const { sampleRate, loopStart, loopEnd } = s;
-					await s.compressSample(f);
+					if (!await s.compressSample(f)) failed.push(s);
 					if (s.sampleRate !== sampleRate || s.loopStart !== loopStart || s.loopEnd !== loopEnd) changed.push(s);
 				}
 			}
@@ -11328,6 +11462,7 @@ var BasicSoundBank = class BasicSoundBank {
 			progressFunc?.(writtenCount / this.samples.length);
 			SpessaLog.info(`%cEncoded sample %c${writtenCount}. ${s.name}%c of %c${this.samples.length}%c. Compressed: %c${s.isCompressed}%c.`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, s.isCompressed ? ConsoleColors.recognized : ConsoleColors.unrecognized, ConsoleColors.info);
 		}
+		if (failed.length > 0 && options.format === "compressed" && options.rejectOnFailure) throw new Error(`Failed to compress ${failed.length} samples: ${failed.map((s) => s.name).join(", ")}`);
 		switch (format) {
 			default:
 			case "pcm":
@@ -11391,21 +11526,21 @@ var BasicSoundBank = class BasicSoundBank {
 	* @param presets The presets to add.
 	*/
 	addPresets(...presets) {
-		this.presets.push(...presets);
+		this.addElements(this.presets, presets);
 	}
 	/**
 	* Adds {@link BasicInstrument}s to this sound bank.
 	* @param instruments The instruments to add.
 	*/
 	addInstruments(...instruments) {
-		this.instruments.push(...instruments);
+		this.addElements(this.instruments, instruments);
 	}
 	/**
 	* Adds {@link BasicSample}s to this sound bank.
 	* @param samples The samples to add.
 	*/
 	addSamples(...samples) {
-		this.samples.push(...samples);
+		this.addElements(this.samples, samples);
 	}
 	/**
 	* Clones a sample into this bank, together with its stereo partner.
@@ -11457,9 +11592,11 @@ var BasicSoundBank = class BasicSoundBank {
 	}
 	/**
 	* Updates internal values. Call after updating the preset list.
+	* @param sort If the presets should be sorted. Set it to `false` to keep a custom order,
+	* only the internal values (like {@link isXGBank}) are then recomputed.
 	*/
-	flush() {
-		this.presets.sort(MIDIPatchTools.compare.bind(MIDIPatchTools));
+	flush(sort = true) {
+		if (sort) this.presets.sort(MIDIPatchTools.compare.bind(MIDIPatchTools));
 		this.parseInternal();
 	}
 	/**
@@ -11604,6 +11741,9 @@ var BasicSoundBank = class BasicSoundBank {
 		this.instruments.length = 0;
 		this.samples.length = 0;
 	}
+	addElements(list, elements) {
+		for (const element of elements) list.push(element);
+	}
 	parsingError(error) {
 		throw new Error(`SF parsing error: ${error} The file may be corrupted.`);
 	}
@@ -15405,7 +15545,6 @@ function setTimeToInternal(time, ticks = void 0) {
 						const channel = analyzed.channel + portOffset;
 						if (channel >= this.synth.midiChannels.length) break;
 						channels[channel] ??= createChannelStatus(channel);
-						if (this._midiData.isMultiPort && track.channels.size === 0) break;
 						if (controller === MIDIControllers.resetAllControllers) {
 							resetAllControllers(channel);
 							break;
@@ -32584,6 +32723,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).
@@ -52388,6 +52669,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;
@@ -52457,6 +52739,7 @@ var DefaultGSInsertion = class {
 		this.sendLevelToReverb = DEFAULT_SEND_LEVEL_TO_REVERB;
 		this.sendLevelToChorus = 0;
 		this.sendLevelToDelay = 0;
+		this.sendEQSwitch = true;
 	}
 	getType() {
 		return this.type;
@@ -52513,6 +52796,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,
@@ -52533,6 +52817,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.
@@ -52662,15 +52947,19 @@ var SoundBankManager = class {
 	*/
 	userDrumSets;
 	presetListChangeCallback;
+	bankRemovedCallback;
 	selectablePresetList = [];
 	/**
 	* @internal
 	* @param presetListChangeCallback Supplied by the parent synthesizer class,
 	* this is called whenever the preset list changes.
 	* The argument tells if the synthesizer should reset after updating its channels.
+	* @param bankRemovedCallback Called when a sound bank leaves the manager (deleted, replaced or destroyed),
+	* so the synthesizer can drop what it holds of it.
 	*/
-	constructor(presetListChangeCallback) {
+	constructor(presetListChangeCallback, bankRemovedCallback) {
 		this.presetListChangeCallback = presetListChangeCallback;
+		this.bankRemovedCallback = bankRemovedCallback;
 		const resolvePatch = (patch) => this.getPreset(patch, this.systemGetter());
 		this.userDrumSets = [new UserDrumSet(64, "User Drum Set 1", resolvePatch), new UserDrumSet(65, "User Drum Set 2", resolvePatch)];
 	}
@@ -52719,13 +53008,16 @@ var SoundBankManager = class {
 	/**
 	* This method removes a sound bank with a given ID from the sound bank list.
 	* @param id The ID of the sound bank to delete.
+	* @param reset If the synthesizer should reset (put every channel's controllers back to defaults) after the change.
+	* Set it to `false` to keep a song playing, the channels then only update to the new presets.
 	* @throws Error An error if there's no sound bank with the given ID.
 	*/
-	deleteSoundBank(id) {
+	deleteSoundBank(id, reset = true) {
 		const index = this.soundBankList.findIndex((s) => s.id === id);
 		if (index === -1) throw new Error(`No sound bank with id "${id}"`);
-		this.soundBankList.splice(index, 1);
-		this.generatePresetList();
+		const [removed] = this.soundBankList.splice(index, 1);
+		this.bankRemoved(removed.soundBank);
+		this.generatePresetList(reset);
 	}
 	/**
 	* Adds a new sound bank with a given ID, or replaces an existing one.
@@ -52733,8 +53025,10 @@ var SoundBankManager = class {
 	* @param id The unique ID to assign to the sound bank.
 	* If a sound bank with this ID already exists, it will be replaced.
 	* @param bankOffset The bank offset of the sound bank. Offsets the bank MSB value of all presets in this sound bank.
+	* @param reset If the synthesizer should reset (put every channel's controllers back to defaults) after the change.
+	* Set it to `false` to keep a song playing, the channels then only update to the new presets.
 	*/
-	addSoundBank(bank, id, bankOffset = 0) {
+	addSoundBank(bank, id, bankOffset = 0, reset = true) {
 		const foundBank = this.soundBankList.find((s) => s.id === id);
 		if (foundBank === void 0) this.soundBankList.push({
 			id,
@@ -52742,10 +53036,12 @@ var SoundBankManager = class {
 			bankOffset
 		});
 		else {
+			const old = foundBank.soundBank;
 			foundBank.soundBank = bank;
 			foundBank.bankOffset = bankOffset;
+			this.bankRemoved(old);
 		}
-		this.generatePresetList();
+		this.generatePresetList(reset);
 	}
 	/**
 	* Rebuilds the preset list from the current sound banks.
@@ -52775,11 +53071,17 @@ var SoundBankManager = class {
 	* @internal
 	*/
 	destroy() {
-		for (const s of this.soundBankList) s.soundBank.destroySoundBank();
+		for (const s of this.soundBankList) {
+			this.bankRemovedCallback?.(s.soundBank);
+			s.soundBank.destroySoundBank();
+		}
 		this.soundBankList = [];
 		this.selectablePresetList = [];
 		this._presetList = [];
 	}
+	bankRemoved(bank) {
+		if (!this.soundBankList.some((s) => s.soundBank === bank)) this.bankRemovedCallback?.(bank);
+	}
 	generatePresetList(resetSynth = true) {
 		const presetList = new Array();
 		const addedPresets = /* @__PURE__ */ new Set();
@@ -52928,7 +53230,7 @@ function renderVoice(voice, timeNow, sampleCount) {
 	let targetKey = voice.targetKey;
 	let cents = voice.pitchOffset + modulated[GeneratorTypes.fineTune] + this.octaveTuning[targetKey] + this.currentTuning;
 	let semitones = modulated[GeneratorTypes.coarseTune];
-	const tuning = core.tunings[this.preset.program * 128 + voice.midiNote];
+	const tuning = core.tunings[(this.preset?.program ?? this.patch.program) * 128 + voice.midiNote];
 	if (tuning !== -1) {
 		targetKey = Math.trunc(tuning);
 		semitones += tuning - targetKey;
@@ -54365,6 +54667,7 @@ const DEFAULT_CHANNEL_MIDI_PARAMETERS = {
 	randomPan: false,
 	assignMode: 2,
 	efxAssign: false,
+	eqEnabled: true,
 	cc1: 16,
 	cc2: 17,
 	drumMap: 0,
@@ -55239,6 +55542,7 @@ const DEFAULT_GLOBAL_SYSTEM_PARAMETERS = {
 	xgChorusLock: false,
 	gsDelayGain: 1,
 	gsDelayLock: false,
+	gsEqualizerLock: false,
 	xgVariationGain: 1,
 	xgVariationLock: false,
 	gsInsertionLock: false,
@@ -57251,6 +57555,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;
@@ -57327,6 +57652,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) {
@@ -57513,6 +57849,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);
@@ -58741,7 +59083,7 @@ var SoundFont2 = class extends BasicSoundBank {
 			}
 		}
 		for (const s of samples) s.name = s.name.trim();
-		this.samples.push(...samples);
+		this.addElements(this.samples, samples);
 		const instrumentGenerators = readGenerators(igenChunk, isSFE);
 		const instrumentModulators = readModulators(imodChunk, isSFE);
 		const extendInstruments = xdtaChunk !== void 0 && !!xChunks.inst;
@@ -58758,7 +59100,7 @@ var SoundFont2 = class extends BasicSoundBank {
 			instruments.pop();
 		}
 		for (const i of instruments) i.name = i.name.trim();
-		this.instruments.push(...instruments);
+		this.addElements(this.instruments, instruments);
 		const ibagIndexes = readZoneIndexes(ibagChunk);
 		if (xdtaChunk && xChunks.ibag) {
 			const extraIndexes = readZoneIndexes(xChunks.ibag);
@@ -58785,7 +59127,7 @@ var SoundFont2 = class extends BasicSoundBank {
 			presets.pop();
 		}
 		for (const p of presets) p.name = p.name.trim();
-		this.addPresets(...presets);
+		this.addElements(this.presets, presets);
 		const pbagIndexes = readZoneIndexes(pbagChunk);
 		if (xdtaChunk && xChunks.pbag) {
 			const extraIndexes = readZoneIndexes(xChunks.pbag);
@@ -58860,6 +59202,7 @@ 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);
@@ -58888,6 +59231,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(),
@@ -58914,7 +59258,6 @@ var DecodedSampleCache = class {
 	*/
 	totalBytes = 0;
 	entries = /* @__PURE__ */ new Map();
-	unreleasable = /* @__PURE__ */ new WeakSet();
 	voiceCache;
 	/**
 	* @param budget The budget in bytes.
@@ -58935,7 +59278,7 @@ var DecodedSampleCache = class {
 	touch(sample, cacheKey) {
 		let entry = this.entries.get(sample);
 		if (entry) this.entries.delete(sample);
-		if (this.unreleasable.has(sample) || sample.storedForm === "float32" && !(sample instanceof DLSSample)) {
+		if (!sample.canRedecode) {
 			if (entry) this.totalBytes -= entry.bytes;
 			return;
 		}
@@ -58950,16 +59293,29 @@ var DecodedSampleCache = class {
 		this.entries.set(sample, entry);
 		if (this.totalBytes > this.budget) this.evict(sample);
 	}
+	/**
+	* Stops tracking samples, for example when their sound bank is removed.
+	* The samples are not released, the cache just stops holding them.
+	* Voices cached from them are dropped too.
+	* @param samples The samples to forget.
+	*/
+	forget(samples) {
+		for (const sample of samples) {
+			const entry = this.entries.get(sample);
+			if (!entry) continue;
+			this.entries.delete(sample);
+			this.totalBytes -= entry.bytes;
+			for (const key of entry.cacheKeys) this.voiceCache.delete(key);
+		}
+	}
 	evict(keep) {
 		for (const [sample, entry] of this.entries) {
 			if (this.totalBytes <= this.budget) return;
 			if (sample === keep) continue;
 			this.entries.delete(sample);
 			this.totalBytes -= entry.bytes;
-			if (!sample.releaseDecoded()) {
-				this.unreleasable.add(sample);
-				continue;
-			}
+			if (!sample.canRedecode) continue;
+			sample.releaseDecoded();
 			for (const key of entry.cacheKeys) this.voiceCache.delete(key);
 		}
 	}
@@ -59002,6 +59358,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 = [
@@ -59104,6 +59470,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
 	*/
@@ -59227,10 +59603,6 @@ var SpessaSynthProcessor = class {
 	*/
 	gsDelayActive = false;
 	/**
-	* The sound bank manager, which manages all sound banks and presets.
-	*/
-	soundBankManager = new SoundBankManager(this.updatePresetList.bind(this));
-	/**
 	* The sample rate, in Hertz.
 	*/
 	sampleRate;
@@ -59326,6 +59698,12 @@ var SpessaSynthProcessor = class {
 	*/
 	decodedSamples;
 	/**
+	* The sound bank manager, which manages all sound banks and presets.
+	*/
+	soundBankManager = new SoundBankManager(this.updatePresetList.bind(this), (bank) => {
+		this.decodedSamples.forget(bank.samples);
+	});
+	/**
 	* The synthesizer's GS reverb processor.
 	*
 	* Used when {@link GlobalMIDIParameter.system} is `gm` `gm2` or `gs`.
@@ -59347,6 +59725,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`.
@@ -59430,6 +59815,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);
@@ -59439,6 +59825,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);
@@ -59833,6 +60221,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", {
@@ -59989,10 +60388,10 @@ var SpessaSynthProcessor = class {
 		*              │          │ │    Chorus     │                │
 		*              │          │ │   Processor   ├──────────┐     │
 		*              │          │ └─┬──────────┬──┘          │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
-		*              │          │   │          │             │     │
+		*         ┌────┴────┐     │   │          │             │     │
+		*         │Equalizer│     │   │          │             │     │
+		*         │or Bypass│     │   │          │             │     │
+		*         └────┬────┘     │   │          │             │     │
 		*              │          │   │          𜸊             𜸊     𜸊
 		*              │          │   │ ┌────────┴───────┐   ┌─┴─────┴────────┐
 		*              │          └───┼>┤     Delay      ├─>>┤     Reverb     │
@@ -60021,6 +60420,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) {
@@ -60036,6 +60436,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) {
@@ -60121,6 +60525,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++) {
@@ -60141,7 +60554,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);
@@ -60716,6 +61134,6 @@ var SpessaSynthProcessor = class {
 		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, wavToAudio };
 
 //# sourceMappingURL=index.js.map