@kidlib/web-audio 0.1.1 → 0.1.3

package/dist/processors/processors.js

@@ -1,1627 +1,1479 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _SamplePlayerProcessor_instances, handleMessage_fn, resetState_fn, stop_fn, smoothLoopWrap_fn, _clamp, _clampZeroCrossing, findNearestZeroCrossing_fn, normalizedToSamples_fn, samplesToNormalized_fn, midiVelocityToGain_fn, getBufferDurationSeconds_fn, getMusicalNoteDurations_fn, quantizeLoopDuration_fn, extractPositionParams_fn, calculatePlaybackRange_fn, calculateLoopRange_fn, getSafeParam_fn, getConstantFlags_fn, resetDurationPreservation_fn, isDurationPreservationActive_fn, prepareDurationPreservingSample_fn, advanceDurationPreservingPlayback_fn, generateLoopDrift_fn, analyzeLoopAmplitude_fn;
+//#region src/utils/search/findClosest.ts
+/**
+* Generic binary search that finds the closest element using a custom comparison function
+* @param sortedArray - Array sorted according to the compareValue function
+* @param target - Target value to search for
+* @param getValue - Function to extract comparison value from array elements (defaults to identity for number arrays)
+* @param getDistance - Optional function to calculate distance (defaults to absolute difference)
+* @returns The array index of the element which value is closest to the target value
+*/
 function findClosestIdx(sortedArray, target, direction = "any", getValue = (x) => x, getDistance = (a, b) => Math.abs(a - b)) {
-  if (sortedArray.length === 0) {
-    throw new Error("Array cannot be empty");
-  }
-  if (sortedArray.length === 1) {
-    return 0;
-  }
-  const targetValue = target;
-  const firstValue = getValue(sortedArray[0]);
-  const lastValue = getValue(sortedArray[sortedArray.length - 1]);
-  if (targetValue <= firstValue) return 0;
-  if (targetValue >= lastValue) return sortedArray.length - 1;
-  let left = 0;
-  let right = sortedArray.length - 1;
-  while (left < right - 1) {
-    const mid = Math.floor((left + right) / 2);
-    const midValue = getValue(sortedArray[mid]);
-    if (midValue === targetValue) {
-      return mid;
-    } else if (midValue < targetValue) {
-      left = mid;
-    } else {
-      right = mid;
-    }
-  }
-  if (direction === "left") return left;
-  if (direction === "right") return right;
-  const leftDistance = getDistance(getValue(sortedArray[left]), targetValue);
-  const rightDistance = getDistance(getValue(sortedArray[right]), targetValue);
-  return leftDistance <= rightDistance ? left : right;
+	if (sortedArray.length === 0) throw new Error("Array cannot be empty");
+	if (sortedArray.length === 1) return 0;
+	const targetValue = target;
+	const firstValue = getValue(sortedArray[0]);
+	const lastValue = getValue(sortedArray[sortedArray.length - 1]);
+	if (targetValue <= firstValue) return 0;
+	if (targetValue >= lastValue) return sortedArray.length - 1;
+	let left = 0;
+	let right = sortedArray.length - 1;
+	while (left < right - 1) {
+		const mid = Math.floor((left + right) / 2);
+		const midValue = getValue(sortedArray[mid]);
+		if (midValue === targetValue) return mid;
+		else if (midValue < targetValue) left = mid;
+		else right = mid;
+	}
+	if (direction === "left") return left;
+	if (direction === "right") return right;
+	return getDistance(getValue(sortedArray[left]), targetValue) <= getDistance(getValue(sortedArray[right]), targetValue) ? left : right;
 }
+/**
+* Generic binary search that finds the closest element using a custom comparison function
+* @param sortedArray - Array sorted according to the compareValue function
+* @param target - Target value to search for
+* @param getValue - Function to extract comparison value from array elements (defaults to identity for number arrays)
+* @param getDistance - Optional function to calculate distance (defaults to absolute difference)
+* @returns The array element which value is closest to the target value
+*/
 function findClosest(sortedArray, target, direction = "any", getValue = (x) => x, getDistance = (a, b) => Math.abs(a - b)) {
-  const index = findClosestIdx(
-    sortedArray,
-    target,
-    direction,
-    getValue,
-    getDistance
-  );
-  return sortedArray[index];
+	return sortedArray[findClosestIdx(sortedArray, target, direction, getValue, getDistance)];
 }
-const SAMPLE_PLAYER_WORKLET_AUDIOPARAMS = {
-  masterGain: {
-    name: "masterGain",
-    defaultValue: 1,
-    minValue: 0,
-    maxValue: 2,
-    automationRate: "k-rate"
-  },
-  envGain: {
-    name: "envGain",
-    defaultValue: 0,
-    minValue: 0,
-    maxValue: 1,
-    automationRate: "a-rate"
-  },
-  velocity: {
-    name: "velocity",
-    defaultValue: 100,
-    minValue: 0,
-    maxValue: 127,
-    automationRate: "k-rate"
-  },
-  pan: {
-    name: "pan",
-    defaultValue: 0,
-    minValue: -1,
-    // -1 hard left
-    maxValue: 1,
-    // 1 hard right
-    automationRate: "k-rate"
-  },
-  playbackRate: {
-    name: "playbackRate",
-    defaultValue: 1,
-    minValue: 0.1,
-    maxValue: 24,
-    automationRate: "a-rate"
-  },
-  // NOTE: Time based params use seconds
-  loopStart: {
-    name: "loopStart",
-    defaultValue: 0,
-    minValue: 0,
-    maxValue: 99999,
-    // Max sample length in seconds
-    automationRate: "k-rate"
-  },
-  loopEnd: {
-    name: "loopEnd",
-    defaultValue: 99999,
-    // Will be set to actual buffer duration when loaded
-    minValue: 0,
-    maxValue: 99999,
-    automationRate: "k-rate"
-  },
-  startPoint: {
-    name: "startPoint",
-    defaultValue: 0,
-    minValue: 0,
-    maxValue: 9999,
-    // Max sample length in seconds
-    automationRate: "k-rate"
-  },
-  endPoint: {
-    name: "endPoint",
-    defaultValue: 9999,
-    // Will be set to actual buffer duration when loaded
-    minValue: 0,
-    maxValue: 9999,
-    automationRate: "k-rate"
-  },
-  playbackPosition: {
-    name: "playbackPosition",
-    defaultValue: 0,
-    minValue: 0,
-    maxValue: 99999,
-    automationRate: "k-rate"
-  },
-  loopDurationDriftAmount: {
-    name: "loopDurationDriftAmount",
-    defaultValue: 0,
-    minValue: 0,
-    maxValue: 1,
-    // 0 = no drift, 1 = max drift (up to 100% of loop duration)
-    automationRate: "k-rate"
-  },
-  maxLoopCount: {
-    name: "maxLoopCount",
-    defaultValue: 999999,
-    minValue: 1,
-    maxValue: 999999,
-    automationRate: "k-rate"
-  },
-  tempo: {
-    name: "tempo",
-    defaultValue: 120,
-    minValue: 20,
-    maxValue: 300,
-    automationRate: "k-rate"
-  }
-};
-const SAMPLE_PLAYER_WORKLET_AUDIOPARAM_DESCRIPTORS = Object.values(
-  SAMPLE_PLAYER_WORKLET_AUDIOPARAMS
-);
-class SamplePlayerProcessor extends AudioWorkletProcessor {
-  // ===== CONSTRUCTOR =====
-  constructor() {
-    super();
-    __privateAdd(this, _SamplePlayerProcessor_instances);
-    __privateAdd(this, _clamp, (value, min, max) => Math.max(min, Math.min(max, value)));
-    __privateAdd(this, _clampZeroCrossing, (value) => __privateGet(this, _clamp).call(this, value, this.minZeroCrossing, this.maxZeroCrossing));
-    this.buffer = null;
-    this.minZeroCrossing = 0;
-    this.maxZeroCrossing = 0;
-    this.usePlaybackPosition = false;
-    this.enableLoopSmoothing = true;
-    this.enableAdaptiveDrift = true;
-    this.enableAmplitudeCompensation = true;
-    this.syncLoopToTempo = false;
-    this.keytrackLoopAmount = 0;
-    this.durationPreservation = {
-      enabled: false,
-      maxDriftSamples: Math.floor(sampleRate * 0.04),
-      timelinePosition: 0,
-      resetPending: false
-    };
-    this.PITCH_PRESERVATION_THRESHOLD = Math.floor(sampleRate * 0.061);
-    this.AMPLITUDE_COMPENSATION_THRESHOLD = Math.floor(sampleRate / 16.35);
-    this.port.onmessage = __privateMethod(this, _SamplePlayerProcessor_instances, handleMessage_fn).bind(this);
-    __privateMethod(this, _SamplePlayerProcessor_instances, resetState_fn).call(this);
-    this.port.postMessage({ type: "initialized" });
-  }
-  // ===== PARAMETER DESCRIPTORS =====
-  static get parameterDescriptors() {
-    return SAMPLE_PLAYER_WORKLET_AUDIOPARAM_DESCRIPTORS;
-  }
-  // ===== MAIN PROCESS METHOD =====
-  process(inputs, outputs, parameters) {
-    var _a, _b, _c;
-    const output = outputs[0];
-    this.debugCounter++;
-    if (!output || !this.isPlaying || !((_b = (_a = this.buffer) == null ? void 0 : _a[0]) == null ? void 0 : _b.length)) {
-      return true;
-    }
-    const masterGain = parameters.masterGain[0];
-    const positionParams = __privateMethod(this, _SamplePlayerProcessor_instances, extractPositionParams_fn).call(this, parameters);
-    const playbackRange = __privateMethod(this, _SamplePlayerProcessor_instances, calculatePlaybackRange_fn).call(this, positionParams);
-    const effectivePlaybackRate = parameters.playbackRate[0] * this.transpositionPlaybackrate;
-    const tempo = parameters.tempo[0];
-    const loopRange = __privateMethod(this, _SamplePlayerProcessor_instances, calculateLoopRange_fn).call(this, positionParams, playbackRange, parameters.loopDurationDriftAmount[0], tempo, effectivePlaybackRate);
-    const amplitudeGain = __privateMethod(this, _SamplePlayerProcessor_instances, analyzeLoopAmplitude_fn).call(this, loopRange.loopStartSamples, loopRange.loopEndSamples);
-    const velocityGain = __privateMethod(this, _SamplePlayerProcessor_instances, midiVelocityToGain_fn).call(this, parameters.velocity[0]) * this.velocitySensitivity;
-    const basePan = parameters.pan[0];
-    const effectivePan = this.panDriftEnabled ? Math.max(-1, Math.min(1, basePan + this.currentPanDrift)) : basePan;
-    let outputChannels;
-    if (output instanceof Float32Array) {
-      outputChannels = [output];
-    } else if (Array.isArray(output) && output.every((ch) => ch instanceof Float32Array)) {
-      outputChannels = output;
-    } else {
-      console.error("Unexpected output structure:", {
-        outputType: typeof output,
-        isArray: Array.isArray(output),
-        constructor: (_c = output == null ? void 0 : output.constructor) == null ? void 0 : _c.name,
-        length: output == null ? void 0 : output.length
-      });
-      return true;
-    }
-    const numChannels = outputChannels.length;
-    const isConstant = __privateMethod(this, _SamplePlayerProcessor_instances, getConstantFlags_fn).call(this, parameters);
-    const silencePadTail = loopRange.loopEndSamples > playbackRange.endSamples;
-    const TAIL_FADE_SAMPLES = 64;
-    if (this.playbackPosition === 0) {
-      this.playbackPosition = this.reversePlayback ? playbackRange.endSamples - 1 : playbackRange.startSamples;
-      __privateMethod(this, _SamplePlayerProcessor_instances, resetDurationPreservation_fn).call(this, this.playbackPosition);
-    }
-    for (let sample = 0; sample < outputChannels[0].length; sample++) {
-      const envelopeGain = __privateMethod(this, _SamplePlayerProcessor_instances, getSafeParam_fn).call(this, parameters.envGain, sample, isConstant.envGain);
-      const baseRate = __privateMethod(this, _SamplePlayerProcessor_instances, getSafeParam_fn).call(this, parameters.playbackRate, sample, isConstant.playbackRate);
-      const effectiveRate = this.reversePlayback ? -Math.abs(baseRate) : Math.abs(baseRate);
-      const playbackStep = effectiveRate * this.transpositionPlaybackrate;
-      const canWrapLoop = this.loopEnabled && this.loopCount < parameters.maxLoopCount[0];
-      if (canWrapLoop) {
-        if (!this.reversePlayback && this.playbackPosition >= loopRange.loopEndSamples) {
-          __privateMethod(this, _SamplePlayerProcessor_instances, smoothLoopWrap_fn).call(this, silencePadTail ? 0 : this.buffer[0][Math.floor(this.playbackPosition - 1)] || 0, this.buffer[0][Math.floor(loopRange.loopStartSamples)] || 0);
-          this.playbackPosition = loopRange.loopStartSamples;
-          this.loopCount++;
-          this.nextDriftGenerated = false;
-        } else if (this.reversePlayback && this.playbackPosition <= loopRange.loopStartSamples) {
-          __privateMethod(this, _SamplePlayerProcessor_instances, smoothLoopWrap_fn).call(this, this.buffer[0][Math.floor(loopRange.loopStartSamples)] || 0, silencePadTail ? 0 : this.buffer[0][Math.floor(loopRange.loopEndSamples) - 1] || 0);
-          this.playbackPosition = loopRange.loopEndSamples;
-          this.loopCount++;
-          this.nextDriftGenerated = false;
-        }
-      }
-      const durationResetTarget = __privateMethod(this, _SamplePlayerProcessor_instances, prepareDurationPreservingSample_fn).call(this, playbackStep, loopRange);
-      const shouldStopForward = !this.reversePlayback && (__privateMethod(this, _SamplePlayerProcessor_instances, isDurationPreservationActive_fn).call(this, loopRange) ? this.durationPreservation.timelinePosition : this.playbackPosition) >= playbackRange.endSamples;
-      const shouldStopReverse = this.reversePlayback && (__privateMethod(this, _SamplePlayerProcessor_instances, isDurationPreservationActive_fn).call(this, loopRange) ? this.durationPreservation.timelinePosition : this.playbackPosition) <= playbackRange.startSamples;
-      const isWithinLoop = this.loopEnabled && this.playbackPosition >= loopRange.loopStartSamples && this.playbackPosition <= loopRange.loopEndSamples;
-      if ((shouldStopForward || shouldStopReverse) && !(this.loopEnabled && isWithinLoop)) {
-        __privateMethod(this, _SamplePlayerProcessor_instances, stop_fn).call(this);
-        return true;
-      }
-      let tailGain = 1;
-      if (silencePadTail) {
-        const distToEnd = playbackRange.endSamples - this.playbackPosition;
-        if (distToEnd < TAIL_FADE_SAMPLES) {
-          tailGain = Math.max(0, distToEnd / TAIL_FADE_SAMPLES);
-        }
-      }
-      const currentPosition = Math.floor(this.playbackPosition);
-      const positionOffset = this.playbackPosition - currentPosition;
-      let nextPosition, interpWeight;
-      if (this.reversePlayback) {
-        nextPosition = Math.max(
-          currentPosition - 1,
-          playbackRange.startSamples
-        );
-        interpWeight = 1 - positionOffset;
-      } else {
-        nextPosition = Math.min(
-          currentPosition + 1,
-          playbackRange.endSamples - 1
-        );
-        interpWeight = positionOffset;
-      }
-      for (let channel = 0; channel < numChannels; channel++) {
-        if (!outputChannels[channel]) {
-          console.warn(
-            `Output channel ${channel} does not exist. Available channels:`,
-            outputChannels.length
-          );
-          continue;
-        }
-        const bufferChannelIndex = Math.min(channel, this.buffer.length - 1);
-        const bufferChannel = this.buffer[bufferChannelIndex];
-        const currentSample = bufferChannel[currentPosition] || 0;
-        const nextSample = bufferChannel[nextPosition] || 0;
-        let interpolatedSample = currentSample + interpWeight * (nextSample - currentSample);
-        if (this.applyClickCompensation) {
-          interpolatedSample += this.loopClickCompensation;
-          if (this.compensationDecay) {
-            this.loopClickCompensation *= this.compensationDecay;
-            if (Math.abs(this.loopClickCompensation) < 1e-3) {
-              this.applyClickCompensation = false;
-            }
-          } else {
-            this.applyClickCompensation = false;
-          }
-        }
-        const finalSample = interpolatedSample * velocityGain * envelopeGain * masterGain * amplitudeGain * tailGain;
-        let panAdjustedSample = finalSample;
-        if (outputChannels.length === 2) {
-          if (channel === 0) {
-            panAdjustedSample = finalSample * (1 - Math.max(0, effectivePan));
-          } else if (channel === 1) {
-            panAdjustedSample = finalSample * (1 - Math.max(0, -effectivePan));
-          }
-        }
-        outputChannels[channel][sample] = Math.max(
-          -1,
-          Math.min(1, isFinite(panAdjustedSample) ? panAdjustedSample : 0)
-        );
-      }
-      __privateMethod(this, _SamplePlayerProcessor_instances, advanceDurationPreservingPlayback_fn).call(this, playbackStep, durationResetTarget, loopRange, canWrapLoop);
-    }
-    if (this.usePlaybackPosition) {
-      const normalizedPosition = __privateMethod(this, _SamplePlayerProcessor_instances, samplesToNormalized_fn).call(this, this.playbackPosition);
-      this.port.postMessage({
-        type: "voice:position",
-        position: normalizedPosition
-      });
-    }
-    return true;
-  }
-}
-_SamplePlayerProcessor_instances = new WeakSet();
-// ===== MESSAGE HANDLING =====
-handleMessage_fn = function(event) {
-  const {
-    type,
-    value,
-    buffer,
-    timestamp,
-    durationSeconds,
-    zeroCrossings,
-    semitones,
-    allowedPeriods,
-    playbackDirection
-  } = event.data;
-  switch (type) {
-    case "voice:reset":
-      __privateMethod(this, _SamplePlayerProcessor_instances, resetState_fn).call(this);
-      this.port.postMessage({ type: "voice:reset" });
-      break;
-    case "voice:setBuffer":
-      __privateMethod(this, _SamplePlayerProcessor_instances, resetState_fn).call(this);
-      this.zeroCrossings = [];
-      this.minZeroCrossing = 0;
-      this.maxZeroCrossing = 0;
-      this.buffer = null;
-      this.buffer = buffer;
-      this.port.postMessage({
-        type: "voice:loaded",
-        durationSeconds,
-        time: currentTime
-      });
-      break;
-    case "transpose":
-      this.transpositionPlaybackrate = Math.pow(2, semitones / 12);
-      this.port.postMessage({
-        type: "voice:transposed",
-        semitones,
-        time: currentTime
-      });
-      break;
-    case "voice:setZeroCrossings":
-      this.zeroCrossings = (zeroCrossings || []).map(
-        (timeSec) => timeSec * sampleRate
-      );
-      if (this.zeroCrossings.length > 0) {
-        this.minZeroCrossing = this.zeroCrossings[0];
-        this.maxZeroCrossing = this.zeroCrossings[this.zeroCrossings.length - 1];
-      }
-      break;
-    case "voice:start":
-      this.isReleasing = false;
-      this.isPlaying = true;
-      this.loopCount = 0;
-      this.playbackPosition = 0;
-      this.port.postMessage({
-        type: "voice:started",
-        time: timestamp || currentTime
-      });
-      break;
-    case "voice:release":
-      this.isReleasing = true;
-      this.port.postMessage({
-        type: "voice:releasing",
-        time: currentTime
-      });
-      break;
-    case "voice:stop":
-      __privateMethod(this, _SamplePlayerProcessor_instances, stop_fn).call(this);
-      break;
-    case "setLoopEnabled":
-      this.loopEnabled = value;
-      this.port.postMessage({
-        type: "loop:enabled",
-        enabled: value
-      });
-      break;
-    case "setPanDriftEnabled":
-      this.panDriftEnabled = value;
-      break;
-    case "voice:setPlaybackDirection": {
-      const reverse = playbackDirection === "reverse";
-      if (reverse !== this.reversePlayback && this.playbackPosition > 0) {
-        this.playbackPosition += reverse ? 1 : -1;
-      }
-      this.reversePlayback = reverse;
-      this.port.postMessage({
-        type: "voice:playbackDirectionChange",
-        playbackDirection
-      });
-      break;
-    }
-    case "voice:usePlaybackPosition":
-      this.usePlaybackPosition = value;
-      break;
-    case "syncLoopToTempo":
-      this.syncLoopToTempo = value;
-      this.port.postMessage({
-        type: "loop:syncToTempo",
-        enabled: value
-      });
-      break;
-    case "setKeytrackLoopAmount":
-      this.keytrackLoopAmount = Math.max(0, Math.min(1, value));
-      break;
-    case "setPreserveDuration":
-      this.durationPreservation.enabled = Boolean(value);
-      __privateMethod(this, _SamplePlayerProcessor_instances, resetDurationPreservation_fn).call(this, this.playbackPosition);
-      break;
-  }
-};
-// ===== METHODS =====
-resetState_fn = function() {
-  this.isPlaying = false;
-  this.isReleasing = false;
-  this.loopEnabled = false;
-  this.transpositionPlaybackrate = 1;
-  this.velocitySensitivity = 1;
-  this.reversePlayback = false;
-  this.playbackPosition = 0;
-  this.debugCounter = 0;
-  this.loopCount = 0;
-  this.applyClickCompensation = false;
-  this.loopClickCompensation = 0;
-  this.driftUpdateCounter = 0;
-  this.currentLoopDrift = 0;
-  this.currentPanDrift = 0;
-  this.panDriftEnabled = true;
-  this.nextDriftGenerated = false;
-  this.loopAmplitudeGain = 1;
-  this.lastAnalyzedLoopStart = -1;
-  this.lastAnalyzedLoopEnd = -1;
-  __privateMethod(this, _SamplePlayerProcessor_instances, resetDurationPreservation_fn).call(this);
-};
-stop_fn = function() {
-  this.isPlaying = false;
-  this.isReleasing = false;
-  this.playbackPosition = 0;
-  this.port.postMessage({ type: "voice:stopped" });
-};
-// Arm click compensation for a loop-wrap discontinuity between the sample
-// just emitted and the first sample of the next pass.
-smoothLoopWrap_fn = function(lastLoopSample, newFirstSample) {
-  const discontinuity = lastLoopSample - newFirstSample;
-  if (this.enableLoopSmoothing && Math.abs(discontinuity) > 0.01) {
-    this.loopClickCompensation = discontinuity * 0.5;
-    this.compensationDecay = 0.9;
-    this.applyClickCompensation = true;
-  }
-};
-_clamp = new WeakMap();
-_clampZeroCrossing = new WeakMap();
-findNearestZeroCrossing_fn = function(position, direction = "any", maxDistance = null) {
-  if (!this.zeroCrossings || this.zeroCrossings.length === 0) {
-    return position;
-  }
-  const closestValue = findClosest(this.zeroCrossings, position, direction);
-  if (maxDistance !== null && Math.abs(closestValue - position) > maxDistance) {
-    return position;
-  }
-  return closestValue;
-};
-// ===== CONVERSION UTILITIES =====
-/**
- * Convert normalized position (0-1) to sample index
- * @param {number} normalizedPosition - Position as 0-1 value
- * @returns {number} - Sample index
- */
-normalizedToSamples_fn = function(normalizedPosition) {
-  if (!this.buffer || !this.buffer[0]) return 0;
-  return normalizedPosition * this.buffer[0].length;
-};
-/**
- * Convert sample index to normalized position (0-1)
- * @param {number} sampleIndex - Sample index
- * @returns {number} - Normalized position 0-1
- */
-samplesToNormalized_fn = function(sampleIndex) {
-  if (!this.buffer || !this.buffer[0]) return 0;
-  return sampleIndex / this.buffer[0].length;
-};
-/**
- * Convert MIDI velocity (0-127) to gain multiplier (0-1)
- * @param {number} midiVelocity - MIDI velocity 0-127
- * @returns {number} - Gain multiplier 0-1
- */
-midiVelocityToGain_fn = function(midiVelocity) {
-  return Math.max(0, Math.min(1, midiVelocity / 127));
-};
-/**
- * Get buffer duration in seconds
- * @returns {number} - Buffer duration in seconds
- */
-getBufferDurationSeconds_fn = function() {
-  var _a, _b;
-  return (((_b = (_a = this.buffer) == null ? void 0 : _a[0]) == null ? void 0 : _b.length) || 0) / sampleRate;
-};
-/**
- * Calculate musical note durations in samples for given tempo
- * @param {number} tempo - BPM
- * @returns {Object} - Musical note durations in samples
- */
-getMusicalNoteDurations_fn = function(tempo) {
-  const beatsPerSecond = tempo / 60;
-  const samplesPerBeat = sampleRate / beatsPerSecond;
-  return {
-    // Standard notes
-    whole: samplesPerBeat * 4,
-    half: samplesPerBeat * 2,
-    quarter: samplesPerBeat,
-    eighth: samplesPerBeat / 2,
-    sixteenth: samplesPerBeat / 4,
-    thirtySecond: samplesPerBeat / 8,
-    // Triplets (divide by 3/2 = multiply by 2/3)
-    quarterTriplet: samplesPerBeat * 2 / 3,
-    eighthTriplet: samplesPerBeat / 2 * 2 / 3,
-    sixteenthTriplet: samplesPerBeat / 4 * 2 / 3
-  };
-};
-/**
- * Quantize loop duration to nearest musical interval (skips if below the smallest quantize option)
- * @param {number} loopDurationSamples - Current loop duration in samples
- * @param {number} tempo - Current tempo in BPM
- * @param {number} playbackRate - Current playback rate
- * @returns {number} - Quantized loop duration in samples
- */
-quantizeLoopDuration_fn = function(loopDurationSamples, tempo, playbackRate) {
-  if (!this.syncLoopToTempo) {
-    return loopDurationSamples;
-  }
-  const noteDurations = __privateMethod(this, _SamplePlayerProcessor_instances, getMusicalNoteDurations_fn).call(this, tempo);
-  const effectiveDuration = loopDurationSamples / Math.abs(playbackRate);
-  const smallestInterval = noteDurations.thirtySecond;
-  if (effectiveDuration < smallestInterval) {
-    return loopDurationSamples;
-  }
-  const intervals = Object.values(noteDurations);
-  let closestInterval = intervals[0];
-  let smallestDiff = Math.abs(effectiveDuration - closestInterval);
-  for (const interval of intervals) {
-    const diff = Math.abs(effectiveDuration - interval);
-    if (diff < smallestDiff) {
-      smallestDiff = diff;
-      closestInterval = interval;
-    }
-  }
-  return Math.floor(closestInterval * Math.abs(playbackRate));
+var SAMPLE_PLAYER_WORKLET_AUDIOPARAM_DESCRIPTORS = Object.values({
+	masterGain: {
+		name: "masterGain",
+		defaultValue: 1,
+		minValue: 0,
+		maxValue: 2,
+		automationRate: "k-rate"
+	},
+	envGain: {
+		name: "envGain",
+		defaultValue: 0,
+		minValue: 0,
+		maxValue: 1,
+		automationRate: "a-rate"
+	},
+	velocity: {
+		name: "velocity",
+		defaultValue: 100,
+		minValue: 0,
+		maxValue: 127,
+		automationRate: "k-rate"
+	},
+	pan: {
+		name: "pan",
+		defaultValue: 0,
+		minValue: -1,
+		maxValue: 1,
+		automationRate: "k-rate"
+	},
+	playbackRate: {
+		name: "playbackRate",
+		defaultValue: 1,
+		minValue: .1,
+		maxValue: 24,
+		automationRate: "a-rate"
+	},
+	loopStart: {
+		name: "loopStart",
+		defaultValue: 0,
+		minValue: 0,
+		maxValue: 99999,
+		automationRate: "k-rate"
+	},
+	loopEnd: {
+		name: "loopEnd",
+		defaultValue: 99999,
+		minValue: 0,
+		maxValue: 99999,
+		automationRate: "k-rate"
+	},
+	startPoint: {
+		name: "startPoint",
+		defaultValue: 0,
+		minValue: 0,
+		maxValue: 9999,
+		automationRate: "k-rate"
+	},
+	endPoint: {
+		name: "endPoint",
+		defaultValue: 9999,
+		minValue: 0,
+		maxValue: 9999,
+		automationRate: "k-rate"
+	},
+	playbackPosition: {
+		name: "playbackPosition",
+		defaultValue: 0,
+		minValue: 0,
+		maxValue: 99999,
+		automationRate: "k-rate"
+	},
+	loopDurationDriftAmount: {
+		name: "loopDurationDriftAmount",
+		defaultValue: 0,
+		minValue: 0,
+		maxValue: 1,
+		automationRate: "k-rate"
+	},
+	maxLoopCount: {
+		name: "maxLoopCount",
+		defaultValue: 999999,
+		minValue: 1,
+		maxValue: 999999,
+		automationRate: "k-rate"
+	},
+	tempo: {
+		name: "tempo",
+		defaultValue: 120,
+		minValue: 20,
+		maxValue: 300,
+		automationRate: "k-rate"
+	}
+});
+//#endregion
+//#region src/worklets/processors/play/sample-player-processor.js
+var SamplePlayerProcessor = class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return SAMPLE_PLAYER_WORKLET_AUDIOPARAM_DESCRIPTORS;
+	}
+	constructor() {
+		super();
+		this.layers = [];
+		this.layerGain = 1;
+		this.minZeroCrossing = 0;
+		this.maxZeroCrossing = 0;
+		this.usePlaybackPosition = false;
+		this.enableLoopSmoothing = true;
+		this.enableAdaptiveDrift = true;
+		this.enableAmplitudeCompensation = true;
+		this.syncLoopToTempo = false;
+		this.keytrackLoopAmount = 0;
+		this.durationPreservation = {
+			enabled: false,
+			maxDriftSamples: Math.floor(sampleRate * .04),
+			timelinePosition: 0,
+			resetPending: false
+		};
+		this.PITCH_PRESERVATION_THRESHOLD = Math.floor(sampleRate * .061);
+		this.AMPLITUDE_COMPENSATION_THRESHOLD = Math.floor(sampleRate / 16.35);
+		this.port.onmessage = this.#handleMessage.bind(this);
+		this.#resetState();
+		this.port.postMessage({ type: "initialized" });
+	}
+	/** Authority layer. All range and duration math reads through this. */
+	get buffer() {
+		return this.layers[0] ?? null;
+	}
+	#handleMessage(event) {
+		const { type, value, buffer, layers, timestamp, durationSeconds, zeroCrossings, allowedPeriods, playbackDirection } = event.data;
+		switch (type) {
+			case "voice:reset":
+				this.#resetState();
+				this.port.postMessage({ type: "voice:reset" });
+				break;
+			case "voice:setBuffer":
+			case "voice:setLayers":
+				this.#resetState();
+				this.zeroCrossings = [];
+				this.minZeroCrossing = 0;
+				this.maxZeroCrossing = 0;
+				this.layers = (layers ?? (buffer ? [buffer] : [])).filter(Boolean);
+				this.layerGain = this.layers.length ? 1 / this.layers.length : 1;
+				this.port.postMessage({
+					type: "voice:loaded",
+					durationSeconds,
+					time: currentTime
+				});
+				break;
+			case "voice:setZeroCrossings":
+				this.zeroCrossings = (zeroCrossings || []).map((timeSec) => timeSec * sampleRate);
+				if (this.zeroCrossings.length > 0) {
+					this.minZeroCrossing = this.zeroCrossings[0];
+					this.maxZeroCrossing = this.zeroCrossings[this.zeroCrossings.length - 1];
+				}
+				break;
+			case "voice:start":
+				this.isReleasing = false;
+				this.isPlaying = true;
+				this.loopCount = 0;
+				this.playbackPosition = 0;
+				this.port.postMessage({
+					type: "voice:started",
+					time: timestamp || currentTime
+				});
+				break;
+			case "voice:release":
+				this.isReleasing = true;
+				this.port.postMessage({
+					type: "voice:releasing",
+					time: currentTime
+				});
+				break;
+			case "voice:stop":
+				this.#stop();
+				break;
+			case "setLoopEnabled":
+				this.loopEnabled = value;
+				this.port.postMessage({
+					type: "loop:enabled",
+					enabled: value
+				});
+				break;
+			case "setPanDriftEnabled":
+				this.panDriftEnabled = value;
+				break;
+			case "voice:setPlaybackDirection": {
+				const reverse = playbackDirection === "reverse";
+				if (reverse !== this.reversePlayback && this.playbackPosition > 0) this.playbackPosition += reverse ? 1 : -1;
+				this.reversePlayback = reverse;
+				this.port.postMessage({
+					type: "voice:playbackDirectionChange",
+					playbackDirection
+				});
+				break;
+			}
+			case "voice:usePlaybackPosition":
+				this.usePlaybackPosition = value;
+				break;
+			case "syncLoopToTempo":
+				this.syncLoopToTempo = value;
+				this.port.postMessage({
+					type: "loop:syncToTempo",
+					enabled: value
+				});
+				break;
+			case "setKeytrackLoopAmount":
+				this.keytrackLoopAmount = Math.max(0, Math.min(1, value));
+				break;
+			case "setPreserveDuration":
+				this.durationPreservation.enabled = Boolean(value);
+				this.#resetDurationPreservation(this.playbackPosition);
+		}
+	}
+	#resetState() {
+		this.isPlaying = false;
+		this.isReleasing = false;
+		this.loopEnabled = false;
+		this.velocitySensitivity = 1;
+		this.reversePlayback = false;
+		this.playbackPosition = 0;
+		this.debugCounter = 0;
+		this.loopCount = 0;
+		this.applyClickCompensation = false;
+		this.loopClickCompensation = 0;
+		this.driftUpdateCounter = 0;
+		this.currentLoopDrift = 0;
+		this.currentPanDrift = 0;
+		this.panDriftEnabled = true;
+		this.nextDriftGenerated = false;
+		this.loopAmplitudeGain = 1;
+		this.lastAnalyzedLoopStart = -1;
+		this.lastAnalyzedLoopEnd = -1;
+		this.#resetDurationPreservation();
+	}
+	#stop() {
+		this.isPlaying = false;
+		this.isReleasing = false;
+		this.playbackPosition = 0;
+		this.port.postMessage({ type: "voice:stopped" });
+	}
+	#smoothLoopWrap(lastLoopSample, newFirstSample) {
+		const discontinuity = lastLoopSample - newFirstSample;
+		if (this.enableLoopSmoothing && Math.abs(discontinuity) > .01) {
+			this.loopClickCompensation = discontinuity * .5;
+			this.compensationDecay = .9;
+			this.applyClickCompensation = true;
+		}
+	}
+	#clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+	#clampZeroCrossing = (value) => this.#clamp(value, this.minZeroCrossing, this.maxZeroCrossing);
+	#findNearestZeroCrossing(position, direction = "any", maxDistance = null) {
+		if (!this.zeroCrossings || this.zeroCrossings.length === 0) return position;
+		const closestValue = findClosest(this.zeroCrossings, position, direction);
+		if (maxDistance !== null && Math.abs(closestValue - position) > maxDistance) return position;
+		return closestValue;
+	}
+	/**
+	* Convert normalized position (0-1) to sample index
+	* @param {number} normalizedPosition - Position as 0-1 value
+	* @returns {number} - Sample index
+	*/
+	#normalizedToSamples(normalizedPosition) {
+		if (!this.buffer || !this.buffer[0]) return 0;
+		return normalizedPosition * this.buffer[0].length;
+	}
+	/**
+	* Convert sample index to normalized position (0-1)
+	* @param {number} sampleIndex - Sample index
+	* @returns {number} - Normalized position 0-1
+	*/
+	#samplesToNormalized(sampleIndex) {
+		if (!this.buffer || !this.buffer[0]) return 0;
+		return sampleIndex / this.buffer[0].length;
+	}
+	/**
+	* Convert MIDI velocity (0-127) to gain multiplier (0-1)
+	* @param {number} midiVelocity - MIDI velocity 0-127
+	* @returns {number} - Gain multiplier 0-1
+	*/
+	#midiVelocityToGain(midiVelocity) {
+		return Math.max(0, Math.min(1, midiVelocity / 127));
+	}
+	/**
+	* Get buffer duration in seconds
+	* @returns {number} - Buffer duration in seconds
+	*/
+	#getBufferDurationSeconds() {
+		return (this.buffer?.[0]?.length || 0) / sampleRate;
+	}
+	/**
+	* Calculate musical note durations in samples for given tempo
+	* @param {number} tempo - BPM
+	* @returns {Object} - Musical note durations in samples
+	*/
+	#getMusicalNoteDurations(tempo) {
+		const beatsPerSecond = tempo / 60;
+		const samplesPerBeat = sampleRate / beatsPerSecond;
+		return {
+			whole: samplesPerBeat * 4,
+			half: samplesPerBeat * 2,
+			quarter: samplesPerBeat,
+			eighth: samplesPerBeat / 2,
+			sixteenth: samplesPerBeat / 4,
+			thirtySecond: samplesPerBeat / 8,
+			quarterTriplet: samplesPerBeat * 2 / 3,
+			eighthTriplet: samplesPerBeat / 2 * 2 / 3,
+			sixteenthTriplet: samplesPerBeat / 4 * 2 / 3
+		};
+	}
+	/**
+	* Quantize loop duration to nearest musical interval (skips if below the smallest quantize option)
+	* @param {number} loopDurationSamples - Current loop duration in samples
+	* @param {number} tempo - Current tempo in BPM
+	* @param {number} playbackRate - Current playback rate
+	* @returns {number} - Quantized loop duration in samples
+	*/
+	#quantizeLoopDuration(loopDurationSamples, tempo, playbackRate) {
+		if (!this.syncLoopToTempo) return loopDurationSamples;
+		const noteDurations = this.#getMusicalNoteDurations(tempo);
+		const effectiveDuration = loopDurationSamples / Math.abs(playbackRate);
+		if (effectiveDuration < noteDurations.thirtySecond) return loopDurationSamples;
+		const intervals = Object.values(noteDurations);
+		let closestInterval = intervals[0];
+		let smallestDiff = Math.abs(effectiveDuration - closestInterval);
+		for (const interval of intervals) {
+			const diff = Math.abs(effectiveDuration - interval);
+			if (diff < smallestDiff) {
+				smallestDiff = diff;
+				closestInterval = interval;
+			}
+		}
+		return Math.floor(closestInterval * Math.abs(playbackRate));
+	}
+	/**
+	* Extract and convert all position parameters from seconds to samples
+	* @param {Object} parameters - AudioWorkletProcessor parameters
+	* @returns {Object} - Converted parameters in samples
+	*/
+	#extractPositionParams(parameters) {
+		return {
+			startPointSamples: Math.floor(parameters.startPoint[0] * sampleRate),
+			endPointSamples: Math.floor(parameters.endPoint[0] * sampleRate),
+			loopStartSamples: Math.floor(parameters.loopStart[0] * sampleRate),
+			loopEndSamples: Math.floor(parameters.loopEnd[0] * sampleRate)
+		};
+	}
+	/**
+	* Calculate effective playback range in samples
+	* @param {Object} params - Position parameters from #extractPositionParams
+	* @returns {Object} - Effective start and end positions
+	*/
+	#calculatePlaybackRange(params) {
+		const bufferLength = this.buffer?.[0]?.length || 0;
+		const start = Math.max(0, params.startPointSamples);
+		const end = params.endPointSamples > start ? Math.min(bufferLength, params.endPointSamples) : bufferLength;
+		const snappedStart = this.#findNearestZeroCrossing(start, "right");
+		const snappedEnd = this.#findNearestZeroCrossing(end, "left");
+		return {
+			startSamples: snappedStart,
+			endSamples: snappedEnd,
+			durationSamples: snappedEnd - snappedStart
+		};
+	}
+	/**
+	* Calculate effective loop range in samples with optional drift
+	* @param {Object} params - Position parameters from #extractPositionParams
+	* @param {Object} playbackRange - Range from #calculatePlaybackRange
+	* @param {number} driftAmount - Loop duration drift amount (0-1)
+	* @param {number} tempo - Current tempo in BPM
+	* @param {number} playbackRate - Current playback rate
+	* @returns {Object} - Effective loop start and end positions with drift applied
+	*/
+	#calculateLoopRange(params, playbackRange, driftAmount = 0, tempo = 120, playbackRate = 1) {
+		const lpStart = params.loopStartSamples;
+		const lpEnd = params.loopEndSamples;
+		let calcLoopStart = lpStart < lpEnd && lpStart >= 0 ? lpStart : playbackRange.startSamples;
+		let calcLoopEnd = lpEnd > lpStart && lpEnd <= playbackRange.endSamples ? lpEnd : playbackRange.endSamples;
+		let baseDuration = calcLoopEnd - calcLoopStart;
+		if (this.syncLoopToTempo) {
+			const quantizedDuration = this.#quantizeLoopDuration(baseDuration, tempo, playbackRate);
+			calcLoopEnd = calcLoopStart + quantizedDuration;
+			calcLoopEnd = Math.min(calcLoopEnd, playbackRange.endSamples);
+		}
+		if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD && this.keytrackLoopAmount > 0 && !this.syncLoopToTempo) {
+			const scale = 1 + this.keytrackLoopAmount * (Math.abs(playbackRate) - 1);
+			baseDuration = Math.max(1, Math.floor(baseDuration * scale));
+			calcLoopEnd = calcLoopStart + baseDuration;
+		}
+		baseDuration = calcLoopEnd - calcLoopStart;
+		if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD) calcLoopStart = this.#findNearestZeroCrossing(calcLoopStart, "right");
+		if (driftAmount > 0 && this.loopEnabled) {
+			if (!this.nextDriftGenerated || this.loopCount === 0) {
+				const updateInterval = baseDuration <= this.PITCH_PRESERVATION_THRESHOLD ? Math.max(1, Math.floor(this.PITCH_PRESERVATION_THRESHOLD / baseDuration)) : 1;
+				if (this.driftUpdateCounter % updateInterval === 0) {
+					this.currentLoopDrift = this.#generateLoopDrift(driftAmount, baseDuration);
+					if (this.panDriftEnabled && driftAmount > 0 && this.loopCount > 0) {
+						const panDriftAmountScalar = 1e-4;
+						this.currentPanDrift = this.currentLoopDrift * panDriftAmountScalar;
+					} else this.currentPanDrift = 0;
+				}
+				this.driftUpdateCounter++;
+				this.nextDriftGenerated = true;
+			}
+			const driftedLoopEnd = calcLoopEnd + this.currentLoopDrift;
+			const minLoopDuration = Math.max(1, Math.floor(baseDuration * .1));
+			const maxLoopEnd = Math.max(playbackRange.endSamples, calcLoopEnd);
+			calcLoopEnd = Math.max(calcLoopStart + minLoopDuration, Math.min(maxLoopEnd, driftedLoopEnd));
+		} else this.currentPanDrift = 0;
+		if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD && calcLoopEnd <= playbackRange.endSamples) calcLoopEnd = Math.max(calcLoopStart + 1, this.#findNearestZeroCrossing(calcLoopEnd, "left"));
+		const loopDuration = calcLoopEnd - calcLoopStart;
+		return {
+			loopStartSamples: calcLoopStart,
+			loopEndSamples: calcLoopEnd,
+			loopDurationSamples: loopDuration
+		};
+	}
+	#getSafeParam(paramArray, index, isConstant) {
+		return isConstant ? paramArray[0] : paramArray[Math.min(index, paramArray.length - 1)];
+	}
+	#getConstantFlags(parameters) {
+		this.constantFlags ??= {
+			envGain: true,
+			playbackRate: true
+		};
+		this.constantFlags.envGain = parameters.envGain.length === 1;
+		this.constantFlags.playbackRate = parameters.playbackRate.length === 1;
+		return this.constantFlags;
+	}
+	#resetDurationPreservation(position = 0) {
+		this.durationPreservation.timelinePosition = position;
+		this.durationPreservation.resetPending = false;
+	}
+	#isDurationPreservationActive(loopRange) {
+		return this.durationPreservation.enabled && Boolean(this.zeroCrossings?.length) && (!this.loopEnabled || loopRange.loopDurationSamples > this.PITCH_PRESERVATION_THRESHOLD);
+	}
+	#prepareDurationPreservingSample(playbackRate, loopRange) {
+		const state = this.durationPreservation;
+		if (!this.#isDurationPreservationActive(loopRange)) return null;
+		if (Math.abs(this.playbackPosition - state.timelinePosition) > state.maxDriftSamples) state.resetPending = true;
+		if (!state.resetPending) return null;
+		const direction = playbackRate < 0 ? "left" : "right";
+		const outgoingZero = this.#findNearestZeroCrossing(this.playbackPosition, direction);
+		if (Math.abs(outgoingZero - this.playbackPosition) > Math.abs(playbackRate)) return null;
+		this.playbackPosition = outgoingZero;
+		state.resetPending = false;
+		return this.#findNearestZeroCrossing(state.timelinePosition, "any", state.maxDriftSamples);
+	}
+	#advanceDurationPreservingPlayback(playbackRate, resetTarget, loopRange, canWrapLoop) {
+		const state = this.durationPreservation;
+		this.playbackPosition = resetTarget === null ? this.playbackPosition + playbackRate : resetTarget;
+		if (this.#isDurationPreservationActive(loopRange)) {
+			state.timelinePosition += playbackRate < 0 ? -1 : 1;
+			if (canWrapLoop && playbackRate >= 0 && state.timelinePosition >= loopRange.loopEndSamples) state.timelinePosition = loopRange.loopStartSamples;
+			else if (canWrapLoop && playbackRate < 0 && state.timelinePosition <= loopRange.loopStartSamples) state.timelinePosition = loopRange.loopEndSamples - 1;
+		} else this.#resetDurationPreservation(this.playbackPosition);
+	}
+	/**
+	* Generate a new drift amount for the current loop iteration
+	* @param {number} driftAmount - Maximum drift amount (0-1)
+	* @param {number} baseDuration - Base loop duration in samples
+	* @returns {number} - Drift amount in samples
+	*/
+	#generateLoopDrift(driftAmount, baseDuration) {
+		if (driftAmount <= 0) return 0;
+		const randomFactor = (Math.random() - .5) * 2;
+		let effectiveDriftAmount = driftAmount;
+		if (this.enableAdaptiveDrift) {
+			const shortThreshold = 1024;
+			const longThreshold = 8192;
+			if (baseDuration < shortThreshold) effectiveDriftAmount *= .1;
+			else if (baseDuration < longThreshold) {
+				const scaleFactor = .1 + .9 * (baseDuration - shortThreshold) / 7168;
+				effectiveDriftAmount *= scaleFactor;
+			}
+		}
+		const maxDriftSamples = effectiveDriftAmount * baseDuration;
+		return Math.floor(randomFactor * maxDriftSamples);
+	}
+	/**
+	* Analyze loop amplitude and calculate makeup gain for short loops
+	* @param {number} loopStart - Loop start position in samples
+	* @param {number} loopEnd - Loop end position in samples
+	* @returns {number} - Makeup gain multiplier (1.0 = no change)
+	*/
+	#analyzeLoopAmplitude(loopStart, loopEnd) {
+		if (!this.enableAmplitudeCompensation || !this.buffer || !this.buffer[0]) return 1;
+		if (loopEnd - loopStart >= this.AMPLITUDE_COMPENSATION_THRESHOLD) return 1;
+		if (loopStart === this.lastAnalyzedLoopStart && loopEnd === this.lastAnalyzedLoopEnd) return this.loopAmplitudeGain;
+		let sumSquares = 0;
+		let sampleCount = 0;
+		const channel = this.buffer[0];
+		const startIndex = Math.floor(loopStart);
+		const endIndex = Math.floor(loopEnd);
+		for (let i = startIndex; i < endIndex && i < channel.length; i++) {
+			const sample = channel[i];
+			sumSquares += sample * sample;
+			sampleCount++;
+		}
+		if (sampleCount === 0) return 1;
+		const rmsAmplitude = Math.sqrt(sumSquares / sampleCount);
+		const targetAmplitude = .3;
+		let makeupGain = 1;
+		if (rmsAmplitude < targetAmplitude) {
+			makeupGain = targetAmplitude / Math.max(rmsAmplitude, .001);
+			makeupGain = Math.min(2, makeupGain);
+		}
+		this.lastAnalyzedLoopStart = loopStart;
+		this.lastAnalyzedLoopEnd = loopEnd;
+		this.loopAmplitudeGain = makeupGain;
+		return makeupGain;
+	}
+	process(inputs, outputs, parameters) {
+		const output = outputs[0];
+		this.debugCounter++;
+		if (!output || !this.isPlaying || !this.buffer?.[0]?.length) return true;
+		const masterGain = parameters.masterGain[0];
+		const positionParams = this.#extractPositionParams(parameters);
+		const playbackRange = this.#calculatePlaybackRange(positionParams);
+		const effectivePlaybackRate = parameters.playbackRate[0];
+		const tempo = parameters.tempo[0];
+		const loopRange = this.#calculateLoopRange(positionParams, playbackRange, parameters.loopDurationDriftAmount[0], tempo, effectivePlaybackRate);
+		const amplitudeGain = this.#analyzeLoopAmplitude(loopRange.loopStartSamples, loopRange.loopEndSamples);
+		const velocityGain = this.#midiVelocityToGain(parameters.velocity[0]) * this.velocitySensitivity;
+		const basePan = parameters.pan[0];
+		const effectivePan = this.panDriftEnabled ? Math.max(-1, Math.min(1, basePan + this.currentPanDrift)) : basePan;
+		let outputChannels;
+		if (output instanceof Float32Array) outputChannels = [output];
+		else if (Array.isArray(output) && output.every((ch) => ch instanceof Float32Array)) outputChannels = output;
+		else {
+			console.error("Unexpected output structure:", {
+				outputType: typeof output,
+				isArray: Array.isArray(output),
+				constructor: output?.constructor?.name,
+				length: output?.length
+			});
+			return true;
+		}
+		const numChannels = outputChannels.length;
+		const isConstant = this.#getConstantFlags(parameters);
+		const silencePadTail = loopRange.loopEndSamples > playbackRange.endSamples;
+		const TAIL_FADE_SAMPLES = 64;
+		if (this.playbackPosition === 0) {
+			this.playbackPosition = this.reversePlayback ? playbackRange.endSamples - 1 : playbackRange.startSamples;
+			this.#resetDurationPreservation(this.playbackPosition);
+		}
+		for (let sample = 0; sample < outputChannels[0].length; sample++) {
+			const envelopeGain = this.#getSafeParam(parameters.envGain, sample, isConstant.envGain);
+			const baseRate = this.#getSafeParam(parameters.playbackRate, sample, isConstant.playbackRate);
+			const playbackStep = this.reversePlayback ? -Math.abs(baseRate) : Math.abs(baseRate);
+			const canWrapLoop = this.loopEnabled && this.loopCount < parameters.maxLoopCount[0];
+			if (canWrapLoop) {
+				if (!this.reversePlayback && this.playbackPosition >= loopRange.loopEndSamples) {
+					this.#smoothLoopWrap(silencePadTail ? 0 : this.buffer[0][Math.floor(this.playbackPosition - 1)] || 0, this.buffer[0][Math.floor(loopRange.loopStartSamples)] || 0);
+					this.playbackPosition = loopRange.loopStartSamples;
+					this.loopCount++;
+					this.nextDriftGenerated = false;
+				} else if (this.reversePlayback && this.playbackPosition <= loopRange.loopStartSamples) {
+					this.#smoothLoopWrap(this.buffer[0][Math.floor(loopRange.loopStartSamples)] || 0, silencePadTail ? 0 : this.buffer[0][Math.floor(loopRange.loopEndSamples) - 1] || 0);
+					this.playbackPosition = loopRange.loopEndSamples;
+					this.loopCount++;
+					this.nextDriftGenerated = false;
+				}
+			}
+			const durationResetTarget = this.#prepareDurationPreservingSample(playbackStep, loopRange);
+			const shouldStopForward = !this.reversePlayback && (this.#isDurationPreservationActive(loopRange) ? this.durationPreservation.timelinePosition : this.playbackPosition) >= playbackRange.endSamples;
+			const shouldStopReverse = this.reversePlayback && (this.#isDurationPreservationActive(loopRange) ? this.durationPreservation.timelinePosition : this.playbackPosition) <= playbackRange.startSamples;
+			const isWithinLoop = this.loopEnabled && this.playbackPosition >= loopRange.loopStartSamples && this.playbackPosition <= loopRange.loopEndSamples;
+			if ((shouldStopForward || shouldStopReverse) && !(this.loopEnabled && isWithinLoop)) {
+				this.#stop();
+				return true;
+			}
+			let tailGain = 1;
+			if (silencePadTail) {
+				const distToEnd = playbackRange.endSamples - this.playbackPosition;
+				if (distToEnd < TAIL_FADE_SAMPLES) tailGain = Math.max(0, distToEnd / TAIL_FADE_SAMPLES);
+			}
+			const currentPosition = Math.floor(this.playbackPosition);
+			const positionOffset = this.playbackPosition - currentPosition;
+			let nextPosition, interpWeight;
+			if (this.reversePlayback) {
+				nextPosition = Math.max(currentPosition - 1, playbackRange.startSamples);
+				interpWeight = 1 - positionOffset;
+			} else {
+				nextPosition = Math.min(currentPosition + 1, playbackRange.endSamples - 1);
+				interpWeight = positionOffset;
+			}
+			for (let channel = 0; channel < numChannels; channel++) {
+				if (!outputChannels[channel]) {
+					console.warn(`Output channel ${channel} does not exist. Available channels:`, outputChannels.length);
+					continue;
+				}
+				let interpolatedSample = 0;
+				for (let l = 0; l < this.layers.length; l++) {
+					const layer = this.layers[l];
+					const layerChannel = layer[Math.min(channel, layer.length - 1)];
+					const currentSample = layerChannel[currentPosition] || 0;
+					const nextSample = layerChannel[nextPosition] || 0;
+					interpolatedSample += (currentSample + interpWeight * (nextSample - currentSample)) * this.layerGain;
+				}
+				if (this.applyClickCompensation) {
+					interpolatedSample += this.loopClickCompensation;
+					if (this.compensationDecay) {
+						this.loopClickCompensation *= this.compensationDecay;
+						if (Math.abs(this.loopClickCompensation) < .001) this.applyClickCompensation = false;
+					} else this.applyClickCompensation = false;
+				}
+				const finalSample = interpolatedSample * velocityGain * envelopeGain * masterGain * amplitudeGain * tailGain;
+				let panAdjustedSample = finalSample;
+				if (outputChannels.length === 2) {
+					if (channel === 0) panAdjustedSample = finalSample * (1 - Math.max(0, effectivePan));
+					else if (channel === 1) panAdjustedSample = finalSample * (1 - Math.max(0, -effectivePan));
+				}
+				outputChannels[channel][sample] = Math.max(-1, Math.min(1, isFinite(panAdjustedSample) ? panAdjustedSample : 0));
+			}
+			this.#advanceDurationPreservingPlayback(playbackStep, durationResetTarget, loopRange, canWrapLoop);
+		}
+		if (this.usePlaybackPosition) {
+			const normalizedPosition = this.#samplesToNormalized(this.playbackPosition);
+			this.port.postMessage({
+				type: "voice:position",
+				position: normalizedPosition
+			});
+		}
+		return true;
+	}
 };
-/**
- * Extract and convert all position parameters from seconds to samples
- * @param {Object} parameters - AudioWorkletProcessor parameters
- * @returns {Object} - Converted parameters in samples
- */
-extractPositionParams_fn = function(parameters) {
-  const samples = {
-    startPointSamples: Math.floor(parameters.startPoint[0] * sampleRate),
-    endPointSamples: Math.floor(parameters.endPoint[0] * sampleRate),
-    loopStartSamples: Math.floor(parameters.loopStart[0] * sampleRate),
-    loopEndSamples: Math.floor(parameters.loopEnd[0] * sampleRate)
-  };
-  return samples;
-};
-/**
- * Calculate effective playback range in samples
- * @param {Object} params - Position parameters from #extractPositionParams
- * @returns {Object} - Effective start and end positions
- */
-calculatePlaybackRange_fn = function(params) {
-  var _a, _b;
-  const bufferLength = ((_b = (_a = this.buffer) == null ? void 0 : _a[0]) == null ? void 0 : _b.length) || 0;
-  const start = Math.max(0, params.startPointSamples);
-  const end = params.endPointSamples > start ? Math.min(bufferLength, params.endPointSamples) : bufferLength;
-  const snappedStart = __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, start, "right");
-  const snappedEnd = __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, end, "left");
-  return {
-    startSamples: snappedStart,
-    endSamples: snappedEnd,
-    durationSamples: snappedEnd - snappedStart
-  };
-};
-/**
- * Calculate effective loop range in samples with optional drift
- * @param {Object} params - Position parameters from #extractPositionParams
- * @param {Object} playbackRange - Range from #calculatePlaybackRange
- * @param {number} driftAmount - Loop duration drift amount (0-1)
- * @param {number} tempo - Current tempo in BPM
- * @param {number} playbackRate - Current playback rate
- * @returns {Object} - Effective loop start and end positions with drift applied
- */
-calculateLoopRange_fn = function(params, playbackRange, driftAmount = 0, tempo = 120, playbackRate = 1) {
-  const lpStart = params.loopStartSamples;
-  const lpEnd = params.loopEndSamples;
-  let calcLoopStart = lpStart < lpEnd && lpStart >= 0 ? lpStart : playbackRange.startSamples;
-  let calcLoopEnd = lpEnd > lpStart && lpEnd <= playbackRange.endSamples ? lpEnd : playbackRange.endSamples;
-  let baseDuration = calcLoopEnd - calcLoopStart;
-  if (this.syncLoopToTempo) {
-    const quantizedDuration = __privateMethod(this, _SamplePlayerProcessor_instances, quantizeLoopDuration_fn).call(this, baseDuration, tempo, playbackRate);
-    calcLoopEnd = calcLoopStart + quantizedDuration;
-    calcLoopEnd = Math.min(calcLoopEnd, playbackRange.endSamples);
-  }
-  if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD && this.keytrackLoopAmount > 0 && !this.syncLoopToTempo) {
-    const scale = 1 + this.keytrackLoopAmount * (Math.abs(playbackRate) - 1);
-    baseDuration = Math.max(1, Math.floor(baseDuration * scale));
-    calcLoopEnd = calcLoopStart + baseDuration;
-  }
-  baseDuration = calcLoopEnd - calcLoopStart;
-  if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD) {
-    calcLoopStart = __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, calcLoopStart, "right");
-  }
-  if (driftAmount > 0 && this.loopEnabled) {
-    if (!this.nextDriftGenerated || this.loopCount === 0) {
-      const updateInterval = baseDuration <= this.PITCH_PRESERVATION_THRESHOLD ? Math.max(
-        1,
-        Math.floor(this.PITCH_PRESERVATION_THRESHOLD / baseDuration)
-      ) : 1;
-      const shouldUpdateDrift = this.driftUpdateCounter % updateInterval === 0;
-      if (shouldUpdateDrift) {
-        this.currentLoopDrift = __privateMethod(this, _SamplePlayerProcessor_instances, generateLoopDrift_fn).call(this, driftAmount, baseDuration);
-        if (this.panDriftEnabled && driftAmount > 0 && this.loopCount > 0) {
-          const panDriftAmountScalar = 1e-4;
-          this.currentPanDrift = this.currentLoopDrift * panDriftAmountScalar;
-        } else {
-          this.currentPanDrift = 0;
-        }
-      }
-      this.driftUpdateCounter++;
-      this.nextDriftGenerated = true;
-    }
-    const driftedLoopEnd = calcLoopEnd + this.currentLoopDrift;
-    const minLoopDuration = Math.max(1, Math.floor(baseDuration * 0.1));
-    const maxLoopEnd = Math.max(playbackRange.endSamples, calcLoopEnd);
-    calcLoopEnd = Math.max(
-      calcLoopStart + minLoopDuration,
-      Math.min(maxLoopEnd, driftedLoopEnd)
-    );
-  } else {
-    this.currentPanDrift = 0;
-  }
-  if (baseDuration > this.PITCH_PRESERVATION_THRESHOLD && calcLoopEnd <= playbackRange.endSamples) {
-    calcLoopEnd = Math.max(
-      calcLoopStart + 1,
-      __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, calcLoopEnd, "left")
-    );
-  }
-  const loopDuration = calcLoopEnd - calcLoopStart;
-  return {
-    loopStartSamples: calcLoopStart,
-    loopEndSamples: calcLoopEnd,
-    loopDurationSamples: loopDuration
-  };
-};
-getSafeParam_fn = function(paramArray, index, isConstant) {
-  return isConstant ? paramArray[0] : paramArray[Math.min(index, paramArray.length - 1)];
-};
-getConstantFlags_fn = function(parameters) {
-  this.constantFlags ?? (this.constantFlags = {
-    envGain: true,
-    playbackRate: true
-  });
-  this.constantFlags.envGain = parameters.envGain.length === 1;
-  this.constantFlags.playbackRate = parameters.playbackRate.length === 1;
-  return this.constantFlags;
-};
-// ===== DURATION PRESERVATION =====
-resetDurationPreservation_fn = function(position = 0) {
-  this.durationPreservation.timelinePosition = position;
-  this.durationPreservation.resetPending = false;
-};
-isDurationPreservationActive_fn = function(loopRange) {
-  var _a;
-  return this.durationPreservation.enabled && Boolean((_a = this.zeroCrossings) == null ? void 0 : _a.length) && (!this.loopEnabled || loopRange.loopDurationSamples > this.PITCH_PRESERVATION_THRESHOLD);
-};
-prepareDurationPreservingSample_fn = function(playbackRate, loopRange) {
-  const state = this.durationPreservation;
-  if (!__privateMethod(this, _SamplePlayerProcessor_instances, isDurationPreservationActive_fn).call(this, loopRange)) return null;
-  if (Math.abs(this.playbackPosition - state.timelinePosition) > state.maxDriftSamples) {
-    state.resetPending = true;
-  }
-  if (!state.resetPending) return null;
-  const direction = playbackRate < 0 ? "left" : "right";
-  const outgoingZero = __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, this.playbackPosition, direction);
-  if (Math.abs(outgoingZero - this.playbackPosition) > Math.abs(playbackRate)) {
-    return null;
-  }
-  this.playbackPosition = outgoingZero;
-  state.resetPending = false;
-  return __privateMethod(this, _SamplePlayerProcessor_instances, findNearestZeroCrossing_fn).call(this, state.timelinePosition, "any", state.maxDriftSamples);
+registerProcessor("sample-player-processor", SamplePlayerProcessor);
+//#endregion
+//#region src/worklets/processors/noise/random-noise-processor.js
+var RandomNoiseProcessor = class extends AudioWorkletProcessor {
+	constructor() {
+		super();
+		this.previousNoise = 0;
+		this.previousFiltered = 0;
+		this.hpfHz = 150;
+		this.alpha = this.hpfHz / (this.hpfHz + sampleRate / (2 * Math.PI));
+		this.port.onmessage = (event) => {
+			if (event.data.type === "setHpfHz") {
+				this.hpfHz = event.data.value;
+				this.alpha = this.calculateAlpha(this.hpfHz);
+			}
+		};
+		this.port.postMessage({ type: "initialized" });
+	}
+	calculateAlpha(frequency) {
+		return frequency / (frequency + sampleRate / (2 * Math.PI));
+	}
+	process(inputs, outputs, parameters) {
+		outputs[0].forEach((channel) => {
+			for (let i = 0; i < channel.length; i++) {
+				const noise = Math.random() * 2 - 1;
+				const filtered = this.alpha * (noise - this.previousNoise) + this.previousFiltered;
+				this.previousNoise = noise;
+				this.previousFiltered = filtered;
+				channel[i] = filtered;
+			}
+		});
+		return true;
+	}
 };
-advanceDurationPreservingPlayback_fn = function(playbackRate, resetTarget, loopRange, canWrapLoop) {
-  const state = this.durationPreservation;
-  this.playbackPosition = resetTarget === null ? this.playbackPosition + playbackRate : resetTarget;
-  if (__privateMethod(this, _SamplePlayerProcessor_instances, isDurationPreservationActive_fn).call(this, loopRange)) {
-    state.timelinePosition += playbackRate < 0 ? -1 : 1;
-    if (canWrapLoop && playbackRate >= 0 && state.timelinePosition >= loopRange.loopEndSamples) {
-      state.timelinePosition = loopRange.loopStartSamples;
-    } else if (canWrapLoop && playbackRate < 0 && state.timelinePosition <= loopRange.loopStartSamples) {
-      state.timelinePosition = loopRange.loopEndSamples - 1;
-    }
-  } else {
-    __privateMethod(this, _SamplePlayerProcessor_instances, resetDurationPreservation_fn).call(this, this.playbackPosition);
-  }
+registerProcessor("random-noise-processor", RandomNoiseProcessor);
+//#endregion
+//#region src/worklets/shared/utils/compress-utils.ts
+var cheapSoftClipSingleSample = (sample, max = .9) => {
+	const a = Math.abs(sample);
+	if (a <= max) return sample;
+	const x = a / max;
+	const compressed = x / (1 + x);
+	return Math.sign(sample) * max * compressed;
 };
 /**
- * Generate a new drift amount for the current loop iteration
- * @param {number} driftAmount - Maximum drift amount (0-1)
- * @param {number} baseDuration - Base loop duration in samples
- * @returns {number} - Drift amount in samples
- */
-generateLoopDrift_fn = function(driftAmount, baseDuration) {
-  if (driftAmount <= 0) return 0;
-  const randomFactor = (Math.random() - 0.5) * 2;
-  let effectiveDriftAmount = driftAmount;
-  if (this.enableAdaptiveDrift) {
-    const shortThreshold = 1024;
-    const longThreshold = 8192;
-    if (baseDuration < shortThreshold) {
-      effectiveDriftAmount *= 0.1;
-    } else if (baseDuration < longThreshold) {
-      const scaleFactor = 0.1 + 0.9 * (baseDuration - shortThreshold) / (longThreshold - shortThreshold);
-      effectiveDriftAmount *= scaleFactor;
-    }
-  }
-  const maxDriftSamples = effectiveDriftAmount * baseDuration;
-  return Math.floor(randomFactor * maxDriftSamples);
+*  Basic attenuation compressor for single sample
+*  Note: No validation since optimized for real time use
+*/
+var compressSingleSample = (input, threshold = .75, ratio = 4, limiter = {
+	enabled: true,
+	type: "soft",
+	outputRange: {
+		min: -1,
+		max: 1
+	}
+}) => {
+	const { min, max } = limiter.outputRange;
+	let x = input;
+	if (Math.abs(x) > threshold) x = Math.sign(x) * (threshold + (Math.abs(x) - threshold) / ratio);
+	if (limiter.enabled) {
+		if (limiter.type === "soft") x = cheapSoftClipSingleSample(x, Math.abs(max));
+		else if (limiter.type === "hard") x = Math.max(min, Math.min(max, x));
+	}
+	return x;
 };
-/**
- * Analyze loop amplitude and calculate makeup gain for short loops
- * @param {number} loopStart - Loop start position in samples
- * @param {number} loopEnd - Loop end position in samples
- * @returns {number} - Makeup gain multiplier (1.0 = no change)
- */
-analyzeLoopAmplitude_fn = function(loopStart, loopEnd) {
-  if (!this.enableAmplitudeCompensation || !this.buffer || !this.buffer[0]) {
-    return 1;
-  }
-  const loopDuration = loopEnd - loopStart;
-  if (loopDuration >= this.AMPLITUDE_COMPENSATION_THRESHOLD) {
-    return 1;
-  }
-  if (loopStart === this.lastAnalyzedLoopStart && loopEnd === this.lastAnalyzedLoopEnd) {
-    return this.loopAmplitudeGain;
-  }
-  let sumSquares = 0;
-  let sampleCount = 0;
-  const channel = this.buffer[0];
-  const startIndex = Math.floor(loopStart);
-  const endIndex = Math.floor(loopEnd);
-  for (let i = startIndex; i < endIndex && i < channel.length; i++) {
-    const sample = channel[i];
-    sumSquares += sample * sample;
-    sampleCount++;
-  }
-  if (sampleCount === 0) return 1;
-  const rmsAmplitude = Math.sqrt(sumSquares / sampleCount);
-  const targetAmplitude = 0.3;
-  let makeupGain = 1;
-  if (rmsAmplitude < targetAmplitude) {
-    const safeRms = Math.max(rmsAmplitude, 1e-3);
-    makeupGain = targetAmplitude / safeRms;
-    makeupGain = Math.min(2, makeupGain);
-  }
-  this.lastAnalyzedLoopStart = loopStart;
-  this.lastAnalyzedLoopEnd = loopEnd;
-  this.loopAmplitudeGain = makeupGain;
-  return makeupGain;
+//#endregion
+//#region src/worklets/processors/delay/DelayBuffer.js
+var DelayBuffer = class {
+	constructor(maxDelaySamples) {
+		this.buffer = new Float32Array(maxDelaySamples);
+		this.writePtr = 0;
+		this.readPtr = 0;
+	}
+	write(sample) {
+		this.buffer[this.writePtr] = sample;
+	}
+	read() {
+		return this.buffer[this.readPtr];
+	}
+	updatePointers(delaySamples) {
+		this.writePtr = (this.writePtr + 1) % this.buffer.length;
+		this.readPtr = (this.writePtr - delaySamples + this.buffer.length) % this.buffer.length;
+	}
 };
-registerProcessor("sample-player-processor", SamplePlayerProcessor);
-class RandomNoiseProcessor extends AudioWorkletProcessor {
-  constructor() {
-    super();
-    this.previousNoise = 0;
-    this.previousFiltered = 0;
-    this.hpfHz = 150;
-    this.alpha = this.hpfHz / (this.hpfHz + sampleRate / (2 * Math.PI));
-    this.port.onmessage = (event) => {
-      if (event.data.type === "setHpfHz") {
-        this.hpfHz = event.data.value;
-        this.alpha = this.calculateAlpha(this.hpfHz);
-      }
-    };
-    this.port.postMessage({ type: "initialized" });
-  }
-  calculateAlpha(frequency) {
-    return frequency / (frequency + sampleRate / (2 * Math.PI));
-  }
-  process(inputs, outputs, parameters) {
-    const output = outputs[0];
-    output.forEach((channel) => {
-      for (let i = 0; i < channel.length; i++) {
-        const noise = Math.random() * 2 - 1;
-        const filtered = this.alpha * (noise - this.previousNoise) + this.previousFiltered;
-        this.previousNoise = noise;
-        this.previousFiltered = filtered;
-        channel[i] = filtered;
-      }
-    });
-    return true;
-  }
-}
-registerProcessor("random-noise-processor", RandomNoiseProcessor);
-const cheapSoftClipSingleSample = (sample, max = 0.9) => {
-  const a = Math.abs(sample);
-  if (a <= max) return sample;
-  const x = a / max;
-  const compressed = x / (1 + x);
-  return Math.sign(sample) * max * compressed;
+//#endregion
+//#region src/worklets/processors/delay/FeedbackDelay.js
+var AUTO_GAIN_THRESHOLD = .8;
+var SAFETY_GAIN_COMPENSATION = .2;
+var FeedbackDelay = class {
+	constructor(sampleRate) {
+		this.sampleRate = sampleRate;
+		this.buffers = [];
+		this.initialized = false;
+		this.autoGainEnabled = false;
+		this.gainCompensation = SAFETY_GAIN_COMPENSATION;
+		this.lowpassStates = [];
+		this.highpassStates = [];
+		this.highpassInputStates = [];
+	}
+	initializeBuffers(channelCount) {
+		this.buffers = [];
+		this.lowpassStates = [];
+		this.highpassStates = [];
+		this.highpassInputStates = [];
+		const maxSamples = Math.floor(this.sampleRate * 2);
+		for (let c = 0; c < channelCount; c++) {
+			this.buffers[c] = new DelayBuffer(maxSamples);
+			this.lowpassStates[c] = 0;
+			this.highpassStates[c] = 0;
+			this.highpassInputStates[c] = 0;
+		}
+		this.initialized = true;
+	}
+	/** Simple one-pole lowpass filter */
+	lowpass(input, cutoffFreq, channelIndex) {
+		if (cutoffFreq >= this.sampleRate * .4) return input;
+		const omega = 2 * Math.PI * cutoffFreq / this.sampleRate;
+		const alpha = Math.max(0, Math.min(.99, Math.sin(omega) / (Math.sin(omega) + Math.cos(omega))));
+		this.lowpassStates[channelIndex] = alpha * input + (1 - alpha) * this.lowpassStates[channelIndex];
+		return this.lowpassStates[channelIndex];
+	}
+	/** Simple one-pole highpass filter */
+	highpass(input, cutoffFreq, channelIndex) {
+		if (cutoffFreq < 5) return input;
+		const omega = 2 * Math.PI * cutoffFreq / this.sampleRate;
+		const alpha = Math.max(0, Math.min(.99, Math.sin(omega) / (Math.sin(omega) + Math.cos(omega))));
+		const lowpassOutput = alpha * input + (1 - alpha) * this.highpassStates[channelIndex];
+		const highpassOutput = input - lowpassOutput;
+		this.highpassStates[channelIndex] = lowpassOutput;
+		return highpassOutput;
+	}
+	process(inputSample, channelIndex, feedbackAmount, delayTime, lowpassFreq = 1e4, highpassFreq = 100) {
+		if (!this.initialized) return inputSample;
+		const buffer = this.buffers[channelIndex] || this.buffers[0];
+		const delaySamples = Math.floor(this.sampleRate * delayTime);
+		const delayedSample = buffer.read();
+		let filteredDelay = this.highpass(delayedSample, highpassFreq, channelIndex);
+		filteredDelay = this.lowpass(filteredDelay, lowpassFreq, channelIndex);
+		const feedbackSample = feedbackAmount * filteredDelay + inputSample;
+		let outputSample = feedbackSample;
+		const compressedFeedback = compressSingleSample(feedbackSample, .5, 4, {
+			enabled: true,
+			outputRange: {
+				min: -.99,
+				max: .99
+			},
+			type: "soft"
+		});
+		if (this.autoGainEnabled && feedbackAmount > AUTO_GAIN_THRESHOLD) outputSample = compressedFeedback * (1 - (feedbackAmount - AUTO_GAIN_THRESHOLD) * this.gainCompensation);
+		return {
+			outputSample,
+			feedbackSample: compressedFeedback,
+			delaySamples
+		};
+	}
+	updateBuffer(channelIndex, sample, delaySamples) {
+		const buffer = this.buffers[channelIndex] || this.buffers[0];
+		buffer.write(sample);
+		buffer.updatePointers(delaySamples);
+	}
+	setAutoGain(enabled, compensation = SAFETY_GAIN_COMPENSATION) {
+		this.autoGainEnabled = enabled;
+		this.gainCompensation = compensation;
+	}
 };
-const compressSingleSample = (input, threshold = 0.75, ratio = 4, limiter = { enabled: true, type: "soft", outputRange: { min: -1, max: 1 } }) => {
-  const { min, max } = limiter.outputRange;
-  let x = input;
-  if (Math.abs(x) > threshold) {
-    x = Math.sign(x) * (threshold + (Math.abs(x) - threshold) / ratio);
-  }
-  if (limiter.enabled) {
-    if (limiter.type === "soft") {
-      x = cheapSoftClipSingleSample(x, Math.abs(max));
-    } else if (limiter.type === "hard") {
-      x = Math.max(min, Math.min(max, x));
-    }
-  }
-  return x;
+//#endregion
+//#region src/worklets/processors/delay/feedback-delay-processor.js
+registerProcessor("feedback-delay-processor", class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return [
+			{
+				name: "feedbackAmount",
+				defaultValue: .5,
+				minValue: 0,
+				maxValue: 1,
+				automationRate: "k-rate"
+			},
+			{
+				name: "delayTime",
+				defaultValue: .5,
+				minValue: .00012656238799684143,
+				maxValue: 2,
+				automationRate: "k-rate"
+			},
+			{
+				name: "decay",
+				defaultValue: 1,
+				minValue: 0,
+				maxValue: 1,
+				automationRate: "k-rate"
+			},
+			{
+				name: "lowpass",
+				defaultValue: 1e4,
+				minValue: 100,
+				maxValue: 16e3,
+				automationRate: "k-rate"
+			}
+		];
+	}
+	constructor() {
+		super();
+		this.feedbackDelay = new FeedbackDelay(sampleRate);
+		this.decayStartTime = null;
+		this.decayActive = false;
+		this.baseFeedbackAmount = .5;
+		this.setupMessageHandling();
+		this.port.postMessage({ type: "initialized" });
+	}
+	setupMessageHandling() {
+		this.port.onmessage = (event) => {
+			switch (event.data.type) {
+				case "setAutoGain":
+					this.feedbackDelay.setAutoGain(event.data.enabled, event.data.amount);
+					break;
+				case "triggerDecay":
+					this.decayStartTime = currentTime;
+					this.decayActive = true;
+					this.baseFeedbackAmount = event.data.baseFeedbackAmount || .5;
+					break;
+				case "stopDecay":
+					this.decayActive = false;
+					this.decayStartTime = null;
+			}
+		};
+	}
+	process(inputs, outputs, parameters) {
+		const input = inputs[0];
+		const output = outputs[0];
+		if (!input || !output) return true;
+		if (!this.feedbackDelay.initialized || this.feedbackDelay.buffers.length !== input.length) this.feedbackDelay.initializeBuffers(input.length);
+		const baseFeedbackAmount = parameters.feedbackAmount[0];
+		const delayTime = parameters.delayTime[0];
+		const decay = parameters.decay[0];
+		const lowpassFreq = parameters.lowpass[0];
+		const channelCount = Math.min(input.length, output.length);
+		const frameCount = output[0].length;
+		for (let i = 0; i < frameCount; ++i) {
+			let effectiveFeedbackAmount = baseFeedbackAmount;
+			if (this.decayActive && this.decayStartTime !== null) {
+				const elapsedTime = currentTime - this.decayStartTime + i / sampleRate;
+				const delayCompensation = Math.min(100, .5 / delayTime);
+				const timeConstant = Math.pow(decay, 5) * 1e3 * delayCompensation + .5;
+				effectiveFeedbackAmount = baseFeedbackAmount * Math.exp(-elapsedTime / timeConstant);
+				if (effectiveFeedbackAmount < .01) {
+					this.decayActive = false;
+					effectiveFeedbackAmount = 0;
+				}
+			}
+			for (let c = 0; c < channelCount; c++) {
+				const processed = this.feedbackDelay.process(input[c][i], c, effectiveFeedbackAmount, delayTime, lowpassFreq);
+				output[c][i] = processed.outputSample;
+				this.feedbackDelay.updateBuffer(c, processed.feedbackSample, processed.delaySamples);
+			}
+		}
+		return true;
+	}
+});
+//#endregion
+//#region src/worklets/processors/delay/delay-processor.js
+var DEFAULT_DELAY_CONFIG = {
+	CHARACTER: ["filtered"],
+	SMOOTHING_FACTOR: {
+		slowest: 1e-4,
+		slow: 25e-5,
+		medium: 35e-5,
+		fast: 5e-4,
+		veryFast: .001,
+		superFast: .1,
+		none: 1
+	}
 };
-class DelayBuffer {
-  constructor(maxDelaySamples) {
-    this.buffer = new Float32Array(maxDelaySamples);
-    this.writePtr = 0;
-    this.readPtr = 0;
-  }
-  write(sample) {
-    this.buffer[this.writePtr] = sample;
-  }
-  read() {
-    return this.buffer[this.readPtr];
-  }
-  updatePointers(delaySamples) {
-    this.writePtr = (this.writePtr + 1) % this.buffer.length;
-    this.readPtr = (this.writePtr - delaySamples + this.buffer.length) % this.buffer.length;
-  }
-}
-const AUTO_GAIN_THRESHOLD = 0.8;
-const SAFETY_GAIN_COMPENSATION = 0.2;
-class FeedbackDelay {
-  constructor(sampleRate2) {
-    this.sampleRate = sampleRate2;
-    this.buffers = [];
-    this.initialized = false;
-    this.autoGainEnabled = false;
-    this.gainCompensation = SAFETY_GAIN_COMPENSATION;
-    this.lowpassStates = [];
-    this.highpassStates = [];
-    this.highpassInputStates = [];
-  }
-  initializeBuffers(channelCount) {
-    this.buffers = [];
-    this.lowpassStates = [];
-    this.highpassStates = [];
-    this.highpassInputStates = [];
-    const maxSamples = Math.floor(this.sampleRate * 2);
-    for (let c = 0; c < channelCount; c++) {
-      this.buffers[c] = new DelayBuffer(maxSamples);
-      this.lowpassStates[c] = 0;
-      this.highpassStates[c] = 0;
-      this.highpassInputStates[c] = 0;
-    }
-    this.initialized = true;
-  }
-  /** Simple one-pole lowpass filter */
-  lowpass(input, cutoffFreq, channelIndex) {
-    if (cutoffFreq >= this.sampleRate * 0.4) {
-      return input;
-    }
-    const omega = 2 * Math.PI * cutoffFreq / this.sampleRate;
-    const alpha = Math.max(
-      0,
-      Math.min(0.99, Math.sin(omega) / (Math.sin(omega) + Math.cos(omega)))
-    );
-    this.lowpassStates[channelIndex] = alpha * input + (1 - alpha) * this.lowpassStates[channelIndex];
-    return this.lowpassStates[channelIndex];
-  }
-  /** Simple one-pole highpass filter */
-  highpass(input, cutoffFreq, channelIndex) {
-    if (cutoffFreq < 5) return input;
-    const omega = 2 * Math.PI * cutoffFreq / this.sampleRate;
-    const alpha = Math.max(
-      0,
-      Math.min(0.99, Math.sin(omega) / (Math.sin(omega) + Math.cos(omega)))
-    );
-    const lowpassOutput = alpha * input + (1 - alpha) * this.highpassStates[channelIndex];
-    const highpassOutput = input - lowpassOutput;
-    this.highpassStates[channelIndex] = lowpassOutput;
-    return highpassOutput;
-  }
-  process(inputSample, channelIndex, feedbackAmount, delayTime, lowpassFreq = 1e4, highpassFreq = 100) {
-    if (!this.initialized) return inputSample;
-    const buffer = this.buffers[channelIndex] || this.buffers[0];
-    const delaySamples = Math.floor(this.sampleRate * delayTime);
-    const delayedSample = buffer.read();
-    let filteredDelay = this.highpass(
-      delayedSample,
-      highpassFreq,
-      channelIndex
-    );
-    filteredDelay = this.lowpass(filteredDelay, lowpassFreq, channelIndex);
-    const feedbackSample = feedbackAmount * filteredDelay + inputSample;
-    let outputSample = feedbackSample;
-    const compressedFeedback = compressSingleSample(feedbackSample, 0.5, 4, {
-      enabled: true,
-      // limiter enabled
-      outputRange: { min: -0.99, max: 0.99 },
-      type: "soft"
-      // soft clip
-    });
-    if (this.autoGainEnabled && feedbackAmount > AUTO_GAIN_THRESHOLD) {
-      const safetyReduction = 1 - (feedbackAmount - AUTO_GAIN_THRESHOLD) * this.gainCompensation;
-      outputSample = compressedFeedback * safetyReduction;
-    }
-    return { outputSample, feedbackSample: compressedFeedback, delaySamples };
-  }
-  updateBuffer(channelIndex, sample, delaySamples) {
-    const buffer = this.buffers[channelIndex] || this.buffers[0];
-    buffer.write(sample);
-    buffer.updatePointers(delaySamples);
-  }
-  setAutoGain(enabled, compensation = SAFETY_GAIN_COMPENSATION) {
-    this.autoGainEnabled = enabled;
-    this.gainCompensation = compensation;
-  }
-}
-registerProcessor(
-  "feedback-delay-processor",
-  class extends AudioWorkletProcessor {
-    static get parameterDescriptors() {
-      return [
-        {
-          name: "feedbackAmount",
-          defaultValue: 0.5,
-          minValue: 0,
-          maxValue: 1,
-          automationRate: "k-rate"
-        },
-        {
-          name: "delayTime",
-          defaultValue: 0.5,
-          minValue: 12656238799684143e-20,
-          // <- B8 natural in seconds (highest note period that works)
-          maxValue: 2,
-          automationRate: "k-rate"
-        },
-        {
-          name: "decay",
-          // feedback decay time factor
-          defaultValue: 1,
-          minValue: 0,
-          maxValue: 1,
-          automationRate: "k-rate"
-        },
-        {
-          name: "lowpass",
-          defaultValue: 1e4,
-          minValue: 100,
-          maxValue: 16e3,
-          automationRate: "k-rate"
-        }
-      ];
-    }
-    constructor() {
-      super();
-      this.feedbackDelay = new FeedbackDelay(sampleRate);
-      this.decayStartTime = null;
-      this.decayActive = false;
-      this.baseFeedbackAmount = 0.5;
-      this.setupMessageHandling();
-      this.port.postMessage({ type: "initialized" });
-    }
-    setupMessageHandling() {
-      this.port.onmessage = (event) => {
-        switch (event.data.type) {
-          case "setAutoGain":
-            this.feedbackDelay.setAutoGain(
-              event.data.enabled,
-              event.data.amount
-            );
-            break;
-          case "triggerDecay":
-            this.decayStartTime = currentTime;
-            this.decayActive = true;
-            this.baseFeedbackAmount = event.data.baseFeedbackAmount || 0.5;
-            break;
-          case "stopDecay":
-            this.decayActive = false;
-            this.decayStartTime = null;
-            break;
-        }
-      };
-    }
-    process(inputs, outputs, parameters) {
-      const input = inputs[0];
-      const output = outputs[0];
-      if (!input || !output) return true;
-      if (!this.feedbackDelay.initialized || this.feedbackDelay.buffers.length !== input.length) {
-        this.feedbackDelay.initializeBuffers(input.length);
-      }
-      const baseFeedbackAmount = parameters.feedbackAmount[0];
-      const delayTime = parameters.delayTime[0];
-      const decay = parameters.decay[0];
-      const lowpassFreq = parameters.lowpass[0];
-      const channelCount = Math.min(input.length, output.length);
-      const frameCount = output[0].length;
-      for (let i = 0; i < frameCount; ++i) {
-        let effectiveFeedbackAmount = baseFeedbackAmount;
-        if (this.decayActive && this.decayStartTime !== null) {
-          const elapsedTime = currentTime - this.decayStartTime + i / sampleRate;
-          const delayCompensation = Math.min(100, 0.5 / delayTime);
-          const timeConstant = Math.pow(decay, 5) * 1e3 * delayCompensation + 0.5;
-          const decayFactor = Math.exp(-elapsedTime / timeConstant);
-          effectiveFeedbackAmount = baseFeedbackAmount * decayFactor;
-          if (effectiveFeedbackAmount < 0.01) {
-            this.decayActive = false;
-            effectiveFeedbackAmount = 0;
-          }
-        }
-        for (let c = 0; c < channelCount; c++) {
-          const processed = this.feedbackDelay.process(
-            input[c][i],
-            c,
-            effectiveFeedbackAmount,
-            delayTime,
-            lowpassFreq
-          );
-          output[c][i] = processed.outputSample;
-          this.feedbackDelay.updateBuffer(
-            c,
-            processed.feedbackSample,
-            processed.delaySamples
-          );
-        }
-      }
-      return true;
-    }
-  }
-);
-const DEFAULT_DELAY_CONFIG = {
-  CHARACTER: ["filtered"],
-  // 'clean' | 'bitCrushed' | 'filtered' or combo
-  // Smoothing factor for delay time interpolation
-  SMOOTHING_FACTOR: {
-    slowest: 1e-4
-  }
+var DEFAULT_CHARACTER_CONFIG = {
+	bitCrushed: {
+		bits: 11,
+		downsample: 3
+	},
+	filtered: {
+		freq: 900,
+		Q: .15
+	}
 };
-const DEFAULT_CHARACTER_CONFIG = {
-  bitCrushed: {
-    bits: 11,
-    // bits for bit reduction (e.g. 4 = 16 levels)
-    downsample: 3
-    // downsample factor (1 = no downsampling, 4 = 1/4 samplerate)
-  },
-  filtered: {
-    freq: 900,
-    // Hz
-    Q: 0.15
-    // very subtle / broad
-  }
+registerProcessor("delay-processor", class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return [{
+			name: "delayTime",
+			defaultValue: .5,
+			minValue: .001,
+			maxValue: 2,
+			automationRate: "k-rate"
+		}, {
+			name: "feedbackAmount",
+			defaultValue: 0,
+			minValue: 0,
+			maxValue: .99,
+			automationRate: "k-rate"
+		}];
+	}
+	constructor() {
+		super();
+		this.buffers = [];
+		this.smoothedDelaySamples = [];
+		this.smoothingFactor = DEFAULT_DELAY_CONFIG.SMOOTHING_FACTOR.slowest;
+		this.characterModes = [...DEFAULT_DELAY_CONFIG.CHARACTER];
+		this._bpState = [];
+		this._bpFreq = DEFAULT_CHARACTER_CONFIG.filtered.freq;
+		this._bpQ = DEFAULT_CHARACTER_CONFIG.filtered.Q;
+		this._bpCoeffs = null;
+		this._lastBpFreq = -1;
+		this._lastBpQ = -1;
+		this.lofiBits = DEFAULT_CHARACTER_CONFIG["bitCrushed"].bits;
+		this.lofiDownsample = DEFAULT_CHARACTER_CONFIG["bitCrushed"].downsample;
+		this._lofiSampleHold = [];
+		this._lofiSampleCount = [];
+		this.initialized = false;
+		this.port.onmessage = (event) => {
+			if (event.data && event.data.type === "setCharacter" && Array.isArray(event.data.modes)) this.characterModes = [...event.data.modes];
+			if (event.data && event.data.type === "setBandpassFreq" && typeof event.data.hz === "number") this.setBandpassFreq(event.data.hz);
+			if (event.data && event.data.type === "trigger") {}
+		};
+		this.port.postMessage({ type: "initialized" });
+	}
+	setBandpassFreq(hz) {
+		this._bpFreq = hz;
+		this._lastBpFreq = -1;
+	}
+	_updateBandpassCoeffs() {
+		if (this._lastBpFreq === this._bpFreq && this._lastBpQ === this._bpQ) return;
+		const bpFreq = this._bpFreq;
+		const bpQ = this._bpQ;
+		const omega = 2 * Math.PI * bpFreq / sampleRate;
+		const alpha = Math.sin(omega) / (2 * bpQ);
+		const cosw = Math.cos(omega);
+		const b0 = alpha;
+		const b1 = 0;
+		const b2 = -alpha;
+		const a0 = 1 + alpha;
+		const a1 = -2 * cosw;
+		const a2 = 1 - alpha;
+		this._bpCoeffs = {
+			b0: b0 / a0,
+			b1: b1 / a0,
+			b2: b2 / a0,
+			a1: a1 / a0,
+			a2: a2 / a0
+		};
+		this._lastBpFreq = bpFreq;
+		this._lastBpQ = bpQ;
+	}
+	initializeBuffers(channelCount) {
+		const maxSamples = Math.floor(sampleRate * 2);
+		this.buffers = [];
+		this.smoothedDelaySamples = [];
+		this._lofiSampleHold = [];
+		this._lofiSampleCount = [];
+		for (let c = 0; c < channelCount; c++) {
+			this.buffers[c] = new DelayBuffer(maxSamples);
+			this.smoothedDelaySamples[c] = Math.floor(sampleRate * .5);
+			this._lofiSampleHold[c] = 0;
+			this._lofiSampleCount[c] = 0;
+		}
+		this.initialized = true;
+	}
+	_processLoFi(delayed, c) {
+		if (this._lofiSampleCount[c] % this.lofiDownsample === 0) {
+			const levels = Math.pow(2, this.lofiBits);
+			delayed = Math.round(delayed * levels) / levels;
+			this._lofiSampleHold[c] = delayed;
+		} else delayed = this._lofiSampleHold[c];
+		this._lofiSampleCount[c]++;
+		return delayed;
+	}
+	_processBandpass(delayed, c) {
+		if (!this._bpState) this._bpState = [];
+		if (!this._bpState[c]) this._bpState[c] = {
+			x1: 0,
+			x2: 0,
+			y1: 0,
+			y2: 0
+		};
+		this._updateBandpassCoeffs();
+		if (!this._bpCoeffs) return delayed;
+		const { b0, b1, b2, a1, a2 } = this._bpCoeffs;
+		const s = this._bpState[c];
+		const y = b0 * delayed + b1 * s.x1 + b2 * s.x2 - a1 * s.y1 - a2 * s.y2;
+		s.x2 = s.x1;
+		s.x1 = delayed;
+		s.y2 = s.y1;
+		s.y1 = y;
+		return y;
+	}
+	process(inputs, outputs, parameters) {
+		const input = inputs[0];
+		const output = outputs[0];
+		if (!input || !output || input.length === 0 || output.length === 0) return true;
+		if (!input[0] || !output[0] || input[0].length === 0 || output[0].length === 0) return true;
+		if (!this.initialized || this.buffers.length !== input.length) this.initializeBuffers(input.length);
+		const delayTime = parameters.delayTime[0];
+		const feedbackAmount = parameters.feedbackAmount[0];
+		const targetDelaySamples = sampleRate * delayTime;
+		const channelCount = Math.min(input.length, output.length);
+		const frameCount = output[0].length;
+		const smoothing = this.smoothingFactor;
+		for (let i = 0; i < frameCount; ++i) for (let c = 0; c < channelCount; c++) {
+			const buf = this.buffers[c];
+			if (!buf) continue;
+			this.smoothedDelaySamples[c] += (targetDelaySamples - this.smoothedDelaySamples[c]) * smoothing;
+			const smoothedDelay = this.smoothedDelaySamples[c];
+			const intDelay = Math.floor(smoothedDelay);
+			const frac = smoothedDelay - intDelay;
+			const readPtrA = (buf.writePtr - intDelay + buf.buffer.length) % buf.buffer.length;
+			const readPtrB = (readPtrA - 1 + buf.buffer.length) % buf.buffer.length;
+			const sampleA = buf.buffer[readPtrA];
+			const sampleB = buf.buffer[readPtrB];
+			let delayed = sampleA * (1 - frac) + sampleB * frac;
+			for (const mode of this.characterModes) if (mode === "bitCrushed") delayed = this._processLoFi(delayed, c);
+			else if (mode === "filtered") delayed = this._processBandpass(delayed, c);
+			output[c][i] = compressSingleSample(delayed, .75, 4, {
+				enabled: true,
+				type: "soft",
+				outputRange: {
+					min: -.9,
+					max: .9
+				}
+			});
+			const inputSample = input[c] && input[c][i] !== void 0 ? input[c][i] : 0;
+			buf.write(inputSample + delayed * feedbackAmount);
+			buf.updatePointers(intDelay);
+		}
+		return true;
+	}
+});
+//#endregion
+//#region src/worklets/processors/reverb/dattorro-reverb-processor.js
+var DattorroReverb = class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return [
+			[
+				"preDelay",
+				0,
+				0,
+				sampleRate - 1,
+				"k-rate"
+			],
+			[
+				"bandwidth",
+				.9999,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"inputDiffusion1",
+				.75,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"inputDiffusion2",
+				.625,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"decay",
+				.5,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"decayDiffusion1",
+				.7,
+				0,
+				.999999,
+				"k-rate"
+			],
+			[
+				"decayDiffusion2",
+				.5,
+				0,
+				.999999,
+				"k-rate"
+			],
+			[
+				"damping",
+				.005,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"excursionRate",
+				.5,
+				0,
+				2,
+				"k-rate"
+			],
+			[
+				"excursionDepth",
+				.7,
+				0,
+				2,
+				"k-rate"
+			],
+			[
+				"wet",
+				.3,
+				0,
+				1,
+				"k-rate"
+			],
+			[
+				"dry",
+				.6,
+				0,
+				1,
+				"k-rate"
+			]
+		].map((x) => /* @__PURE__ */ new Object({
+			name: x[0],
+			defaultValue: x[1],
+			minValue: x[2],
+			maxValue: x[3],
+			automationRate: x[4]
+		}));
+	}
+	constructor(options) {
+		super(options);
+		this._Delays = [];
+		this._pDLength = sampleRate + (128 - sampleRate % 128);
+		this._preDelay = new Float32Array(this._pDLength);
+		this._pDWrite = 0;
+		this._lp1 = 0;
+		this._lp2 = 0;
+		this._lp3 = 0;
+		this._excPhase = 0;
+		const SHORT_DELAY_SCALE = .5;
+		[
+			.004771345,
+			.003595309,
+			.012734787,
+			.009307483,
+			.022579886,
+			.149625349,
+			.060481839,
+			.1249958,
+			.030509727,
+			.141695508,
+			.089244313,
+			.106280031
+		].map((x) => x * SHORT_DELAY_SCALE).forEach((x) => this.makeDelay(x));
+		this._taps = Int16Array.from([
+			.008937872,
+			.099929438,
+			.064278754,
+			.067067639,
+			.066866033,
+			.006283391,
+			.035818689,
+			.011861161,
+			.121870905,
+			.041262054,
+			.08981553,
+			.070931756,
+			.011256342,
+			.004065724
+		], (x) => Math.round(x * sampleRate));
+		this.port.postMessage({ type: "initialized" });
+	}
+	makeDelay(length) {
+		let len = Math.round(length * sampleRate);
+		let nextPow2 = 2 ** Math.ceil(Math.log2(len));
+		this._Delays.push([
+			new Float32Array(nextPow2),
+			len - 1,
+			0,
+			nextPow2 - 1
+		]);
+	}
+	writeDelay(index, data) {
+		return this._Delays[index][0][this._Delays[index][1]] = data;
+	}
+	readDelay(index) {
+		return this._Delays[index][0][this._Delays[index][2]];
+	}
+	readDelayAt(index, i) {
+		let d = this._Delays[index];
+		return d[0][d[2] + i & d[3]];
+	}
+	readDelayCAt(index, i) {
+		let d = this._Delays[index], frac = i - ~~i, int = ~~i + d[2] - 1, mask = d[3];
+		let x0 = d[0][int++ & mask], x1 = d[0][int++ & mask], x2 = d[0][int++ & mask], x3 = d[0][int & mask];
+		let a = (3 * (x1 - x2) - x0 + x3) / 2, b = 2 * x2 + x0 - (5 * x1 + x3) / 2, c = (x2 - x0) / 2;
+		return ((a * frac + b) * frac + c) * frac + x1;
+	}
+	process(inputs, outputs, parameters) {
+		const TWO_PI = 6.283185307179586;
+		const TWO_PI_DETUNE = 6.284702653297906;
+		const pd = ~~parameters.preDelay[0], bw = parameters.bandwidth[0], fi = parameters.inputDiffusion1[0], si = parameters.inputDiffusion2[0], dc = parameters.decay[0], ft = parameters.decayDiffusion1[0], st = parameters.decayDiffusion2[0], dp = 1 - parameters.damping[0], ex = parameters.excursionRate[0] / sampleRate, ed = parameters.excursionDepth[0] * sampleRate / 1e3, we = parameters.wet[0] * .6, dr = parameters.dry[0];
+		if (inputs[0].length == 2) for (let i = 127; i >= 0; i--) {
+			this._preDelay[this._pDWrite + i] = (inputs[0][0][i] + inputs[0][1][i]) * .5;
+			outputs[0][0][i] = inputs[0][0][i] * dr;
+			outputs[0][1][i] = inputs[0][1][i] * dr;
+		}
+		else if (inputs[0].length > 0) {
+			this._preDelay.set(inputs[0][0], this._pDWrite);
+			for (let i = 127; i >= 0; i--) outputs[0][0][i] = outputs[0][1][i] = inputs[0][0][i] * dr;
+		} else this._preDelay.set(/* @__PURE__ */ new Float32Array(128), this._pDWrite);
+		let i = 0;
+		while (i < 128) {
+			let lo = 0, ro = 0;
+			this._lp1 += bw * (this._preDelay[(this._pDLength + this._pDWrite - pd + i) % this._pDLength] - this._lp1);
+			let pre = this.writeDelay(0, this._lp1 - fi * this.readDelay(0));
+			pre = this.writeDelay(1, fi * (pre - this.readDelay(1)) + this.readDelay(0));
+			pre = this.writeDelay(2, fi * pre + this.readDelay(1) - si * this.readDelay(2));
+			pre = this.writeDelay(3, si * (pre - this.readDelay(3)) + this.readDelay(2));
+			let split = si * pre + this.readDelay(3);
+			let exc = ed * (1 + Math.cos(this._excPhase * TWO_PI));
+			let exc2 = ed * (1 + Math.sin(this._excPhase * TWO_PI_DETUNE));
+			let temp = this.writeDelay(4, split + dc * this.readDelay(11) + ft * this.readDelayCAt(4, exc));
+			this.writeDelay(5, this.readDelayCAt(4, exc) - ft * temp);
+			this._lp2 += dp * (this.readDelay(5) - this._lp2);
+			temp = this.writeDelay(6, dc * this._lp2 - st * this.readDelay(6));
+			this.writeDelay(7, this.readDelay(6) + st * temp);
+			temp = this.writeDelay(8, split + dc * this.readDelay(7) + ft * this.readDelayCAt(8, exc2));
+			this.writeDelay(9, this.readDelayCAt(8, exc2) - ft * temp);
+			this._lp3 += dp * (this.readDelay(9) - this._lp3);
+			temp = this.writeDelay(10, dc * this._lp3 - st * this.readDelay(10));
+			this.writeDelay(11, this.readDelay(10) + st * temp);
+			lo = this.readDelayAt(9, this._taps[0]) + this.readDelayAt(9, this._taps[1]) - this.readDelayAt(10, this._taps[2]) + this.readDelayAt(11, this._taps[3]) - this.readDelayAt(5, this._taps[4]) - this.readDelayAt(6, this._taps[5]) - this.readDelayAt(7, this._taps[6]);
+			ro = this.readDelayAt(5, this._taps[7]) + this.readDelayAt(5, this._taps[8]) - this.readDelayAt(6, this._taps[9]) + this.readDelayAt(7, this._taps[10]) - this.readDelayAt(9, this._taps[11]) - this.readDelayAt(10, this._taps[12]) - this.readDelayAt(11, this._taps[13]);
+			outputs[0][0][i] += lo * we;
+			outputs[0][1][i] += ro * we;
+			this._excPhase += ex;
+			if (this._excPhase >= 1) this._excPhase -= 1;
+			i++;
+			const delays = this._Delays;
+			for (let j = 0; j < delays.length; j++) {
+				const d = delays[j];
+				d[1] = d[1] + 1 & d[3];
+				d[2] = d[2] + 1 & d[3];
+			}
+		}
+		this._pDWrite = (this._pDWrite + 128) % this._pDLength;
+		return true;
+	}
 };
-registerProcessor(
-  "delay-processor",
-  class extends AudioWorkletProcessor {
-    static get parameterDescriptors() {
-      return [
-        {
-          name: "delayTime",
-          defaultValue: 0.5,
-          minValue: 1e-3,
-          maxValue: 2,
-          automationRate: "k-rate"
-        },
-        {
-          name: "feedbackAmount",
-          defaultValue: 0,
-          minValue: 0,
-          maxValue: 0.99,
-          automationRate: "k-rate"
-        }
-      ];
-    }
-    constructor() {
-      super();
-      this.buffers = [];
-      this.smoothedDelaySamples = [];
-      this.smoothingFactor = DEFAULT_DELAY_CONFIG.SMOOTHING_FACTOR.slowest;
-      this.characterModes = [...DEFAULT_DELAY_CONFIG.CHARACTER];
-      this._bpState = [];
-      this._bpFreq = DEFAULT_CHARACTER_CONFIG.filtered.freq;
-      this._bpQ = DEFAULT_CHARACTER_CONFIG.filtered.Q;
-      this._bpCoeffs = null;
-      this._lastBpFreq = -1;
-      this._lastBpQ = -1;
-      this.lofiBits = DEFAULT_CHARACTER_CONFIG["bitCrushed"].bits;
-      this.lofiDownsample = DEFAULT_CHARACTER_CONFIG["bitCrushed"].downsample;
-      this._lofiSampleHold = [];
-      this._lofiSampleCount = [];
-      this.initialized = false;
-      this.port.onmessage = (event) => {
-        if (event.data && event.data.type === "setCharacter" && Array.isArray(event.data.modes)) {
-          this.characterModes = [...event.data.modes];
-        }
-        if (event.data && event.data.type === "setBandpassFreq" && typeof event.data.hz === "number") {
-          this.setBandpassFreq(event.data.hz);
-        }
-        if (event.data && event.data.type === "trigger") ;
-      };
-      this.port.postMessage({ type: "initialized" });
-    }
-    setBandpassFreq(hz) {
-      this._bpFreq = hz;
-      this._lastBpFreq = -1;
-    }
-    _updateBandpassCoeffs() {
-      if (this._lastBpFreq === this._bpFreq && this._lastBpQ === this._bpQ) {
-        return;
-      }
-      const bpFreq = this._bpFreq;
-      const bpQ = this._bpQ;
-      const omega = 2 * Math.PI * bpFreq / sampleRate;
-      const alpha = Math.sin(omega) / (2 * bpQ);
-      const cosw = Math.cos(omega);
-      const b0 = alpha;
-      const b1 = 0;
-      const b2 = -alpha;
-      const a0 = 1 + alpha;
-      const a1 = -2 * cosw;
-      const a2 = 1 - alpha;
-      this._bpCoeffs = {
-        b0: b0 / a0,
-        b1: b1 / a0,
-        b2: b2 / a0,
-        a1: a1 / a0,
-        a2: a2 / a0
-      };
-      this._lastBpFreq = bpFreq;
-      this._lastBpQ = bpQ;
-    }
-    initializeBuffers(channelCount) {
-      const maxSamples = Math.floor(sampleRate * 2);
-      this.buffers = [];
-      this.smoothedDelaySamples = [];
-      this._lofiSampleHold = [];
-      this._lofiSampleCount = [];
-      for (let c = 0; c < channelCount; c++) {
-        this.buffers[c] = new DelayBuffer(maxSamples);
-        this.smoothedDelaySamples[c] = Math.floor(sampleRate * 0.5);
-        this._lofiSampleHold[c] = 0;
-        this._lofiSampleCount[c] = 0;
-      }
-      this.initialized = true;
-    }
-    _processLoFi(delayed, c) {
-      if (this._lofiSampleCount[c] % this.lofiDownsample === 0) {
-        const levels = Math.pow(2, this.lofiBits);
-        delayed = Math.round(delayed * levels) / levels;
-        this._lofiSampleHold[c] = delayed;
-      } else {
-        delayed = this._lofiSampleHold[c];
-      }
-      this._lofiSampleCount[c]++;
-      return delayed;
-    }
-    _processBandpass(delayed, c) {
-      if (!this._bpState) this._bpState = [];
-      if (!this._bpState[c]) {
-        this._bpState[c] = { x1: 0, x2: 0, y1: 0, y2: 0 };
-      }
-      this._updateBandpassCoeffs();
-      if (!this._bpCoeffs) {
-        return delayed;
-      }
-      const { b0, b1, b2, a1, a2 } = this._bpCoeffs;
-      const s = this._bpState[c];
-      const y = b0 * delayed + b1 * s.x1 + b2 * s.x2 - a1 * s.y1 - a2 * s.y2;
-      s.x2 = s.x1;
-      s.x1 = delayed;
-      s.y2 = s.y1;
-      s.y1 = y;
-      return y;
-    }
-    process(inputs, outputs, parameters) {
-      const input = inputs[0];
-      const output = outputs[0];
-      if (!input || !output || input.length === 0 || output.length === 0) {
-        return true;
-      }
-      if (!input[0] || !output[0] || input[0].length === 0 || output[0].length === 0) {
-        return true;
-      }
-      if (!this.initialized || this.buffers.length !== input.length) {
-        this.initializeBuffers(input.length);
-      }
-      const delayTime = parameters.delayTime[0];
-      const feedbackAmount = parameters.feedbackAmount[0];
-      const targetDelaySamples = sampleRate * delayTime;
-      const channelCount = Math.min(input.length, output.length);
-      const frameCount = output[0].length;
-      const smoothing = this.smoothingFactor;
-      for (let i = 0; i < frameCount; ++i) {
-        for (let c = 0; c < channelCount; c++) {
-          const buf = this.buffers[c];
-          if (!buf) {
-            continue;
-          }
-          this.smoothedDelaySamples[c] += (targetDelaySamples - this.smoothedDelaySamples[c]) * smoothing;
-          const smoothedDelay = this.smoothedDelaySamples[c];
-          const intDelay = Math.floor(smoothedDelay);
-          const frac = smoothedDelay - intDelay;
-          const readPtrA = (buf.writePtr - intDelay + buf.buffer.length) % buf.buffer.length;
-          const readPtrB = (readPtrA - 1 + buf.buffer.length) % buf.buffer.length;
-          const sampleA = buf.buffer[readPtrA];
-          const sampleB = buf.buffer[readPtrB];
-          let delayed = sampleA * (1 - frac) + sampleB * frac;
-          for (const mode of this.characterModes) {
-            if (mode === "bitCrushed") {
-              delayed = this._processLoFi(delayed, c);
-            } else if (mode === "filtered") {
-              delayed = this._processBandpass(delayed, c);
-            }
-          }
-          output[c][i] = compressSingleSample(delayed, 0.75, 4, {
-            enabled: true,
-            type: "soft",
-            outputRange: { min: -0.9, max: 0.9 }
-          });
-          const inputSample = input[c] && input[c][i] !== void 0 ? input[c][i] : 0;
-          buf.write(inputSample + delayed * feedbackAmount);
-          buf.updatePointers(intDelay);
-        }
-      }
-      return true;
-    }
-  }
-);
-class DattorroReverb extends AudioWorkletProcessor {
-  static get parameterDescriptors() {
-    return [
-      ["preDelay", 0, 0, sampleRate - 1, "k-rate"],
-      ["bandwidth", 0.9999, 0, 1, "k-rate"],
-      ["inputDiffusion1", 0.75, 0, 1, "k-rate"],
-      ["inputDiffusion2", 0.625, 0, 1, "k-rate"],
-      ["decay", 0.5, 0, 1, "k-rate"],
-      ["decayDiffusion1", 0.7, 0, 0.999999, "k-rate"],
-      ["decayDiffusion2", 0.5, 0, 0.999999, "k-rate"],
-      ["damping", 5e-3, 0, 1, "k-rate"],
-      ["excursionRate", 0.5, 0, 2, "k-rate"],
-      ["excursionDepth", 0.7, 0, 2, "k-rate"],
-      ["wet", 0.3, 0, 1, "k-rate"],
-      ["dry", 0.6, 0, 1, "k-rate"]
-    ].map(
-      (x) => new Object({
-        name: x[0],
-        defaultValue: x[1],
-        minValue: x[2],
-        maxValue: x[3],
-        automationRate: x[4]
-      })
-    );
-  }
-  constructor(options) {
-    super(options);
-    this._Delays = [];
-    this._pDLength = sampleRate + (128 - sampleRate % 128);
-    this._preDelay = new Float32Array(this._pDLength);
-    this._pDWrite = 0;
-    this._lp1 = 0;
-    this._lp2 = 0;
-    this._lp3 = 0;
-    this._excPhase = 0;
-    const SHORT_DELAY_SCALE = 0.5;
-    [
-      4771345e-9,
-      3595309e-9,
-      0.012734787,
-      9307483e-9,
-      0.022579886,
-      0.149625349,
-      0.060481839,
-      0.1249958,
-      0.030509727,
-      0.141695508,
-      0.089244313,
-      0.106280031
-    ].map((x) => x * SHORT_DELAY_SCALE).forEach((x) => this.makeDelay(x));
-    this._taps = Int16Array.from(
-      [
-        8937872e-9,
-        0.099929438,
-        0.064278754,
-        0.067067639,
-        0.066866033,
-        6283391e-9,
-        0.035818689,
-        0.011861161,
-        0.121870905,
-        0.041262054,
-        0.08981553,
-        0.070931756,
-        0.011256342,
-        4065724e-9
-      ],
-      (x) => Math.round(x * sampleRate)
-    );
-    this.port.postMessage({ type: "initialized" });
-  }
-  makeDelay(length) {
-    let len = Math.round(length * sampleRate);
-    let nextPow2 = 2 ** Math.ceil(Math.log2(len));
-    this._Delays.push([
-      new Float32Array(nextPow2),
-      len - 1,
-      // ? or should be 0 ?
-      0 | 0,
-      // ? or should be len - 1 ?
-      nextPow2 - 1
-    ]);
-  }
-  writeDelay(index, data) {
-    return this._Delays[index][0][this._Delays[index][1]] = data;
-  }
-  readDelay(index) {
-    return this._Delays[index][0][this._Delays[index][2]];
-  }
-  readDelayAt(index, i) {
-    let d = this._Delays[index];
-    return d[0][d[2] + i & d[3]];
-  }
-  // cubic interpolation
-  // O. Niemitalo: https://www.musicdsp.org/en/latest/Other/49-cubic-interpollation.html
-  readDelayCAt(index, i) {
-    let d = this._Delays[index], frac = i - ~~i, int = ~~i + d[2] - 1, mask = d[3];
-    let x0 = d[0][int++ & mask], x1 = d[0][int++ & mask], x2 = d[0][int++ & mask], x3 = d[0][int & mask];
-    let a = (3 * (x1 - x2) - x0 + x3) / 2, b = 2 * x2 + x0 - (5 * x1 + x3) / 2, c = (x2 - x0) / 2;
-    return ((a * frac + b) * frac + c) * frac + x1;
-  }
-  // First input will be downmixed to mono if number of channels is not 2
-  // Outputs Stereo.
-  process(inputs, outputs, parameters) {
-    const TWO_PI = 6.283185307179586;
-    const TWO_PI_DETUNE = 6.284702653297906;
-    const pd = ~~parameters.preDelay[0], bw = parameters.bandwidth[0], fi = parameters.inputDiffusion1[0], si = parameters.inputDiffusion2[0], dc = parameters.decay[0], ft = parameters.decayDiffusion1[0], st = parameters.decayDiffusion2[0], dp = 1 - parameters.damping[0], ex = parameters.excursionRate[0] / sampleRate, ed = parameters.excursionDepth[0] * sampleRate / 1e3, we = parameters.wet[0] * 0.6, dr = parameters.dry[0];
-    if (inputs[0].length == 2) {
-      for (let i2 = 127; i2 >= 0; i2--) {
-        this._preDelay[this._pDWrite + i2] = (inputs[0][0][i2] + inputs[0][1][i2]) * 0.5;
-        outputs[0][0][i2] = inputs[0][0][i2] * dr;
-        outputs[0][1][i2] = inputs[0][1][i2] * dr;
-      }
-    } else if (inputs[0].length > 0) {
-      this._preDelay.set(inputs[0][0], this._pDWrite);
-      for (let i2 = 127; i2 >= 0; i2--)
-        outputs[0][0][i2] = outputs[0][1][i2] = inputs[0][0][i2] * dr;
-    } else {
-      this._preDelay.set(new Float32Array(128), this._pDWrite);
-    }
-    let i = 0 | 0;
-    while (i < 128) {
-      let lo = 0, ro = 0;
-      this._lp1 += bw * (this._preDelay[(this._pDLength + this._pDWrite - pd + i) % this._pDLength] - this._lp1);
-      let pre = this.writeDelay(0, this._lp1 - fi * this.readDelay(0));
-      pre = this.writeDelay(
-        1,
-        fi * (pre - this.readDelay(1)) + this.readDelay(0)
-      );
-      pre = this.writeDelay(
-        2,
-        fi * pre + this.readDelay(1) - si * this.readDelay(2)
-      );
-      pre = this.writeDelay(
-        3,
-        si * (pre - this.readDelay(3)) + this.readDelay(2)
-      );
-      let split = si * pre + this.readDelay(3);
-      let exc = ed * (1 + Math.cos(this._excPhase * TWO_PI));
-      let exc2 = ed * (1 + Math.sin(this._excPhase * TWO_PI_DETUNE));
-      let temp = this.writeDelay(
-        4,
-        split + dc * this.readDelay(11) + ft * this.readDelayCAt(4, exc)
-      );
-      this.writeDelay(5, this.readDelayCAt(4, exc) - ft * temp);
-      this._lp2 += dp * (this.readDelay(5) - this._lp2);
-      temp = this.writeDelay(6, dc * this._lp2 - st * this.readDelay(6));
-      this.writeDelay(7, this.readDelay(6) + st * temp);
-      temp = this.writeDelay(
-        8,
-        split + dc * this.readDelay(7) + ft * this.readDelayCAt(8, exc2)
-      );
-      this.writeDelay(9, this.readDelayCAt(8, exc2) - ft * temp);
-      this._lp3 += dp * (this.readDelay(9) - this._lp3);
-      temp = this.writeDelay(10, dc * this._lp3 - st * this.readDelay(10));
-      this.writeDelay(11, this.readDelay(10) + st * temp);
-      lo = this.readDelayAt(9, this._taps[0]) + this.readDelayAt(9, this._taps[1]) - this.readDelayAt(10, this._taps[2]) + this.readDelayAt(11, this._taps[3]) - this.readDelayAt(5, this._taps[4]) - this.readDelayAt(6, this._taps[5]) - this.readDelayAt(7, this._taps[6]);
-      ro = this.readDelayAt(5, this._taps[7]) + this.readDelayAt(5, this._taps[8]) - this.readDelayAt(6, this._taps[9]) + this.readDelayAt(7, this._taps[10]) - this.readDelayAt(9, this._taps[11]) - this.readDelayAt(10, this._taps[12]) - this.readDelayAt(11, this._taps[13]);
-      outputs[0][0][i] += lo * we;
-      outputs[0][1][i] += ro * we;
-      this._excPhase += ex;
-      if (this._excPhase >= 1) this._excPhase -= 1;
-      i++;
-      const delays = this._Delays;
-      for (let j = 0; j < delays.length; j++) {
-        const d = delays[j];
-        d[1] = d[1] + 1 & d[3];
-        d[2] = d[2] + 1 & d[3];
-      }
-    }
-    this._pDWrite = (this._pDWrite + 128) % this._pDLength;
-    return true;
-  }
-}
 registerProcessor("dattorro-reverb-processor", DattorroReverb);
-class Distortion {
-  constructor() {
-    this.limitingMode = "hard-clipping";
-  }
-  applyDrive(sample, driveAmount) {
-    if (driveAmount <= 0) return sample;
-    const driveMultiplier = 1 + driveAmount * 3;
-    const drivenSample = sample * driveMultiplier;
-    return drivenSample;
-  }
-  applyClipping(sample, clippingAmount, clipThreshold) {
-    if (clippingAmount <= 0) return sample;
-    let clippedSample;
-    switch (this.limitingMode) {
-      case "soft-clipping":
-        clippedSample = clipThreshold * Math.tanh(sample / clipThreshold);
-        break;
-      case "hard-clipping":
-        clippedSample = Math.max(
-          -clipThreshold,
-          Math.min(clipThreshold, sample)
-        );
-        break;
-      case "bypass":
-      default:
-        clippedSample = sample;
-        break;
-    }
-    if (clipThreshold < 0.08) {
-      const makeupGain = Math.min(2, Math.pow(0.1 / clipThreshold, 0.5));
-      clippedSample *= makeupGain;
-    }
-    const blended = sample * (1 - clippingAmount) + clippedSample * clippingAmount;
-    return blended;
-  }
-  setLimitingMode(mode) {
-    this.limitingMode = mode;
-  }
-}
-registerProcessor(
-  "distortion-processor",
-  class extends AudioWorkletProcessor {
-    static get parameterDescriptors() {
-      return [
-        {
-          name: "distortionDrive",
-          defaultValue: 0,
-          minValue: 0,
-          maxValue: 1,
-          automationRate: "a-rate"
-        },
-        {
-          name: "clippingAmount",
-          defaultValue: 0,
-          minValue: 0,
-          maxValue: 1,
-          automationRate: "a-rate"
-        },
-        {
-          name: "clippingThreshold",
-          defaultValue: 0.5,
-          minValue: 0,
-          maxValue: 1,
-          automationRate: "k-rate"
-        }
-      ];
-    }
-    constructor() {
-      super();
-      this.distortion = new Distortion();
-      this.setupMessageHandling();
-      this.port.postMessage({ type: "initialized" });
-    }
-    setupMessageHandling() {
-      this.port.onmessage = (event) => {
-        switch (event.data.type) {
-          case "setLimitingMode":
-            this.distortion.setLimitingMode(event.data.mode);
-            break;
-          default:
-            console.warn("distortion-processor: Unsupported message");
-            break;
-        }
-      };
-    }
-    process(inputs, outputs, parameters) {
-      const input = inputs[0];
-      const output = outputs[0];
-      if (!input || !output) return true;
-      const clipThreshold = parameters.clippingThreshold[0];
-      for (let i = 0; i < output[0].length; ++i) {
-        const distortionDrive = parameters.distortionDrive[Math.min(i, parameters.distortionDrive.length - 1)];
-        const clippingAmount = parameters.clippingAmount[Math.min(i, parameters.clippingAmount.length - 1)];
-        for (let c = 0; c < Math.min(input.length, output.length); c++) {
-          let sample = input[c][i];
-          sample = this.distortion.applyDrive(sample, distortionDrive);
-          sample = this.distortion.applyClipping(
-            sample,
-            clippingAmount,
-            clipThreshold
-          );
-          output[c][i] = Math.max(-0.999, Math.min(0.999, sample));
-        }
-      }
-      return true;
-    }
-  }
-);
-registerProcessor(
-  "envelope-follower-processor",
-  class extends AudioWorkletProcessor {
-    static get parameterDescriptors() {
-      return [
-        {
-          name: "inputGain",
-          // linear gain (1.0 = unity)
-          defaultValue: 1,
-          minValue: 0,
-          maxValue: 10,
-          automationRate: "k-rate"
-        },
-        {
-          name: "outputGain",
-          // linear gain (1.0 = unity)
-          defaultValue: 1,
-          minValue: 0,
-          maxValue: 10,
-          automationRate: "k-rate"
-        },
-        {
-          name: "attack",
-          // seconds
-          defaultValue: 3e-3,
-          minValue: 1e-3,
-          maxValue: 1,
-          automationRate: "k-rate"
-        },
-        {
-          name: "release",
-          // seconds
-          defaultValue: 0.05,
-          minValue: 1e-3,
-          maxValue: 5,
-          automationRate: "k-rate"
-        }
-      ];
-    }
-    constructor() {
-      super();
-      this.envelope = 0;
-      this.gateThreshold = 5e-3;
-      this.debugCounter = 0;
-      this.port.postMessage({ type: "initialized" });
-    }
-    process(inputs, outputs, parameters) {
-      const input = inputs[0];
-      const output = outputs[0];
-      const channel = inputs[0][0];
-      if (!input || !output || !channel || input.length === 0 || output.length === 0 || channel.length === 0) {
-        return true;
-      }
-      const inChannel = input[0];
-      if (!inChannel || inChannel.length === 0) return true;
-      const attack = parameters.attack[0];
-      const release = parameters.release[0];
-      const inputGain = parameters.inputGain[0];
-      const outputGain = parameters.outputGain[0];
-      const attackCoeff = Math.exp(-1 / (attack * sampleRate));
-      const releaseCoeff = Math.exp(-1 / (release * sampleRate));
-      for (let sample = 0; sample < output[0].length; sample++) {
-        const inputLevel = Math.abs((input[0][sample] || 0) * inputGain);
-        if (inputLevel > 1e-6) {
-          if (inputLevel > this.envelope) {
-            this.envelope = inputLevel + (this.envelope - inputLevel) * attackCoeff;
-          } else {
-            this.envelope = inputLevel + (this.envelope - inputLevel) * releaseCoeff;
-          }
-        } else {
-          this.envelope *= releaseCoeff;
-        }
-        if (this.envelope < this.gateThreshold) this.envelope = 0;
-        const finalOutput = this.envelope * outputGain;
-        for (let channel2 = 0; channel2 < output.length; channel2++) {
-          output[channel2][sample] = finalOutput;
-        }
-      }
-      return true;
-    }
-  }
-);
+//#endregion
+//#region src/worklets/processors/distortion/distortion-processor.js
+var Distortion = class {
+	constructor() {
+		this.limitingMode = "hard-clipping";
+	}
+	applyDrive(sample, driveAmount) {
+		if (driveAmount <= 0) return sample;
+		return sample * (1 + driveAmount * 3);
+	}
+	applyClipping(sample, clippingAmount, clipThreshold) {
+		if (clippingAmount <= 0) return sample;
+		let clippedSample;
+		switch (this.limitingMode) {
+			case "soft-clipping":
+				clippedSample = clipThreshold * Math.tanh(sample / clipThreshold);
+				break;
+			case "hard-clipping":
+				clippedSample = Math.max(-clipThreshold, Math.min(clipThreshold, sample));
+				break;
+			default: clippedSample = sample;
+		}
+		if (clipThreshold < .08) {
+			const makeupGain = Math.min(2, Math.pow(.1 / clipThreshold, .5));
+			clippedSample *= makeupGain;
+		}
+		return sample * (1 - clippingAmount) + clippedSample * clippingAmount;
+	}
+	setLimitingMode(mode) {
+		this.limitingMode = mode;
+	}
+};
+registerProcessor("distortion-processor", class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return [
+			{
+				name: "distortionDrive",
+				defaultValue: 0,
+				minValue: 0,
+				maxValue: 1,
+				automationRate: "a-rate"
+			},
+			{
+				name: "clippingAmount",
+				defaultValue: 0,
+				minValue: 0,
+				maxValue: 1,
+				automationRate: "a-rate"
+			},
+			{
+				name: "clippingThreshold",
+				defaultValue: .5,
+				minValue: 0,
+				maxValue: 1,
+				automationRate: "k-rate"
+			}
+		];
+	}
+	constructor() {
+		super();
+		this.distortion = new Distortion();
+		this.setupMessageHandling();
+		this.port.postMessage({ type: "initialized" });
+	}
+	setupMessageHandling() {
+		this.port.onmessage = (event) => {
+			switch (event.data.type) {
+				case "setLimitingMode":
+					this.distortion.setLimitingMode(event.data.mode);
+					break;
+				default: console.warn("distortion-processor: Unsupported message");
+			}
+		};
+	}
+	process(inputs, outputs, parameters) {
+		const input = inputs[0];
+		const output = outputs[0];
+		if (!input || !output) return true;
+		const clipThreshold = parameters.clippingThreshold[0];
+		for (let i = 0; i < output[0].length; ++i) {
+			const distortionDrive = parameters.distortionDrive[Math.min(i, parameters.distortionDrive.length - 1)];
+			const clippingAmount = parameters.clippingAmount[Math.min(i, parameters.clippingAmount.length - 1)];
+			for (let c = 0; c < Math.min(input.length, output.length); c++) {
+				let sample = input[c][i];
+				sample = this.distortion.applyDrive(sample, distortionDrive);
+				sample = this.distortion.applyClipping(sample, clippingAmount, clipThreshold);
+				output[c][i] = Math.max(-.999, Math.min(.999, sample));
+			}
+		}
+		return true;
+	}
+});
+//#endregion
+//#region src/worklets/processors/follower/envelope-follower-processor.js
+registerProcessor("envelope-follower-processor", class extends AudioWorkletProcessor {
+	static get parameterDescriptors() {
+		return [
+			{
+				name: "inputGain",
+				defaultValue: 1,
+				minValue: 0,
+				maxValue: 10,
+				automationRate: "k-rate"
+			},
+			{
+				name: "outputGain",
+				defaultValue: 1,
+				minValue: 0,
+				maxValue: 10,
+				automationRate: "k-rate"
+			},
+			{
+				name: "attack",
+				defaultValue: .003,
+				minValue: .001,
+				maxValue: 1,
+				automationRate: "k-rate"
+			},
+			{
+				name: "release",
+				defaultValue: .05,
+				minValue: .001,
+				maxValue: 5,
+				automationRate: "k-rate"
+			}
+		];
+	}
+	constructor() {
+		super();
+		this.envelope = 0;
+		this.gateThreshold = .005;
+		this.debugCounter = 0;
+		this.port.postMessage({ type: "initialized" });
+	}
+	process(inputs, outputs, parameters) {
+		const input = inputs[0];
+		const output = outputs[0];
+		const channel = inputs[0][0];
+		if (!input || !output || !channel || input.length === 0 || output.length === 0 || channel.length === 0) return true;
+		const inChannel = input[0];
+		if (!inChannel || inChannel.length === 0) return true;
+		const attack = parameters.attack[0];
+		const release = parameters.release[0];
+		const inputGain = parameters.inputGain[0];
+		const outputGain = parameters.outputGain[0];
+		const attackCoeff = Math.exp(-1 / (attack * sampleRate));
+		const releaseCoeff = Math.exp(-1 / (release * sampleRate));
+		for (let sample = 0; sample < output[0].length; sample++) {
+			const inputLevel = Math.abs((input[0][sample] || 0) * inputGain);
+			if (inputLevel > 1e-6) {
+				if (inputLevel > this.envelope) this.envelope = inputLevel + (this.envelope - inputLevel) * attackCoeff;
+				else this.envelope = inputLevel + (this.envelope - inputLevel) * releaseCoeff;
+			} else this.envelope *= releaseCoeff;
+			if (this.envelope < this.gateThreshold) this.envelope = 0;
+			const finalOutput = this.envelope * outputGain;
+			for (let channel = 0; channel < output.length; channel++) output[channel][sample] = finalOutput;
+		}
+		return true;
+	}
+});
+//#endregion