cantor-digitalis 0.0.1

package/dist/index.js

@@ -0,0 +1,1486 @@
+var lt = Object.defineProperty;
+var ht = (a, t, e) => t in a ? lt(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var r = (a, t, e) => ht(a, typeof t != "symbol" ? t + "" : t, e);
+class w {
+  constructor(t, e) {
+    r(this, "ctx");
+    r(this, "gainNode");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.gainNode = e, this.in = e, this.out = e;
+  }
+  static async create(t, e) {
+    const i = t.createGain();
+    return i.gain.setValueAtTime(e.gain, t.currentTime), new w(t, i);
+  }
+  update(t) {
+    this.gainNode.gain.setTargetAtTime(t.gain, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.gainNode.disconnect();
+  }
+  get gain() {
+    return this.gainNode.gain;
+  }
+}
+const dt = `
+class PulseTrainProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "f0", defaultValue: 220, minValue: 20, maxValue: 20000, automationRate: "a-rate" },
+      { name: "jitterDepth", defaultValue: 0, minValue: 0, maxValue: 0.3, automationRate: "k-rate" },
+      { name: "shimmerDepth", defaultValue: 0, minValue: 0, maxValue: 1, automationRate: "k-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Phase accumulator (0 to 1)
+    this.phase = 0;
+
+    // Current perturbation values (updated each period)
+    this.currentJitter = 1;   // Multiplier for f0 (1 = no jitter)
+    this.currentShimmer = 1;  // Multiplier for amplitude (1 = no shimmer)
+
+    // Box-Muller spare for Gaussian random
+    this.hasSpare = false;
+    this.spare = 0;
+
+    // Cached harmonic count for band-limiting
+    this.harmonicCount = 0;
+    this.lastF0ForHarmonics = 220;
+    this.updateHarmonicCount(220);
+  }
+
+  /**
+   * Update the number of harmonics to sum for band-limited impulse.
+   * We include harmonics up to Nyquist to avoid aliasing.
+   */
+  updateHarmonicCount(f0) {
+    const nyquist = sampleRate / 2;
+    this.harmonicCount = Math.max(1, Math.floor(nyquist / f0));
+    this.lastF0ForHarmonics = f0;
+  }
+
+  /**
+   * Generate a Gaussian-distributed random number using Box-Muller transform.
+   * Returns values with mean 0 and standard deviation 1.
+   */
+  gaussianRandom() {
+    if (this.hasSpare) {
+      this.hasSpare = false;
+      return this.spare;
+    }
+
+    let u, v, s;
+    do {
+      u = Math.random() * 2 - 1;
+      v = Math.random() * 2 - 1;
+      s = u * u + v * v;
+    } while (s >= 1 || s === 0);
+
+    const mul = Math.sqrt(-2 * Math.log(s) / s);
+    this.spare = v * mul;
+    this.hasSpare = true;
+    return u * mul;
+  }
+
+  /**
+   * Generate new perturbation values at a period boundary.
+   * Jitter affects the next period's frequency.
+   * Shimmer affects the current pulse's amplitude.
+   */
+  generatePerturbations(jitterDepth, shimmerDepth) {
+    // Jitter: Gaussian perturbation of f0, clipped to ±jitterDepth
+    // Using Gaussian makes small perturbations more likely than large ones
+    const jitterRaw = this.gaussianRandom() * jitterDepth * 0.5;
+    const jitterClamped = Math.max(-jitterDepth, Math.min(jitterDepth, jitterRaw));
+    this.currentJitter = 1 + jitterClamped;
+
+    // Shimmer: Gaussian perturbation of amplitude, clipped to [0, 2]
+    // At shimmerDepth=1, amplitude can vary from 0 to 2 (±100%)
+    const shimmerRaw = this.gaussianRandom() * shimmerDepth * 0.5;
+    const shimmerClamped = Math.max(-shimmerDepth, Math.min(shimmerDepth, shimmerRaw));
+    this.currentShimmer = 1 + shimmerClamped;
+
+    // Clamp shimmer to non-negative (amplitude can't be negative)
+    this.currentShimmer = Math.max(0, this.currentShimmer);
+  }
+
+  /**
+   * Compute a band-limited impulse using additive synthesis.
+   * Sums cosines at all harmonic frequencies up to Nyquist.
+   *
+   * The impulse is normalized so that its peak amplitude is approximately 1.
+   */
+  computeBandLimitedImpulse(phase) {
+    // Sum all harmonics: Σ cos(2π * k * phase) for k = 1 to harmonicCount
+    // This produces a Dirac comb approximation
+    let sum = 0;
+    const twoPiPhase = 2 * Math.PI * phase;
+    for (let k = 1; k <= this.harmonicCount; k++) {
+      sum += Math.cos(k * twoPiPhase);
+    }
+    // Normalize by harmonic count to keep amplitude reasonable
+    return sum / this.harmonicCount;
+  }
+
+  process(inputs, outputs, parameters) {
+    const output = outputs[0]?.[0];
+    if (!output) {
+      return true;
+    }
+
+    const dt = 1 / sampleRate;
+    // k-rate parameters (single value per block)
+    const jitterDepth = parameters.jitterDepth[0];
+    const shimmerDepth = parameters.shimmerDepth[0];
+
+    for (let i = 0; i < output.length; i++) {
+      // a-rate: per-sample value for f0
+      const f0 = parameters.f0.length > 1 ? parameters.f0[i] : parameters.f0[0];
+
+      // Compute effective f0 with current jitter
+      const f0Effective = f0 * this.currentJitter;
+
+      // Advance phase
+      this.phase += f0Effective * dt;
+
+      // Check for period boundary (phase wrapped)
+      if (this.phase >= 1) {
+        this.phase -= 1;
+        // Generate new perturbations for the next period
+        this.generatePerturbations(jitterDepth, shimmerDepth);
+        // Update harmonic count if f0 changed significantly (>10%)
+        if (Math.abs(f0 - this.lastF0ForHarmonics) / this.lastF0ForHarmonics > 0.1) {
+          this.updateHarmonicCount(f0);
+        }
+      }
+
+      // Generate band-limited impulse and apply shimmer
+      output[i] = this.currentShimmer * this.computeBandLimitedImpulse(this.phase);
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('pulse-train-processor', PulseTrainProcessor);
+`;
+let Q = !1;
+async function pt(a) {
+  if (Q)
+    return;
+  const t = new Blob([dt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), Q = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class V {
+  constructor(t, e, i) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "gain");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.gain = i, this.out = i.out, this.in = null;
+  }
+  /** Fundamental frequency AudioParam (a-rate, 20-20000 Hz) */
+  get f0() {
+    return this.workletNode.parameters.get("f0");
+  }
+  /** Jitter depth AudioParam (k-rate, 0-0.3) */
+  get jitterDepth() {
+    return this.workletNode.parameters.get("jitterDepth");
+  }
+  /** Shimmer depth AudioParam (k-rate, 0-1) */
+  get shimmerDepth() {
+    return this.workletNode.parameters.get("shimmerDepth");
+  }
+  static async create(t, e) {
+    await pt(t);
+    const i = new AudioWorkletNode(t, "pulse-train-processor"), s = await w.create(t, { gain: 0 });
+    i.connect(s.in);
+    const n = new V(t, i, s);
+    return n.update(e), n;
+  }
+  update(t) {
+    this.f0.setTargetAtTime(t.f0, this.ctx.currentTime, 0.02), this.jitterDepth.setTargetAtTime(t.jitterDepth, this.ctx.currentTime, 0.02), this.shimmerDepth.setTargetAtTime(t.shimmerDepth, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect(), this.gain.destroy();
+  }
+  start() {
+    this.gain.update({ gain: 1 });
+  }
+  stop() {
+    this.gain.update({ gain: 0 });
+  }
+}
+const mt = `
+class GlottalFormantProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "Fg", defaultValue: 110, minValue: 20, maxValue: 2000, automationRate: "a-rate" },
+      { name: "Bg", defaultValue: 50, minValue: 10, maxValue: 500, automationRate: "a-rate" },
+      { name: "Ag", defaultValue: 1, minValue: 0, maxValue: 10, automationRate: "a-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Filter state (delay line)
+    this.x1 = 0;
+    this.x2 = 0;
+    this.y1 = 0;
+    this.y2 = 0;
+
+    // Cached coefficient values to avoid recomputing when unchanged
+    this.lastFg = -1;
+    this.lastBg = -1;
+    this.R = 0;
+    this.cosTheta = 0;
+    this.a1 = 0;
+    this.a2 = 0;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0]?.[0];
+    const output = outputs[0]?.[0];
+
+    if (!input || !output) {
+      return true;
+    }
+
+    const Ts = 1 / sampleRate;
+    // k-rate parameters (single value per block)
+    const Fg = parameters.Fg[0];
+    const Bg = parameters.Bg[0];
+
+    // Recompute filter coefficients if Fg or Bg changed
+    if (Fg !== this.lastFg || Bg !== this.lastBg) {
+      this.R = Math.exp(-Math.PI * Bg * Ts);
+      const theta = 2 * Math.PI * Fg * Ts;
+      this.cosTheta = Math.cos(theta);
+      this.a1 = -2 * this.R * this.cosTheta;
+      this.a2 = this.R * this.R;
+      this.lastFg = Fg;
+      this.lastBg = Bg;
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      // a-rate: per-sample value for Ag
+      const Ag = parameters.Ag.length > 1 ? parameters.Ag[i] : parameters.Ag[0];
+
+      const x0 = input[i];
+
+      // Numerator coefficients (feedforward) depend on Ag
+      // From: -Ag * z^{-1} * (1 - z^{-1}) = -Ag*z^{-1} + Ag*z^{-2}
+      const b1 = -Ag;
+      const b2 = Ag;
+
+      // Direct Form I biquad (b0 is always 0)
+      const y0 = b1 * this.x1 + b2 * this.x2
+                 - this.a1 * this.y1 - this.a2 * this.y2;
+
+      // Update delay line
+      this.x2 = this.x1;
+      this.x1 = x0;
+      this.y2 = this.y1;
+      this.y1 = y0;
+
+      output[i] = y0;
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('glottal-formant-processor', GlottalFormantProcessor);
+`;
+let z = !1;
+async function ft(a) {
+  if (z)
+    return;
+  const t = new Blob([mt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), z = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class D {
+  constructor(t, e) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.in = e, this.out = e;
+  }
+  /** Glottal formant centre frequency AudioParam (a-rate, 20-2000 Hz) */
+  get Fg() {
+    return this.workletNode.parameters.get("Fg");
+  }
+  /** Glottal formant bandwidth AudioParam (a-rate, 10-500 Hz) */
+  get Bg() {
+    return this.workletNode.parameters.get("Bg");
+  }
+  /** Source amplitude AudioParam (a-rate, 0-10) */
+  get Ag() {
+    return this.workletNode.parameters.get("Ag");
+  }
+  /**
+   * Creates a new GlottalFormant node.
+   *
+   * The AudioWorklet module is registered automatically on first use.
+   */
+  static async create(t, e) {
+    await ft(t);
+    const i = new AudioWorkletNode(t, "glottal-formant-processor"), s = new D(t, i);
+    return s.update(e), s;
+  }
+  /**
+   * Updates the glottal formant parameters.
+   * Sets AudioParams via setTargetAtTime for smooth transitions.
+   */
+  update(t) {
+    this.Fg.setTargetAtTime(t.Fg, this.ctx.currentTime, 0.02), this.Bg.setTargetAtTime(t.Bg, this.ctx.currentTime, 0.02), this.Ag.setTargetAtTime(t.Ag, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect();
+  }
+}
+const gt = `
+class SpectralTiltProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "Tl1", defaultValue: 0, minValue: 0, maxValue: 50, automationRate: "k-rate" },
+      { name: "Tl2", defaultValue: 0, minValue: 0, maxValue: 30, automationRate: "k-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Filter coefficients for two stages
+    this.a1 = 0;  // First stage pole
+    this.a2 = 0;  // Second stage pole
+    this.g1 = 1;  // First stage gain (1 - a1)
+    this.g2 = 1;  // Second stage gain (1 - a2)
+
+    // Filter state (one delay element per stage)
+    this.y1_prev = 0;  // Previous output of stage 1
+    this.y2_prev = 0;  // Previous output of stage 2
+
+    // Cache last parameter values for change detection
+    this.lastTl1 = -1;
+    this.lastTl2 = -1;
+
+    // Pre-compute cosOmega since it's constant for a given sample rate
+    const Ts = 1 / sampleRate;
+    this.cosOmega = Math.cos(2 * Math.PI * 3000 * Ts);
+  }
+
+  /**
+   * Compute the pole coefficient for a single stage.
+   * Returns [a, g] where a is the pole and g = 1 - a is the gain.
+   */
+  computeStageCoefficients(Tl) {
+    // Bypass if attenuation is zero or negative
+    if (Tl <= 0) {
+      return [0, 1];
+    }
+
+    // Power ratio at 3000 Hz (10^(Tl/10) is the attenuation factor)
+    const attenuationRatio = Math.pow(10, Tl / 10);
+
+    // Compute ν from Section 3.2.2
+    // νᵢ = 1 + (1 - cos(ω)) / (10^(Tlᵢ/10) - 1)
+    const nu = 1 + (1 - this.cosOmega) / (attenuationRatio - 1);
+
+    // Compute pole coefficient: a = ν - √(ν² - 1)
+    // This ensures 0 < a < 1 for stability
+    const a = nu - Math.sqrt(nu * nu - 1);
+    const g = 1 - a;
+
+    return [a, g];
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0]?.[0];
+    const output = outputs[0]?.[0];
+
+    if (!input || !output) {
+      return true;
+    }
+
+    // k-rate parameters (single value per block)
+    const Tl1 = parameters.Tl1[0];
+    const Tl2 = parameters.Tl2[0];
+
+    // Recompute coefficients if parameters changed
+    if (Tl1 !== this.lastTl1) {
+      [this.a1, this.g1] = this.computeStageCoefficients(Tl1);
+      this.lastTl1 = Tl1;
+    }
+    if (Tl2 !== this.lastTl2) {
+      [this.a2, this.g2] = this.computeStageCoefficients(Tl2);
+      this.lastTl2 = Tl2;
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      // Stage 1: y1[n] = g1 * x[n] + a1 * y1[n-1]
+      const y1 = this.g1 * input[i] + this.a1 * this.y1_prev;
+      this.y1_prev = y1;
+
+      // Stage 2: y2[n] = g2 * y1[n] + a2 * y2[n-1]
+      const y2 = this.g2 * y1 + this.a2 * this.y2_prev;
+      this.y2_prev = y2;
+
+      output[i] = y2;
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('spectral-tilt-processor', SpectralTiltProcessor);
+`;
+let O = !1;
+async function yt(a) {
+  if (O)
+    return;
+  const t = new Blob([gt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), O = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class N {
+  constructor(t, e) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.in = e, this.out = e;
+  }
+  /** First stage spectral tilt attenuation AudioParam (k-rate, 0-50 dB at 3kHz) */
+  get Tl1() {
+    return this.workletNode.parameters.get("Tl1");
+  }
+  /** Second stage spectral tilt attenuation AudioParam (k-rate, 0-30 dB at 3kHz) */
+  get Tl2() {
+    return this.workletNode.parameters.get("Tl2");
+  }
+  /**
+   * Creates a new SpectralTilt node.
+   *
+   * The AudioWorklet module is registered automatically on first use.
+   */
+  static async create(t, e) {
+    await yt(t);
+    const i = new AudioWorkletNode(t, "spectral-tilt-processor"), s = new N(t, i);
+    return s.update(e), s;
+  }
+  /**
+   * Updates the spectral tilt parameters.
+   * Sets AudioParams via setTargetAtTime for smooth transitions.
+   */
+  update(t) {
+    this.Tl1.setTargetAtTime(t.Tl1, this.ctx.currentTime, 0.02), this.Tl2.setTargetAtTime(t.Tl2, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect();
+  }
+}
+const wt = `
+class NoiseSourceProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "An", defaultValue: 0, minValue: 0, maxValue: 1, automationRate: "a-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Box-Muller spare value
+    this.hasSpare = false;
+    this.spare = 0;
+  }
+
+  /**
+   * Generate a Gaussian-distributed random number using Box-Muller transform.
+   * Returns values with mean 0 and standard deviation 1.
+   */
+  gaussianRandom() {
+    if (this.hasSpare) {
+      this.hasSpare = false;
+      return this.spare;
+    }
+
+    // Generate two uniform random numbers in (0, 1)
+    let u, v, s;
+    do {
+      u = Math.random() * 2 - 1;
+      v = Math.random() * 2 - 1;
+      s = u * u + v * v;
+    } while (s >= 1 || s === 0);
+
+    const mul = Math.sqrt(-2 * Math.log(s) / s);
+    this.spare = v * mul;
+    this.hasSpare = true;
+    return u * mul;
+  }
+
+  process(inputs, outputs, parameters) {
+    const output = outputs[0]?.[0];
+
+    if (!output) {
+      return true;
+    }
+
+    for (let i = 0; i < output.length; i++) {
+      // a-rate: per-sample value for An
+      const An = parameters.An.length > 1 ? parameters.An[i] : parameters.An[0];
+      output[i] = An * this.gaussianRandom();
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('noise-source-processor', NoiseSourceProcessor);
+`;
+let W = !1;
+async function bt(a) {
+  if (W)
+    return;
+  const t = new Blob([wt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), W = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class P {
+  constructor(t, e, i, s) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "highpassFilter");
+    r(this, "lowpassFilter");
+    r(this, "in", null);
+    // Noise source has no input
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.highpassFilter = i, this.lowpassFilter = s, this.out = s;
+  }
+  /** Noise amplitude AudioParam (a-rate, 0-1) */
+  get An() {
+    return this.workletNode.parameters.get("An");
+  }
+  /**
+   * Creates a new NoiseSource node.
+   *
+   * The AudioWorklet module is registered automatically on first use.
+   */
+  static async create(t, e) {
+    await bt(t);
+    const i = new AudioWorkletNode(t, "noise-source-processor"), s = t.createBiquadFilter();
+    s.type = "highpass", s.frequency.setValueAtTime(1e3, t.currentTime), s.Q.setValueAtTime(Math.SQRT1_2, t.currentTime);
+    const n = t.createBiquadFilter();
+    n.type = "lowpass", n.frequency.setValueAtTime(6e3, t.currentTime), n.Q.setValueAtTime(Math.SQRT1_2, t.currentTime), i.connect(s), s.connect(n);
+    const o = new P(t, i, s, n);
+    return o.update(e), o;
+  }
+  /**
+   * Updates the noise source amplitude.
+   * Sets AudioParam via setTargetAtTime for smooth transitions.
+   */
+  update(t) {
+    this.An.setTargetAtTime(t.An, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect(), this.highpassFilter.disconnect(), this.lowpassFilter.disconnect();
+  }
+}
+class S {
+  constructor(t, e, i, s, n, o) {
+    r(this, "pulseTrain");
+    r(this, "glottalFormant");
+    r(this, "spectralTilt");
+    r(this, "noiseSource");
+    r(this, "noiseModulator");
+    // Multiplies noise by GFD signal
+    r(this, "outputGain");
+    r(this, "in", null);
+    // Source node has no input
+    r(this, "out");
+    this.pulseTrain = t, this.glottalFormant = e, this.spectralTilt = i, this.noiseSource = s, this.noiseModulator = n, this.outputGain = o, this.out = o.out;
+  }
+  /**
+   * Creates a new GlottalFlowDerivative node.
+   *
+   * Sets up the voiced path (pulse train → glottal formant → spectral tilt)
+   * and the noise modulation path where noise is multiplied by the GFD signal.
+   */
+  static async create(t, e) {
+    const [i, s, n, o, c] = await Promise.all([
+      V.create(t, {
+        f0: e.f0,
+        jitterDepth: e.jitterDepth,
+        shimmerDepth: e.shimmerDepth
+      }),
+      D.create(t, { Fg: e.Fg, Bg: e.Bg, Ag: e.Ag }),
+      N.create(t, { Tl1: e.Tl1, Tl2: e.Tl2 }),
+      P.create(t, { An: e.An }),
+      w.create(t, { gain: 1 })
+    ]), l = t.createGain();
+    return l.gain.setValueAtTime(0, t.currentTime), i.out.connect(s.in), s.out.connect(n.in), n.out.connect(c.in), n.out.connect(l.gain), o.out.connect(l), l.connect(c.in), new S(
+      i,
+      s,
+      n,
+      o,
+      l,
+      c
+    );
+  }
+  /**
+   * Updates all glottal flow derivative parameters.
+   * Each sub-node receives its relevant parameters.
+   */
+  update(t) {
+    this.pulseTrain.update({
+      f0: t.f0,
+      jitterDepth: t.jitterDepth,
+      shimmerDepth: t.shimmerDepth
+    }), this.glottalFormant.update({ Fg: t.Fg, Bg: t.Bg, Ag: t.Ag }), this.spectralTilt.update({ Tl1: t.Tl1, Tl2: t.Tl2 }), this.noiseSource.update({ An: t.An });
+  }
+  /**
+   * Returns the pulse train node for direct AudioParam access.
+   *
+   * Example usage:
+   *   gfd.pulseTrainNode.f0.setValueAtTime(440, ctx.currentTime);
+   *   gfd.pulseTrainNode.jitterDepth.linearRampToValueAtTime(0.1, ctx.currentTime + 0.5);
+   */
+  get pulseTrainNode() {
+    return this.pulseTrain;
+  }
+  /**
+   * Returns the glottal formant node for direct AudioParam access.
+   *
+   * Example usage:
+   *   gfd.glottalFormantNode.Fg.setValueAtTime(220, ctx.currentTime);
+   *   gfd.glottalFormantNode.Ag.setTargetAtTime(0.5, ctx.currentTime, 0.1);
+   */
+  get glottalFormantNode() {
+    return this.glottalFormant;
+  }
+  /**
+   * Returns the spectral tilt node for direct AudioParam access.
+   *
+   * Example usage:
+   *   gfd.spectralTiltNode.Tl1.setValueAtTime(10, ctx.currentTime);
+   */
+  get spectralTiltNode() {
+    return this.spectralTilt;
+  }
+  /**
+   * Returns the noise source node for direct AudioParam access.
+   *
+   * Example usage:
+   *   gfd.noiseSourceNode.An.setValueAtTime(0.3, ctx.currentTime);
+   */
+  get noiseSourceNode() {
+    return this.noiseSource;
+  }
+  /**
+   * Starts the voiced excitation (pulse train).
+   */
+  start() {
+    this.pulseTrain.start();
+  }
+  /**
+   * Stops the voiced excitation (pulse train).
+   * Note: Noise source continues to produce output based on An parameter.
+   */
+  stop() {
+    this.pulseTrain.stop();
+  }
+  destroy() {
+    this.pulseTrain.destroy(), this.glottalFormant.destroy(), this.spectralTilt.destroy(), this.noiseSource.destroy(), this.noiseModulator.disconnect(), this.outputGain.destroy();
+  }
+}
+const Tt = `
+class FormantResonatorProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "F", defaultValue: 500, minValue: 100, maxValue: 8000, automationRate: "a-rate" },
+      { name: "B", defaultValue: 100, minValue: 20, maxValue: 1000, automationRate: "a-rate" },
+      { name: "A", defaultValue: 1, minValue: 0, maxValue: 10, automationRate: "a-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Filter state (delay line)
+    this.x1 = 0;
+    this.x2 = 0;
+    this.y1 = 0;
+    this.y2 = 0;
+
+    // Cached parameter values for change detection
+    this.lastF = -1;
+    this.lastB = -1;
+    this.lastA = -1;
+
+    // Cached coefficients
+    this.b0 = 0;
+    this.b2 = 0;
+    this.a1 = 0;
+    this.a2 = 0;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0]?.[0];
+    const output = outputs[0]?.[0];
+
+    if (!input || !output) {
+      return true;
+    }
+
+    // a-rate parameters (per-sample values)
+    const F = parameters.F[0];
+    const B = parameters.B[0];
+    const A = parameters.A[0];
+
+    // Recompute coefficients if any parameter changed
+    if (F !== this.lastF || B !== this.lastB || A !== this.lastA) {
+      const Ts = 1 / sampleRate;
+
+      // Pole radius and angle
+      const R = Math.exp(-Math.PI * B * Ts);
+      const theta = 2 * Math.PI * F * Ts;
+
+      // Gain scaling factor
+      const g = 1 - R;
+
+      // Numerator coefficients (feedforward)
+      // From: A * g * (1 - R*z^{-2}) = A*g + 0*z^{-1} - A*g*R*z^{-2}
+      this.b0 = A * g;
+      this.b2 = -A * g * R;
+
+      // Denominator coefficients (feedback)
+      // From: 1 - 2R*cos(θ)*z^{-1} + R²*z^{-2}
+      this.a1 = -2 * R * Math.cos(theta);
+      this.a2 = R * R;
+
+      this.lastF = F;
+      this.lastB = B;
+      this.lastA = A;
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      const x0 = input[i];
+
+      // Direct Form I biquad (b1 is always 0)
+      const y0 = this.b0 * x0 + this.b2 * this.x2
+                 - this.a1 * this.y1 - this.a2 * this.y2;
+
+      // Update delay line
+      this.x2 = this.x1;
+      this.x1 = x0;
+      this.y2 = this.y1;
+      this.y1 = y0;
+
+      output[i] = y0;
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('formant-resonator-processor', FormantResonatorProcessor);
+`;
+let $ = !1;
+async function Ft(a) {
+  if ($)
+    return;
+  const t = new Blob([Tt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), $ = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class C {
+  constructor(t, e) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.in = e, this.out = e;
+  }
+  /** Formant centre frequency AudioParam (a-rate, 100-8000 Hz) */
+  get F() {
+    return this.workletNode.parameters.get("F");
+  }
+  /** Formant bandwidth AudioParam (a-rate, 20-1000 Hz) */
+  get B() {
+    return this.workletNode.parameters.get("B");
+  }
+  /** Formant amplitude AudioParam (a-rate, 0-10) */
+  get A() {
+    return this.workletNode.parameters.get("A");
+  }
+  /**
+   * Creates a new FormantResonator node.
+   *
+   * The AudioWorklet module is registered automatically on first use.
+   */
+  static async create(t, e) {
+    await Ft(t);
+    const i = new AudioWorkletNode(t, "formant-resonator-processor"), s = new C(t, i);
+    return s.update(e), s;
+  }
+  /**
+   * Updates the formant resonator parameters.
+   * Sets AudioParams via setTargetAtTime for smooth transitions.
+   */
+  update(t) {
+    this.F.setTargetAtTime(t.F, this.ctx.currentTime, 0.02), this.B.setTargetAtTime(t.B, this.ctx.currentTime, 0.02), this.A.setTargetAtTime(t.A, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect();
+  }
+}
+class j {
+  constructor(t, e, i) {
+    r(this, "resonators");
+    r(this, "inputGain");
+    r(this, "outputGain");
+    r(this, "in");
+    r(this, "out");
+    this.resonators = t, this.inputGain = e, this.outputGain = i, this.in = e, this.out = i;
+  }
+  /**
+   * Creates a new FormantBank node with the specified formants.
+   *
+   * All formant resonators are created in parallel for efficiency.
+   */
+  static async create(t, e) {
+    const i = t.createGain();
+    i.gain.setValueAtTime(1, t.currentTime);
+    const s = t.createGain();
+    s.gain.setValueAtTime(1, t.currentTime);
+    const n = await Promise.all(
+      e.formants.map((o) => C.create(t, o))
+    );
+    for (const o of n)
+      i.connect(o.in), o.out.connect(s);
+    return new j(n, i, s);
+  }
+  /**
+   * Updates all formant parameters.
+   *
+   * The formants array must have the same length as the original.
+   * Each resonator receives its corresponding parameters.
+   *
+   * @throws Error if the formants array length doesn't match
+   */
+  update(t) {
+    if (t.formants.length !== this.resonators.length)
+      throw new Error(
+        `FormantBank: Cannot change number of formants. Expected ${this.resonators.length}, got ${t.formants.length}. Destroy and recreate the node to change formant count.`
+      );
+    for (let e = 0; e < this.resonators.length; e++)
+      this.resonators[e].update(t.formants[e]);
+  }
+  /**
+   * Returns the number of formant resonators in this bank.
+   */
+  get count() {
+    return this.resonators.length;
+  }
+  /**
+   * Returns the array of formant resonators for direct AudioParam access.
+   *
+   * Example usage:
+   *   formantBank.formants[0].F.setValueAtTime(800, ctx.currentTime);
+   *   formantBank.formants[1].B.linearRampToValueAtTime(100, ctx.currentTime + 0.1);
+   */
+  get formants() {
+    return this.resonators;
+  }
+  destroy() {
+    this.inputGain.disconnect(), this.outputGain.disconnect();
+    for (const t of this.resonators)
+      t.destroy();
+    this.resonators = [];
+  }
+}
+const Rt = `
+class AntiResonanceProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "F", defaultValue: 4700, minValue: 1000, maxValue: 10000, automationRate: "k-rate" },
+      { name: "Q", defaultValue: 2.5, minValue: 0.5, maxValue: 20, automationRate: "k-rate" }
+    ];
+  }
+
+  constructor() {
+    super();
+    // Filter state (delay line)
+    this.x1 = 0;
+    this.x2 = 0;
+    this.y1 = 0;
+    this.y2 = 0;
+
+    // Cached parameter values for change detection
+    this.lastF = -1;
+    this.lastQ = -1;
+
+    // Cached coefficients
+    this.b0 = 1;
+    this.b1 = 0;
+    this.b2 = 1;
+    this.a1 = 0;
+    this.a2 = 0;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0]?.[0];
+    const output = outputs[0]?.[0];
+
+    if (!input || !output) {
+      return true;
+    }
+
+    // k-rate parameters (single value per block)
+    const F = parameters.F[0];
+    const Q = parameters.Q[0];
+
+    // Recompute coefficients if any parameter changed
+    if (F !== this.lastF || Q !== this.lastQ) {
+      const Ts = 1 / sampleRate;
+      const omega = 2 * Math.PI * F * Ts;
+
+      // Intermediate coefficients from the paper
+      const alpha = Math.sin(omega) / (2 * Q);
+      const beta = -2 * Math.cos(omega);
+
+      // Normalize by dividing by (1 + alpha) so that a0 = 1
+      const a0 = 1 + alpha;
+
+      // Numerator coefficients (feedforward)
+      // From: (1 + β*z⁻¹ + z⁻²) / a0
+      this.b0 = 1 / a0;
+      this.b1 = beta / a0;
+      this.b2 = 1 / a0;
+
+      // Denominator coefficients (feedback), normalized
+      // From: ((1 + α) + β*z⁻¹ + (1 - α)*z⁻²) / a0
+      // a0/a0 = 1 (implicit), a1 = β/a0, a2 = (1 - α)/a0
+      this.a1 = beta / a0;
+      this.a2 = (1 - alpha) / a0;
+
+      this.lastF = F;
+      this.lastQ = Q;
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      const x0 = input[i];
+
+      // Direct Form I biquad
+      const y0 = this.b0 * x0 + this.b1 * this.x1 + this.b2 * this.x2
+                 - this.a1 * this.y1 - this.a2 * this.y2;
+
+      // Update delay line
+      this.x2 = this.x1;
+      this.x1 = x0;
+      this.y2 = this.y1;
+      this.y1 = y0;
+
+      output[i] = y0;
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('anti-resonance-processor', AntiResonanceProcessor);
+`;
+let I = !1;
+async function At(a) {
+  if (I)
+    return;
+  const t = new Blob([Rt], { type: "application/javascript" }), e = URL.createObjectURL(t);
+  try {
+    await a.audioWorklet.addModule(e), I = !0;
+  } finally {
+    URL.revokeObjectURL(e);
+  }
+}
+class G {
+  constructor(t, e) {
+    r(this, "ctx");
+    r(this, "workletNode");
+    r(this, "in");
+    r(this, "out");
+    this.ctx = t, this.workletNode = e, this.in = e, this.out = e;
+  }
+  /** Anti-formant centre frequency AudioParam (k-rate, 1000-10000 Hz) */
+  get F() {
+    return this.workletNode.parameters.get("F");
+  }
+  /** Anti-formant quality factor AudioParam (k-rate, 0.5-20) */
+  get Q() {
+    return this.workletNode.parameters.get("Q");
+  }
+  /**
+   * Creates a new AntiResonance node.
+   *
+   * The AudioWorklet module is registered automatically on first use.
+   */
+  static async create(t, e) {
+    await At(t);
+    const i = new AudioWorkletNode(t, "anti-resonance-processor"), s = new G(t, i);
+    return s.update(e), s;
+  }
+  /**
+   * Updates the anti-resonance parameters.
+   * Sets AudioParams via setTargetAtTime for smooth transitions.
+   */
+  update(t) {
+    this.F.setTargetAtTime(t.F, this.ctx.currentTime, 0.02), this.Q.setTargetAtTime(t.Q, this.ctx.currentTime, 0.02);
+  }
+  destroy() {
+    this.workletNode.disconnect();
+  }
+}
+class L {
+  constructor(t, e) {
+    r(this, "formantBank");
+    r(this, "antiResonance");
+    r(this, "in");
+    r(this, "out");
+    this.formantBank = t, this.antiResonance = e, this.in = t.in, this.out = e.out;
+  }
+  /**
+   * Creates a new VocalTract node.
+   *
+   * Sets up the parallel formant bank followed by the anti-resonance filter.
+   */
+  static async create(t, e) {
+    const [i, s] = await Promise.all([
+      j.create(t, { formants: e.formants }),
+      G.create(t, { F: e.F_BQ, Q: e.Q_BQ })
+    ]);
+    return i.out.connect(s.in), new L(i, s);
+  }
+  /**
+   * Updates all vocal tract parameters.
+   *
+   * @throws Error if the formants array length doesn't match the original
+   */
+  update(t) {
+    this.formantBank.update({ formants: t.formants }), this.antiResonance.update({ F: t.F_BQ, Q: t.Q_BQ });
+  }
+  /**
+   * Returns the number of formant resonators in the vocal tract.
+   */
+  get formantCount() {
+    return this.formantBank.count;
+  }
+  /**
+   * Returns the array of formant resonators for direct AudioParam access.
+   *
+   * Example usage:
+   *   vocalTract.formants[0].F.setValueAtTime(800, ctx.currentTime);
+   *   vocalTract.formants[2].B.linearRampToValueAtTime(100, ctx.currentTime + 0.1);
+   */
+  get formants() {
+    return this.formantBank.formants;
+  }
+  /**
+   * Returns the anti-resonance node for direct AudioParam access.
+   *
+   * Example usage:
+   *   vocalTract.antiResonanceNode.F.setValueAtTime(4500, ctx.currentTime);
+   *   vocalTract.antiResonanceNode.Q.setValueAtTime(3, ctx.currentTime);
+   */
+  get antiResonanceNode() {
+    return this.antiResonance;
+  }
+  destroy() {
+    this.formantBank.destroy(), this.antiResonance.destroy();
+  }
+}
+class E {
+  constructor(t, e, i) {
+    r(this, "glottalFlowDerivative");
+    r(this, "vocalTract");
+    r(this, "outputGainNode");
+    r(this, "in", null);
+    // Source node has no input
+    r(this, "out");
+    this.glottalFlowDerivative = t, this.vocalTract = e, this.outputGainNode = i, this.out = i.out;
+  }
+  /**
+   * Creates a new Voice synthesizer node.
+   *
+   * Sets up the complete source-filter synthesis pipeline.
+   */
+  static async create(t, e) {
+    const [i, s, n] = await Promise.all([
+      S.create(t, e),
+      L.create(t, e),
+      w.create(t, { gain: e.outputGain ?? 1 })
+    ]);
+    return i.out.connect(s.in), s.out.connect(n.in), new E(i, s, n);
+  }
+  /**
+   * Updates all voice parameters.
+   *
+   * @throws Error if the formants array length doesn't match the original
+   */
+  update(t) {
+    this.glottalFlowDerivative.update(t), this.vocalTract.update(t), t.outputGain !== void 0 && this.outputGainNode.update({ gain: t.outputGain });
+  }
+  /**
+   * Starts the voice (begins voiced excitation).
+   */
+  start() {
+    this.glottalFlowDerivative.start();
+  }
+  /**
+   * Stops the voice (stops voiced excitation).
+   * Note: Noise component continues based on An parameter.
+   */
+  stop() {
+    this.glottalFlowDerivative.stop();
+  }
+  /**
+   * Returns the number of formant resonators in the vocal tract.
+   */
+  get formantCount() {
+    return this.vocalTract.formantCount;
+  }
+  /**
+   * Returns the glottal flow derivative node for direct AudioParam access.
+   *
+   * Example usage:
+   *   voice.source.pulseTrainNode.f0.setValueAtTime(440, ctx.currentTime);
+   *   voice.source.glottalFormantNode.Ag.setTargetAtTime(0.5, ctx.currentTime, 0.1);
+   */
+  get source() {
+    return this.glottalFlowDerivative;
+  }
+  /**
+   * Returns the vocal tract node for direct AudioParam access.
+   *
+   * Example usage:
+   *   voice.tract.formants[0].F.linearRampToValueAtTime(800, ctx.currentTime + 0.1);
+   *   voice.tract.antiResonanceNode.F.setValueAtTime(4500, ctx.currentTime);
+   */
+  get tract() {
+    return this.vocalTract;
+  }
+  /**
+   * Returns the output gain node for direct AudioParam access.
+   *
+   * Example usage:
+   *   voice.outputGain.gain.linearRampToValueAtTime(0.5, ctx.currentTime + 1);
+   */
+  get outputGain() {
+    return this.outputGainNode;
+  }
+  destroy() {
+    this.glottalFlowDerivative.destroy(), this.vocalTract.destroy(), this.outputGainNode.destroy();
+  }
+}
+const p = [0, 0.5, 1], m = [0, 1 / 3, 2 / 3, 1], F = [
+  ["u", "y", "i"],
+  // H = 0
+  ["o", "œ", "e"],
+  // H = 1/3
+  ["ɔ", "ø", "ɛ"],
+  // H = 2/3
+  ["a", "a", "a"]
+  // H = 1 (all map to /a/)
+];
+function R(a) {
+  return qt.find((t) => t.ipa === a);
+}
+function B(a, t, e) {
+  return a + (t - a) * e;
+}
+function vt(a, t, e) {
+  return {
+    frequency: B(a.frequency, t.frequency, e),
+    amplitude: B(a.amplitude, t.amplitude, e),
+    bandwidth: B(a.bandwidth, t.bandwidth, e)
+  };
+}
+function x(a, t, e) {
+  return a.map((i, s) => vt(i, t[s], e));
+}
+function kt(a, t) {
+  a = Math.max(0, Math.min(1, a)), t = Math.max(0, Math.min(1, t));
+  let e = 0, i = 1;
+  for (let u = 0; u < m.length - 1; u++)
+    if (t >= m[u] && t <= m[u + 1]) {
+      e = u, i = u + 1;
+      break;
+    }
+  let s = 0, n = 1;
+  for (let u = 0; u < p.length - 1; u++)
+    if (a >= p[u] && a <= p[u + 1]) {
+      s = u, n = u + 1;
+      break;
+    }
+  const o = R(F[e][s]), c = R(F[e][n]), l = R(F[i][s]), A = R(F[i][n]), f = m[i] - m[e], b = p[n] - p[s], v = f > 0 ? (t - m[e]) / f : 0, d = b > 0 ? (a - p[s]) / b : 0, k = x(o.formants, c.formants, d), h = x(l.formants, A.formants, d);
+  return x(k, h, v);
+}
+const qt = [
+  {
+    ipa: "i",
+    v: 1,
+    h: 0,
+    formants: [
+      { frequency: 215, amplitude: -10, bandwidth: 10 },
+      { frequency: 1900, amplitude: -10, bandwidth: 18 },
+      { frequency: 2630, amplitude: -8, bandwidth: 20 },
+      { frequency: 3170, amplitude: -4, bandwidth: 30 },
+      { frequency: 3710, amplitude: -15, bandwidth: 40 },
+      { frequency: 6340, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "e",
+    v: 1,
+    h: 1 / 3,
+    formants: [
+      { frequency: 410, amplitude: -1, bandwidth: 10 },
+      { frequency: 2e3, amplitude: -3, bandwidth: 15 },
+      { frequency: 2570, amplitude: -2, bandwidth: 20 },
+      { frequency: 2980, amplitude: -2, bandwidth: 30 },
+      { frequency: 3900, amplitude: -5, bandwidth: 40 },
+      { frequency: 5960, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "ɛ",
+    v: 1,
+    h: 2 / 3,
+    formants: [
+      { frequency: 590, amplitude: 0, bandwidth: 10 },
+      { frequency: 1700, amplitude: -4, bandwidth: 15 },
+      { frequency: 2540, amplitude: -5, bandwidth: 30 },
+      { frequency: 2800, amplitude: -12, bandwidth: 50 },
+      { frequency: 3900, amplitude: -24, bandwidth: 40 },
+      { frequency: 5600, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "y",
+    v: 0.5,
+    h: 0,
+    formants: [
+      { frequency: 250, amplitude: -12, bandwidth: 10 },
+      { frequency: 1750, amplitude: -9, bandwidth: 10 },
+      { frequency: 2160, amplitude: -14, bandwidth: 20 },
+      { frequency: 3060, amplitude: -11, bandwidth: 30 },
+      { frequency: 3900, amplitude: -11, bandwidth: 40 },
+      { frequency: 6120, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "œ",
+    v: 0.5,
+    h: 1 / 3,
+    formants: [
+      { frequency: 350, amplitude: -6, bandwidth: 10 },
+      { frequency: 1350, amplitude: -3, bandwidth: 10 },
+      { frequency: 2250, amplitude: -8, bandwidth: 20 },
+      { frequency: 3170, amplitude: -8, bandwidth: 30 },
+      { frequency: 3900, amplitude: -10, bandwidth: 40 },
+      { frequency: 6340, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "ø",
+    v: 0.5,
+    h: 2 / 3,
+    formants: [
+      { frequency: 620, amplitude: -3, bandwidth: 10 },
+      { frequency: 1300, amplitude: -3, bandwidth: 10 },
+      { frequency: 2520, amplitude: -3, bandwidth: 20 },
+      { frequency: 3310, amplitude: -7, bandwidth: 30 },
+      { frequency: 3900, amplitude: -14, bandwidth: 40 },
+      { frequency: 6620, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "u",
+    v: 0,
+    h: 0,
+    formants: [
+      { frequency: 290, amplitude: -6, bandwidth: 10 },
+      { frequency: 750, amplitude: -8, bandwidth: 10 },
+      { frequency: 2300, amplitude: -13, bandwidth: 20 },
+      { frequency: 3080, amplitude: -8, bandwidth: 30 },
+      { frequency: 3900, amplitude: -9, bandwidth: 40 },
+      { frequency: 6160, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "o",
+    v: 0,
+    h: 1 / 3,
+    formants: [
+      { frequency: 440, amplitude: -6, bandwidth: 10 },
+      { frequency: 750, amplitude: -1, bandwidth: 12 },
+      { frequency: 2160, amplitude: -10, bandwidth: 20 },
+      { frequency: 2860, amplitude: -6, bandwidth: 30 },
+      { frequency: 3900, amplitude: -28, bandwidth: 40 },
+      { frequency: 5720, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "ɔ",
+    v: 0,
+    h: 2 / 3,
+    formants: [
+      { frequency: 610, amplitude: -3, bandwidth: 10 },
+      { frequency: 950, amplitude: 0, bandwidth: 12 },
+      { frequency: 2510, amplitude: -12, bandwidth: 20 },
+      { frequency: 2830, amplitude: -15, bandwidth: 30 },
+      { frequency: 3900, amplitude: -20, bandwidth: 40 },
+      { frequency: 5660, amplitude: -15, bandwidth: 150 }
+    ]
+  },
+  {
+    ipa: "a",
+    v: 0.5,
+    h: 1,
+    formants: [
+      { frequency: 700, amplitude: 0, bandwidth: 13 },
+      { frequency: 1200, amplitude: 0, bandwidth: 13 },
+      { frequency: 2500, amplitude: -5, bandwidth: 40 },
+      { frequency: 2800, amplitude: -7, bandwidth: 60 },
+      { frequency: 3600, amplitude: -24, bandwidth: 40 },
+      { frequency: 5600, amplitude: -15, bandwidth: 150 }
+    ]
+  }
+], Mt = {
+  harmonicCoincidenceAttenuation: !0,
+  formantFrequencyScaling: !0,
+  f1Tuning: !0,
+  f2Tuning: !0,
+  antiResonanceScaling: !0
+}, y = 0.2, H = 0.2, _ = 4700, Bt = 2.5;
+function xt(a) {
+  return 440 * Math.pow(2, (a - 69) / 12);
+}
+function Vt(a) {
+  return Math.pow(10, a / 20);
+}
+function Dt(a, t, e) {
+  const i = e === 1 ? 0.903 - 0.426 * t : 0.978 - 0.279 * t;
+  return a <= 0.5 ? Math.pow(10, -2 * (1 - i) * a) : Math.pow(10, 2 * i * (1 - a) - 1);
+}
+function Nt(a, t) {
+  const e = t === 1 ? 0.66 : 0.55;
+  return a <= 0.5 ? 0.5 + 2 * (e - 0.5) * a : 0.9 - 2 * (0.9 - e) * (1 - a);
+}
+function Pt(a, t, e) {
+  const i = Math.PI * (1 - e), s = Math.tan(Math.max(0.01, Math.min(Math.PI - 0.01, i)));
+  return a / (t * Math.abs(s));
+}
+function St(a, t) {
+  return t === 1 ? {
+    Tl1: 27 - 21 * a,
+    Tl2: 11 - 11 * a
+  } : {
+    Tl1: 45 - 36 * a,
+    Tl2: 20 - 18.5 * a
+  };
+}
+function Ct(a, t) {
+  return a <= y ? 0 : ((1 - H) * ((a - y) / (1 - y)) + H) / t;
+}
+function jt(a, t) {
+  return t > y ? a : 1.5 * t * a;
+}
+function Gt(a) {
+  return 1.7 * a + 0.5;
+}
+function Lt(a) {
+  return 125e-6 * a + 0.975;
+}
+function Ut(a, t, e) {
+  if (e >= 3)
+    return 0;
+  const i = 15 + 85 * ((a - 50) / 1450), s = [10, 15, 25][e], o = Math.round(t / a) * a, c = Math.abs(o - t);
+  return c < i ? (1 - c / i) * s : 0;
+}
+function Ot(a, t = {}) {
+  const e = { ...Mt, ...t }, {
+    pitch: i,
+    pitchOffset: s,
+    vocalEffort: n,
+    vowelHeight: o,
+    vowelBackness: c,
+    tenseness: l,
+    breathiness: A,
+    roughness: f,
+    vocalTractSize: b,
+    isFalsetto: v
+  } = a, d = v ? 2 : 1, k = s + 35 * i, h = xt(k), u = Dt(l, n, d), J = Nt(l, d), K = h / (2 * u), X = Pt(h, u, J), Y = Ct(n, u), { Tl1: Z, Tl2: tt } = St(n, d), et = jt(A, n), at = f * 0.3, it = f * 1, U = Gt(b), st = Lt(h), rt = kt(c, o).map((g, q) => {
+    const M = e.formantFrequencyScaling ? st * U : 1;
+    let T = M * g.frequency;
+    if (q === 0 && e.f1Tuning) {
+      const ct = M * g.frequency + 140 / (1 - y) * n - 70;
+      T = Math.max(h + 50, ct);
+    }
+    q === 1 && e.f2Tuning && (T = Math.max(2 * h + 50, M * g.frequency));
+    const ot = e.harmonicCoincidenceAttenuation ? Ut(h, T, q) : 0, ut = Vt(g.amplitude - ot);
+    return {
+      F: T,
+      B: g.bandwidth,
+      A: ut
+    };
+  }), nt = e.antiResonanceScaling ? _ * U : _;
+  return {
+    f0: h,
+    Fg: K,
+    Bg: X,
+    Ag: Y,
+    Tl1: Z,
+    Tl2: tt,
+    An: et,
+    jitterDepth: at,
+    shimmerDepth: it,
+    formants: rt,
+    F_BQ: nt,
+    Q_BQ: Bt
+  };
+}
+export {
+  G as AntiResonance,
+  j as FormantBank,
+  C as FormantResonator,
+  w as Gain,
+  S as GlottalFlowDerivative,
+  D as GlottalFormant,
+  P as NoiseSource,
+  V as PulseTrain,
+  N as SpectralTilt,
+  L as VocalTract,
+  E as Voice,
+  Ot as generateSynthParams,
+  kt as interpolateFormants,
+  qt as vowels
+};
+//# sourceMappingURL=index.js.map