@thi.ng/dsp 3.0.31 → 4.0.0

package/lib/index.js

@@ -1,1703 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var errors = require('@thi.ng/errors');
-var transducers = require('@thi.ng/transducers');
-var math = require('@thi.ng/math');
-var checks = require('@thi.ng/checks');
-var random = require('@thi.ng/random');
-
-class AGen {
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-    *[Symbol.iterator]() {
-        while (true)
-            yield this.next();
-    }
-    take(num, out = [], idx = 0) {
-        for (; --num >= 0;) {
-            out[idx++] = this.next();
-        }
-        return out;
-    }
-}
-
-function mapG(op, ...args) {
-    switch (args.length) {
-        case 2:
-            return new MapG1(op, args[0], args[1]);
-        case 3:
-            return new MapG2(op, args[0], args[1], args[2]);
-        case 4:
-            return new MapG3(op, args[0], args[1], args[2], args[3]);
-        case 5:
-            return new MapG4(op, args[0], args[1], args[2], args[3], args[4]);
-        default:
-            errors.illegalArity(args.length);
-    }
-}
-class MapG1 extends AGen {
-    constructor(_op, _a, init) {
-        super(init);
-        this._op = _op;
-        this._a = _a;
-    }
-    next() {
-        return (this._val = this._op(this._a.next(), this._val));
-    }
-}
-class MapG2 extends AGen {
-    constructor(_op, _a, _b, init) {
-        super(init);
-        this._op = _op;
-        this._a = _a;
-        this._b = _b;
-    }
-    next() {
-        return (this._val = this._op(this._a.next(), this._b.next(), this._val));
-    }
-}
-class MapG3 extends AGen {
-    constructor(_op, _a, _b, _c, init) {
-        super(init);
-        this._op = _op;
-        this._a = _a;
-        this._b = _b;
-        this._c = _c;
-    }
-    next() {
-        return (this._val = this._op(this._a.next(), this._b.next(), this._c.next(), this._val));
-    }
-}
-class MapG4 extends AGen {
-    constructor(_op, _a, _b, _c, _d, init) {
-        super(init);
-        this._op = _op;
-        this._a = _a;
-        this._b = _b;
-        this._c = _c;
-        this._d = _d;
-    }
-    next() {
-        return (this._val = this._op(this._a.next(), this._b.next(), this._c.next(), this._d.next(), this._val));
-    }
-}
-
-const addG = (step, start = 0) => new MapG1((a, b) => a + b, step, start - step.deref());
-
-class AProc {
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-    xform() {
-        return transducers.map((x) => this.next(x));
-    }
-}
-class AProc2 {
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-}
-
-function compP(...procs) {
-    const [a, b, c, d] = procs;
-    switch (procs.length) {
-        case 2:
-            return new CompP2(a, b);
-        case 3:
-            return new CompP3(a, b, c);
-        case 4:
-            return new CompP4(a, b, c, d);
-        default:
-            return new CompP(procs);
-    }
-}
-class CompP2 extends AProc {
-    constructor(_a, _b) {
-        super(null);
-        this._a = _a;
-        this._b = _b;
-    }
-    next(x) {
-        return (this._val = this._b.next(this._a.next(x)));
-    }
-}
-class CompP3 extends AProc {
-    constructor(_a, _b, _c) {
-        super(null);
-        this._a = _a;
-        this._b = _b;
-        this._c = _c;
-    }
-    next(x) {
-        return (this._val = this._c.next(this._b.next(this._a.next(x))));
-    }
-}
-class CompP4 extends AProc {
-    constructor(_a, _b, _c, _d) {
-        super(null);
-        this._a = _a;
-        this._b = _b;
-        this._c = _c;
-        this._d = _d;
-    }
-    next(x) {
-        return (this._val = this._d.next(this._c.next(this._b.next(this._a.next(x)))));
-    }
-}
-class CompP extends AProc {
-    constructor(_procs) {
-        super(null);
-        this._procs = _procs;
-    }
-    next(x) {
-        return (this._val = this._procs.reduce((x, p) => p.next(x), x));
-    }
-}
-
-function multiplex(...procs) {
-    return new Multiplex(procs);
-}
-class Multiplex extends AProc {
-    constructor(procs) {
-        super(procs.map((p) => p.deref()));
-        this._procs = procs;
-    }
-    next(x) {
-        return (this._val = this._procs.map((p) => p.next(x)));
-    }
-}
-
-function pipe(src, ...procs) {
-    let fn;
-    const [a, b, c, d] = procs;
-    switch (procs.length) {
-        case 1:
-            fn = (x) => a.next(x);
-            break;
-        case 2:
-            fn = (x) => b.next(a.next(x));
-            break;
-        case 3:
-            fn = (x) => c.next(b.next(a.next(x)));
-            break;
-        case 4:
-            fn = (x) => d.next(c.next(b.next(a.next(x))));
-            break;
-        default:
-            fn = (x) => procs.reduce((x, p) => p.next(x), x);
-    }
-    return new MapG1(fn, src, null);
-}
-
-function product(a, b, c) {
-    return c
-        ? new MapG3((a, b, c) => a * b * c, a, b, c, 0)
-        : new MapG2((a, b) => a * b, a, b, 0);
-}
-
-function sum(a, b, c) {
-    return c
-        ? new MapG3((a, b, c) => a + b + c, a, b, c, 0)
-        : new MapG2((a, b) => a + b, a, b, 0);
-}
-
-const add = (step, start, clamp) => new Add(step, start, clamp);
-class Add extends AGen {
-    constructor(_step = 1, _start = 0, _clamp) {
-        super(0);
-        this._step = _step;
-        this._start = _start;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    reset() {
-        this._val = this._start - this._step;
-        return this;
-    }
-    next() {
-        let v = this._val + this._step;
-        return (this._val =
-            this._clamp !== undefined
-                ? this._start < this._clamp
-                    ? Math.min(v, this._clamp)
-                    : Math.max(v, this._clamp)
-                : v);
-    }
-}
-
-const madd = (factor, start, offset, clamp) => new MAdd(factor, start, offset, clamp);
-class MAdd extends AGen {
-    constructor(_factor = 1, _start = 1, _offset = 0, _clamp) {
-        super(0);
-        this._factor = _factor;
-        this._start = _start;
-        this._offset = _offset;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    reset() {
-        this._val = (this._start - this._offset) / this._factor;
-        return this;
-    }
-    next() {
-        let v = this._val * this._factor + this._offset;
-        return (this._val =
-            this._clamp !== undefined
-                ? this._start < this._clamp
-                    ? Math.min(v, this._clamp)
-                    : Math.max(v, this._clamp)
-                : v);
-    }
-}
-
-const curve = (start, end, num, rate = 0.1, skipFirst = false, clampEnd = false) => {
-    const c = Math.exp(-Math.log((Math.abs(end - start) + rate) / rate) / num);
-    const offset = (start < end ? end + rate : end - rate) * (1 - c);
-    return new MAdd(c, skipFirst ? offset + start * c : start, offset, clampEnd ? end : undefined);
-};
-
-var EnvPhase;
-(function (EnvPhase) {
-    EnvPhase[EnvPhase["ATTACK"] = 0] = "ATTACK";
-    EnvPhase[EnvPhase["DECAY"] = 1] = "DECAY";
-    EnvPhase[EnvPhase["SUSTAIN"] = 2] = "SUSTAIN";
-    EnvPhase[EnvPhase["RELEASE"] = 3] = "RELEASE";
-    EnvPhase[EnvPhase["IDLE"] = 4] = "IDLE";
-})(EnvPhase || (EnvPhase = {}));
-const adsr = (opts) => new ADSR(opts);
-class ADSR extends AGen {
-    constructor(opts) {
-        super(0);
-        opts = Object.assign({ a: 0, d: 0, s: 1, r: 0, acurve: 0.1, dcurve: 0.001, slen: Infinity, gain: 1 }, opts);
-        this.setAttack(opts.a);
-        this.setDecay(opts.d);
-        this.setRelease(opts.r);
-        this.setSustain(opts.s, opts.slen);
-        this.setCurveA(opts.acurve);
-        this.setCurveD(opts.dcurve);
-        this.setGain(opts.gain);
-        this.reset();
-    }
-    reset() {
-        this._phase = 0 ;
-        this._curve = curve(0, 1, this._atime + 1, this._acurve, true);
-        this._val = 0;
-        return this;
-    }
-    release() {
-        if (this._phase < 3 ) {
-            this._phase = 3 ;
-            this._curve = curve(this._sustain, 0, this._rtime + 1, this._dcurve, true);
-        }
-    }
-    isSustained() {
-        return this._phase === 2 ;
-    }
-    isDone() {
-        return this._phase === 4 ;
-    }
-    next() {
-        let v;
-        switch (this._phase) {
-            case 4 :
-                return 0;
-            case 0 :
-                v = this._curve.next();
-                if (v >= 1) {
-                    v = 1;
-                    this._phase = 1 ;
-                    this._curve = curve(1, this._sustain, this._dtime + 1, this._dcurve, true);
-                }
-                break;
-            case 1 :
-                v = this._curve.next();
-                if (v <= this._sustain) {
-                    v = this._sustain;
-                    this._phase = 2 ;
-                    this._curve = add(1, 1);
-                }
-                break;
-            case 2 :
-                if (this._curve.next() >= this._speriod) {
-                    this.release();
-                }
-                return this._val;
-            case 3 :
-                v = this._curve.next();
-                if (v < 0) {
-                    v = 0;
-                    this._phase = 4 ;
-                }
-        }
-        return (this._val = v * this._gain);
-    }
-    setAttack(steps) {
-        this._atime = Math.max(steps, 0);
-    }
-    setDecay(steps) {
-        this._dtime = Math.max(steps, 0);
-    }
-    setRelease(steps) {
-        this._rtime = Math.max(steps, 0);
-    }
-    setSustain(level, duration) {
-        this._sustain = math.clamp01(level);
-        duration !== undefined && (this._speriod = duration);
-    }
-    setCurveA(ratio) {
-        this._acurve = Math.max(ratio, 1e-9);
-    }
-    setCurveD(ratio) {
-        this._dcurve = Math.max(ratio, 1e-9);
-    }
-    setGain(gain) {
-        this._gain = gain;
-    }
-}
-
-const alt = (n = 1) => new Alt(n, -n);
-const altT = (a, b) => new Alt(a, b);
-const altB = (x = true) => new Alt(x, !x);
-class Alt extends AGen {
-    constructor(_a, _b) {
-        super(_b);
-        this._a = _a;
-        this._b = _b;
-        this._flip = true;
-    }
-    reset() {
-        this._flip = true;
-        return this;
-    }
-    next() {
-        return (this._val = (this._flip = !this._flip) ? this._b : this._a);
-    }
-}
-
-const constant = (x) => new Const(x);
-class Const extends AGen {
-    next() {
-        return this._val;
-    }
-}
-
-const cosine = (freq, amp) => new Cosine(freq, amp);
-class Cosine extends AGen {
-    constructor(_freq, _amp = 1) {
-        super(0);
-        this._freq = _freq;
-        this._amp = _amp;
-        this.calcCoeffs();
-    }
-    reset() {
-        this.calcCoeffs();
-        return this;
-    }
-    next() {
-        const t = this._nxt * this._cos - this._val;
-        this._val = this._nxt;
-        this._nxt = t;
-        return this._val;
-    }
-    freq() {
-        return this._freq;
-    }
-    setFreq(freq) {
-        this._freq = freq;
-        this.calcCoeffs();
-    }
-    amp() {
-        return this._amp;
-    }
-    setAmp(amp) {
-        this._amp = amp;
-        this.calcCoeffs();
-    }
-    calcCoeffs() {
-        this._nxt = this._amp;
-        this._cos = Math.cos(this._freq * math.TAU) * 2;
-        this._val = this._cos * this._amp * 0.5;
-    }
-}
-
-const impulse = (on = 1) => new Impulse(on, 0);
-const impulseT = (on, off) => new Impulse(on, off);
-const impulseB = (start = true) => new Impulse(start, !start);
-class Impulse extends AGen {
-    constructor(_on, _off) {
-        super(_on);
-        this._on = _on;
-        this._off = _off;
-    }
-    reset() {
-        this._val = this._on;
-        return this;
-    }
-    next() {
-        const x = this._val;
-        this._val = this._off;
-        return x;
-    }
-}
-
-const impulseTrain = (period, start) => new ImpulseTrain(1, 0, period, start);
-const impulseTrainT = (on, off, period, start) => new ImpulseTrain(on, off, period, start);
-const impulseTrainB = (period, start) => new ImpulseTrain(true, false, period, start);
-class ImpulseTrain extends AGen {
-    constructor(_on, _off, _period, _pos = 0) {
-        super(_off);
-        this._on = _on;
-        this._off = _off;
-        this._period = _period;
-        this._pos = _pos;
-        this._startpos = --this._pos;
-    }
-    reset() {
-        this._val = this._off;
-        this._pos = this._startpos;
-        return this;
-    }
-    next() {
-        return (this._val =
-            ++this._pos >= this._period
-                ? ((this._pos = 0), this._on)
-                : this._off);
-    }
-}
-
-const iterable = (src, initial) => new $Iterable(src, initial);
-class $Iterable {
-    constructor(src, initial) {
-        this._iter = src[Symbol.iterator]();
-        this._val = initial;
-    }
-    deref() {
-        return this._val;
-    }
-    *[Symbol.iterator]() {
-        while (true)
-            yield this.next();
-    }
-    next() {
-        if (this._iter) {
-            const res = this._iter.next();
-            if (!res.done) {
-                this._val = res.value;
-            }
-            else {
-                this._iter = null;
-            }
-        }
-        return this._val;
-    }
-    take(num, out = [], idx = 0) {
-        for (; --num >= 0;) {
-            out[idx++] = this.next();
-        }
-        return out;
-    }
-}
-
-const line = (start = 0, end = 1, num = 10, skipFirst = false, clampEnd = false) => {
-    const dt = (end - start) / num;
-    return new Add(dt, skipFirst ? start + dt : start, clampEnd ? end : undefined);
-};
-
-const mul = (factor, start, clamp) => new Mul(factor, start, clamp);
-class Mul extends AGen {
-    constructor(_factor = 1, _start = 1, _clamp) {
-        super(0);
-        this._factor = _factor;
-        this._start = _start;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    reset() {
-        this._val = this._start / this._factor;
-        return this;
-    }
-    next() {
-        let v = this._val * this._factor;
-        return (this._val =
-            this._clamp !== undefined
-                ? this._start < this._clamp
-                    ? Math.min(v, this._clamp)
-                    : Math.max(v, this._clamp)
-                : v);
-    }
-}
-
-const osc = (osc, freq, amp, dc) => new Osc(osc, freq, amp, dc);
-const modOsc = (osc, freq, fmod, amod = 1) => new Osc(osc, sum(fmod, checks.isNumber(freq) ? add(freq) : freq), amod);
-class Osc extends AGen {
-    constructor(_osc, freq, amp = 1, _dc = 0) {
-        super(0);
-        this._osc = _osc;
-        this._dc = _dc;
-        this.setFreq(freq);
-        this.setAmp(amp);
-    }
-    next() {
-        return (this._val = this._osc(this._phase.next(), 1, this._amp.next(), this._dc));
-    }
-    setFreq(freq, phase = 0) {
-        this._phase = checks.isNumber(freq) ? new Add(freq, phase) : freq;
-    }
-    setAmp(amp) {
-        this._amp = checks.isNumber(amp) ? new Const(amp) : amp;
-    }
-}
-
-const AMP = [3.8024, 2.9694, 2.597, 3.087, 3.4006];
-const PROB = [0.00198, 0.0128, 0.049, 0.17, 0.682];
-const pinkNoise = (gain, rnd, amp, prob) => new PinkNoise(gain, rnd, amp, prob);
-class PinkNoise extends AGen {
-    constructor(_gain = 1, _rnd = random.SYSTEM, _amp = AMP, prob = PROB) {
-        super(0);
-        this._gain = _gain;
-        this._rnd = _rnd;
-        this._amp = _amp;
-        this._gain /= _amp.reduce((acc, x) => acc + x, 0);
-        this._psum = prob.reduce((acc, x, i) => (acc.push(i > 0 ? acc[i - 1] + x : x), acc), []);
-        this._bins = [0, 0, 0, 0, 0];
-    }
-    reset() {
-        this._bins.fill(0);
-        return this;
-    }
-    next() {
-        const { _bins, _rnd, _amp, _psum } = this;
-        const bin = _rnd.float();
-        for (let i = 0; i < 5; i++) {
-            if (bin <= _psum[i]) {
-                _bins[i] = _rnd.norm(_amp[i]);
-                break;
-            }
-        }
-        return (this._val =
-            this._gain *
-                (_bins[0] + _bins[1] + _bins[2] + _bins[3] + _bins[4]));
-    }
-}
-
-const reciprocal = (step) => new Reciprocal(step);
-class Reciprocal extends AGen {
-    constructor(_step = 1) {
-        super(1);
-        this._step = _step;
-        this.reset();
-    }
-    reset() {
-        this._n = 1 - this._step;
-        return this;
-    }
-    next() {
-        this._n += this._step;
-        return (this._val = 1 / this._n);
-    }
-}
-
-class SinCos extends AGen {
-    constructor(_freq, _amp = 1) {
-        super([0, _amp]);
-        this._freq = _freq;
-        this._amp = _amp;
-        this.calcCoeffs();
-    }
-    reset() {
-        this.calcCoeffs();
-        return this;
-    }
-    next() {
-        this._val = [this._s, this._c];
-        this._s += this._f * this._c;
-        this._c -= this._f * this._s;
-        return this._val;
-    }
-    freq() {
-        return this._freq;
-    }
-    setFreq(freq) {
-        this._freq = freq;
-        this.calcCoeffs();
-    }
-    amp() {
-        return this._amp;
-    }
-    setAmp(amp) {
-        this._amp = amp;
-        this.calcCoeffs();
-    }
-    calcCoeffs() {
-        this._f = math.TAU * this._freq;
-        this._s = 0;
-        this._c = this._amp;
-    }
-}
-
-const sweep = (start, end, steps, rate, clamp = true) => addG(curve(start, end, steps, rate, false, clamp));
-
-const whiteNoise = (gain, rnd) => new WhiteNoise(gain, rnd);
-class WhiteNoise extends AGen {
-    constructor(_gain = 1, _rnd = random.SYSTEM) {
-        super(0);
-        this._gain = _gain;
-        this._rnd = _rnd;
-    }
-    reset() {
-        return this;
-    }
-    next() {
-        return (this._val = this._rnd.norm(this._gain));
-    }
-}
-
-const allpass = (freq) => new AllPass1(freq);
-class AllPass1 extends AProc {
-    constructor(freq) {
-        super(0);
-        this.setFreq(freq);
-        this.reset();
-    }
-    reset() {
-        this._z1 = 0;
-        return this;
-    }
-    next(x) {
-        const { _coeff, _z1 } = this;
-        x -= _z1 * _coeff;
-        this._z1 = x;
-        return x * _coeff + _z1;
-    }
-    low(x) {
-        return (x + this.next(x)) * 0.5;
-    }
-    high(x) {
-        return (x - this.next(x)) * 0.5;
-    }
-    freq() {
-        return this._freq;
-    }
-    setFreq(freq) {
-        this._freq = math.clamp05(freq);
-        this._coeff = Math.tan(freq * math.PI - math.QUARTER_PI);
-    }
-}
-
-const normFreq = (f, fs) => f / fs;
-const freqRad = (f, fs) => (f / fs) * math.TAU;
-const freqMs = (f) => 1000 / f;
-const radFreq = (rad, fs) => (rad / math.TAU) * fs;
-const msFrames = (t, fs) => t * 0.001 * fs;
-const framesMs = (frames, fs) => (frames / fs) * 1000;
-const magDb = (x) => (20 * Math.log(x)) / Math.LN10;
-const dbMag = (x) => 10 ** (x / 20);
-
-const biquad = (type, fc, q, gain) => new Biquad(type, fc, q, gain);
-const biquadLP = (fc, q) => new Biquad("lp", fc, q);
-const biquadHP = (fc, q) => new Biquad("hp", fc, q);
-const biquadBP = (fc, q) => new Biquad("bp", fc, q);
-const biquadNotch = (fc, q) => new Biquad("notch", fc, q);
-const biquadPeak = (fc, q, gain = 6) => new Biquad("peak", fc, q, gain);
-const biquadLoShelf = (fc, gain = -6) => new Biquad("loshelf", fc, undefined, gain);
-const biquadHiShelf = (fc, gain = -6) => new Biquad("hishelf", fc, undefined, gain);
-class Biquad extends AProc {
-    constructor(_type, _freq, _q = math.SQRT2_2, _gain = 0) {
-        super(0);
-        this._type = _type;
-        this._freq = _freq;
-        this._q = _q;
-        this._gain = _gain;
-        this.reset();
-        this.calcCoeffs();
-    }
-    reset() {
-        this._z1 = this._z2 = this._val = 0;
-        return this;
-    }
-    next(x) {
-        const out = x * this._a0 + this._z1;
-        this._z1 = x * this._a1 + this._z2 - this._b1 * out;
-        this._z2 = x * this._a2 - this._b2 * out;
-        return (this._val = out);
-    }
-    freq() {
-        return this._freq;
-    }
-    q() {
-        return this._q;
-    }
-    gain() {
-        return this._gain;
-    }
-    set(fc, q, gain) {
-        this._freq = math.clamp05(fc);
-        this._q = q;
-        this._gain = gain;
-        this.calcCoeffs();
-    }
-    setFreq(fc) {
-        this._freq = math.clamp05(fc);
-        this.calcCoeffs();
-    }
-    setQ(q) {
-        this._q = q;
-        this.calcCoeffs();
-    }
-    setGain(g) {
-        this._gain = g;
-        this.calcCoeffs();
-    }
-    filterCoeffs() {
-        return {
-            zeroes: [this._a0, this._a1, this._a2],
-            poles: [1, this._b1, this._b2],
-        };
-    }
-    calcCoeffs() {
-        const k = Math.tan(math.PI * this._freq);
-        const k2 = k * k;
-        const k22 = 2 * (k2 - 1);
-        const kq = k / this._q;
-        const k2kqp1 = 1 + kq + k2;
-        const k2kqm1 = 1 - kq + k2;
-        const ksqrt2 = k * math.SQRT2;
-        const v = dbMag(Math.abs(this._gain));
-        const kvq = k * (v / this._q);
-        const ksqrt2v = k * Math.sqrt(2 * v);
-        let norm = 1 / k2kqp1;
-        switch (this._type) {
-            case "lp":
-                this._a0 = k2 * norm;
-                this._a1 = 2 * this._a0;
-                this._a2 = this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "hp":
-                this._a0 = norm;
-                this._a1 = -2 * this._a0;
-                this._a2 = this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "bp":
-                this._a0 = kq * norm;
-                this._a1 = 0;
-                this._a2 = -this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "notch":
-                this._a0 = (1 + k2) * norm;
-                this._a1 = k22 * norm;
-                this._a2 = this._a0;
-                this._b1 = this._a1;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "peak": {
-                const z1 = 1 + kvq + k2;
-                const z2 = 1 - kvq + k2;
-                if (this._gain >= 0) {
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = this._a1;
-                    this._b2 = k2kqm1 * norm;
-                }
-                else {
-                    norm = 1 / z1;
-                    this._a0 = k2kqp1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = k2kqm1 * norm;
-                    this._b1 = this._a1;
-                    this._b2 = z2 * norm;
-                }
-                break;
-            }
-            case "loshelf": {
-                const z1 = 1 + ksqrt2 + k2;
-                const z2 = 1 - ksqrt2 + k2;
-                const vk2 = v * k2;
-                const y1 = 1 + ksqrt2v + vk2;
-                const y2 = 1 - ksqrt2v + vk2;
-                const vk22 = 2 * (vk2 - 1);
-                if (this._gain >= 0) {
-                    norm = 1 / z1;
-                    this._a0 = y1 * norm;
-                    this._a1 = vk22 * norm;
-                    this._a2 = y2 * norm;
-                    this._b1 = k22 * norm;
-                    this._b2 = z2 * norm;
-                }
-                else {
-                    norm = 1 / y1;
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = vk22 * norm;
-                    this._b2 = y2 * norm;
-                }
-                break;
-            }
-            case "hishelf": {
-                const z1 = 1 + ksqrt2 + k2;
-                const z2 = 1 - ksqrt2 + k2;
-                const y1 = v + ksqrt2v + k2;
-                const y2 = v - ksqrt2v + k2;
-                const vk2 = 2 * (k2 - v);
-                if (this._gain >= 0) {
-                    norm = 1 / z1;
-                    this._a0 = y1 * norm;
-                    this._a1 = vk2 * norm;
-                    this._a2 = y2 * norm;
-                    this._b1 = k22 * norm;
-                    this._b2 = z2 * norm;
-                }
-                else {
-                    norm = 1 / y1;
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = vk2 * norm;
-                    this._b2 = y2 * norm;
-                }
-                break;
-            }
-            default:
-                errors.unsupported(`invalid filter type: ${this._type}`);
-        }
-    }
-}
-
-const onepoleLP = (fc) => new OnePole("lp", fc);
-const onepoleHP = (fc) => new OnePole("hp", fc);
-class OnePole extends AProc {
-    constructor(_type, _freq) {
-        super(0);
-        this._type = _type;
-        this._freq = _freq;
-        this.setFreq(_freq);
-    }
-    clear() {
-        this._val = 0;
-    }
-    reset() {
-        this.clear();
-        return this;
-    }
-    next(x) {
-        return (this._val = x * this._a0 + this._val * this._b1);
-    }
-    setFreq(fc) {
-        this._freq = fc = math.clamp05(fc);
-        if (this._type === "lp") {
-            this._b1 = Math.exp(-math.TAU * fc);
-            this._a0 = 1 - this._b1;
-        }
-        else {
-            this._b1 = -Math.exp(-math.TAU * (0.5 - fc));
-            this._a0 = 1 + this._b1;
-        }
-    }
-    filterCoeffs() {
-        return {
-            zeroes: [this._a0],
-            poles: [1, this._type === "lp" ? this._b1 : -this._b1],
-        };
-    }
-}
-
-const dcBlock = (freq) => new DCBlock("lp", freq);
-class DCBlock extends OnePole {
-    next(x) {
-        return x - super.next(x);
-    }
-}
-
-const delay = (n) => new Delay(n, 0);
-const delayT = (n, off) => new Delay(n, off);
-class Delay extends AProc {
-    constructor(n, _empty) {
-        super(checks.isFunction(_empty) ? _empty() : _empty);
-        this._empty = _empty;
-        this._wpos = n - 1;
-        this._rpos = 0;
-        this._buf = new Array(n);
-        this.clear();
-    }
-    get length() {
-        return this._buf.length;
-    }
-    clear() {
-        const { _buf, _empty } = this;
-        if (checks.isFunction(_empty)) {
-            for (let i = _buf.length; --i >= 0;) {
-                this._buf[i] = _empty();
-            }
-        }
-        else {
-            this._buf.fill(_empty);
-        }
-    }
-    reset() {
-        this.clear();
-        return this;
-    }
-    deref() {
-        return this._buf[this._rpos];
-    }
-    tap(t) {
-        return this._buf[math.wrap((t | 0) + this._wpos, 0, this._buf.length - 1)];
-    }
-    multiTap(t, out = []) {
-        for (let i = t.length; --i >= 0;) {
-            out[i] = this.tap(t[i]);
-        }
-        return out;
-    }
-    next(x) {
-        this.step();
-        this._buf[this._wpos] = x;
-        return x;
-    }
-    step() {
-        const n = this._buf.length;
-        ++this._wpos >= n && (this._wpos -= n);
-        ++this._rpos >= n && (this._rpos -= n);
-    }
-}
-
-const feedbackDelay = (n, feedback) => new FeedbackDelay(n, feedback);
-class FeedbackDelay extends Delay {
-    constructor(n, _feedback = 0.5) {
-        super(n, 0);
-        this._feedback = _feedback;
-        this.setFeedback(_feedback);
-    }
-    next(x) {
-        return super.next(x + this._buf[this._rpos] * this._feedback);
-    }
-    feedback() {
-        return this._feedback;
-    }
-    setFeedback(feedback) {
-        this._feedback = math.clamp01(feedback);
-    }
-}
-
-const foldback = (thresh, amp) => new Foldback(thresh, amp);
-class Foldback extends AProc {
-    constructor(_thresh = 1, _amp = 1 / _thresh) {
-        super(0);
-        this._thresh = _thresh;
-        this._amp = _amp;
-    }
-    next(x) {
-        return (this._val = math.foldback(this._thresh, x) * this._amp);
-    }
-    threshold() {
-        return this._thresh;
-    }
-    setThreshold(t) {
-        this._thresh = t;
-    }
-    amp() {
-        return this._amp;
-    }
-    setAmp(a) {
-        this._amp = a;
-    }
-}
-
-const integrator = (coeff, start) => new Integrator(coeff, start);
-class Integrator extends AProc {
-    constructor(_coeff = 1, _start = 0) {
-        super(_start);
-        this._coeff = _coeff;
-        this._start = _start;
-    }
-    reset() {
-        this._val = this._start;
-        return this;
-    }
-    next(x) {
-        return (this._val = this._val * this._coeff + x);
-    }
-    coeff() {
-        return this._coeff;
-    }
-    setCoeff(c) {
-        this._coeff = c;
-    }
-}
-
-class Mix extends AProc2 {
-    constructor(_t) {
-        super(0);
-        this._t = _t;
-    }
-    get mix() {
-        return this._t;
-    }
-    set mix(x) {
-        this._t = math.clamp01(x);
-    }
-    next(a, b) {
-        return (this._val = a + (b - a) * this._t);
-    }
-}
-
-const svfLP = (fc, q) => new SVF("lp", fc, q);
-const svfHP = (fc, q) => new SVF("hp", fc, q);
-const svfBP = (fc, q) => new SVF("bp", fc, q);
-const svfNotch = (fc, q) => new SVF("notch", fc, q);
-const svfPeak = (fc, q) => new SVF("peak", fc, q);
-const svfAllpass = (fc, q) => new SVF("all", fc, q);
-class SVF extends AProc {
-    constructor(_type, _freq, _q = 0.5) {
-        super(0);
-        this._type = _type;
-        this._freq = _freq;
-        this._q = _q;
-        this.reset();
-        this.computeCoeffs();
-    }
-    reset() {
-        this._c1 = this._c2 = this._val = 0;
-        return this;
-    }
-    next(x) {
-        const { _c1, _c2 } = this;
-        const x1 = this._a1 * _c1 + this._a2 * (x - _c2);
-        const x2 = _c2 + this._g * x1;
-        this._c1 = 2 * x1 - _c1;
-        this._c2 = 2 * x2 - _c2;
-        switch (this._type) {
-            case "lp":
-                return (this._val = x2);
-            case "hp":
-                return (this._val = x - this._k * x1 - x2);
-            case "bp":
-                return (this._val = x1);
-            case "notch":
-                return (this._val = x - this._k * x1);
-            case "peak":
-                return (this._val = 2 * x2 - x + this._k * x1);
-            case "all":
-                return (this._val = x - 2 * this._k * x1);
-        }
-    }
-    set(fc, q) {
-        this._freq = fc;
-        this._q = q;
-        this.computeCoeffs();
-    }
-    setFreq(fc) {
-        this._freq = fc;
-        this.computeCoeffs();
-    }
-    setQ(q) {
-        this._q = q;
-        this.computeCoeffs();
-    }
-    computeCoeffs() {
-        this._freq = math.clamp05(this._freq);
-        const g = (this._g = Math.tan(math.PI * this._freq));
-        this._k = 2 - 2 * this._q;
-        this._a1 = 1 / (1 + g * (g + this._k));
-        this._a2 = g * this._a1;
-    }
-}
-
-const waveShaper = (thresh, amp, map) => new WaveShaper(thresh, amp, map);
-class WaveShaper extends AProc {
-    constructor(_coeff = 3, amp = true, _map = waveshapeSigmoid) {
-        super(0);
-        this._coeff = _coeff;
-        this._map = _map;
-        amp === true ? this.setAutoGain() : this.setAmp(amp);
-    }
-    next(x) {
-        return (this._val = this._amp * this._map(x, this._coeff));
-    }
-    coeff() {
-        return this._coeff;
-    }
-    setCoeff(t) {
-        this._coeff = Math.max(t, 0);
-        this._autoGain && this.setAutoGain();
-    }
-    amp() {
-        return this._amp;
-    }
-    setAmp(a) {
-        this._amp = a;
-        this._autoGain = false;
-    }
-    setAutoGain() {
-        this._amp = 1 / this._map(1, this._coeff);
-        this._autoGain = true;
-    }
-}
-const waveshapeTan = (x, k) => Math.atan(k * x) / k;
-const waveshapeSigmoid = (x, k) => 2 / (1 + Math.exp(-k * x)) - 1;
-const waveshapeSin = (x, k) => Math.sin((math.PI / k) * x);
-
-const gibbs = (n, i) => Math.cos(((i - 1) * math.HALF_PI) / n) ** 2;
-const fejer = (k, n) => (n - k) / n;
-const polyBLEP = (dt, t) => t < dt
-    ? ((t /= dt), t + t - t * t - 1)
-    : t > 1 - dt
-        ? ((t = (t - 1) / dt), t * t + t + t + 1)
-        : 0;
-
-const sin$1 = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.sin(phase * freq * math.TAU);
-
-const additive = (osc, freqFn, ampFn, n) => {
-    const fcache = [];
-    const acache = [];
-    for (let i = 1; i <= n; i++) {
-        fcache.push(freqFn(i));
-        acache.push(ampFn(i));
-    }
-    return (phase, freq, amp = 1, dc = 0) => {
-        let y = 0;
-        for (let i = 0; i < n; i++) {
-            y += osc(phase, freq * fcache[i], acache[i]);
-        }
-        return dc + amp * y;
-    };
-};
-const squareAdditive = (n = 8) => additive(sin$1, (i) => 2 * (i - 1) + 1, (i) => (1 / (2 * (i - 1) + 1)) * gibbs(n, i), n);
-const sawAdditive = (n = 8) => additive(sin$1, (i) => i, (i) => (1 / i) * gibbs(n, i), n);
-
-const cos$1 = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.cos(phase * freq * math.TAU);
-
-const dsf = (phase, freq, amp = 1, dc = 0, alpha = 0.5, beta = 1) => {
-    const aa = alpha * alpha;
-    const a2 = 2 * alpha;
-    phase *= math.TAU * freq;
-    return (amp *
-        (((1 - aa) * Math.sin(phase)) /
-            (1 + aa - a2 * Math.cos(beta * phase))) +
-        dc);
-};
-const dsfHOF = (alpha = 0.5, beta = 1) => {
-    const aa = alpha * alpha;
-    const a2 = 2 * alpha;
-    return (phase, freq, amp = 1, dc = 0) => {
-        phase *= math.TAU * freq;
-        return (amp *
-            (((1 - aa) * Math.sin(phase)) /
-                (1 + aa - a2 * Math.cos(beta * phase))) +
-            dc);
-    };
-};
-
-const mixOsc = (osc1, osc2) => (phase, freq, amp = 1, dc = 0, t = 0.5) => math.mix(osc1(phase, freq, amp, dc), osc2(phase, freq, amp, dc), t);
-const mixOscHOF = (osc1, osc2, mix = 0.5) => (phase, freq, amp = 1, dc = 0) => math.mix(osc1(phase, freq, amp, dc), osc2(phase, freq, amp, dc), mix);
-
-const parabolic = (phase, freq, amp = 1, dc = 0) => dc + amp * (8 * (math.fract(phase * freq) - 0.5) ** 2 - 1);
-
-const rect = (phase, freq, amp = 1, dc = 0, duty = 0.5) => dc + amp * (math.fract(phase * freq) < duty ? 1 : -1);
-const rectHOF = (duty = 0.5) => (phase, freq, amp, dc) => rect(phase, freq, amp, dc, duty);
-
-const saw = (phase, freq, amp = 1, dc = 0) => dc + amp * (1 - 2 * math.fract(phase * freq));
-
-const tri = (phase, freq, amp = 1, dc = 0) => dc + amp * (Math.abs(math.fract(phase * freq) * 4 - 2) - 1);
-
-const wavetable = (table, interpolate = math.mix) => {
-    const n = table.length;
-    const n1 = n - 1;
-    return (phase, freq, amp = 1, dc = 0) => {
-        phase = math.fract(phase * freq) * n;
-        let i = phase | 0;
-        let j = i < n1 ? i + 1 : 0;
-        return dc + amp * interpolate(table[i], table[j], phase - i);
-    };
-};
-
-const isComplex = (buf) => !checks.isNumber(buf[0]);
-
-const integralT = (window) => {
-    let sum = 0;
-    for (let i = window.length; --i >= 0;) {
-        sum += window[i];
-    }
-    return sum;
-};
-const integralTSquared = (window) => {
-    let sum = 0;
-    for (let i = window.length; --i >= 0;) {
-        sum += window[i] ** 2;
-    }
-    return sum;
-};
-const integralF = ([real, img]) => {
-    let sum = 0;
-    for (let i = real.length; --i >= 0;) {
-        sum += Math.hypot(real[i], img[i]);
-    }
-    return sum;
-};
-const integralFSquared = ([real, img]) => {
-    let sum = 0;
-    for (let i = real.length; --i >= 0;) {
-        sum += real[i] ** 2 + img[i] ** 2;
-    }
-    return sum;
-};
-const powerScale = (scale, base = 1) => checks.isNumber(scale) ? scale : base / integralT(scale);
-const invPowerScale = (scale, base = 1) => checks.isNumber(scale) ? scale : integralT(scale) / base;
-const powerSumSquared = (window) => isComplex(window)
-    ? integralFSquared(window) / window[0].length
-    : integralTSquared(window);
-const powerMeanSquared = (window) => powerSumSquared(window) /
-    (isComplex(window) ? window[0].length : window.length);
-const powerTimeIntegral = (window, fs) => (isComplex(window) ? integralFSquared(window) : integralTSquared(window)) /
-    fs;
-
-const PI4 = 4 * math.PI;
-const PI6 = 6 * math.PI;
-const sin = Math.sin;
-const cos = Math.cos;
-const window = (fn, lenOfBuf) => {
-    const buf = checks.isNumber(lenOfBuf) ? new Float64Array(lenOfBuf) : lenOfBuf;
-    const n = buf.length - 1;
-    for (let i = 0; i <= n; i++) {
-        buf[i] = fn(i, n);
-    }
-    return buf;
-};
-const applyWindow = (signal, window, out = signal) => {
-    for (let i = signal.length; --i >= 0;) {
-        out[i] = signal[i] * window[i];
-    }
-    return out;
-};
-const windowRect = () => 1;
-const windowBartlett = (i, n) => 1 - Math.abs((i - n / 2) / (n / 2));
-const windowWelch = (i, n) => 1 - ((i - n / 2) / (n / 2)) ** 2;
-const windowSin = (i, n) => sin((math.PI * i) / n);
-const windowSinPow = (k) => (i, n) => sin((math.PI * i) / n) ** k;
-const windowLanczos = (i, n) => {
-    i = math.PI * ((2 * i) / n - 1);
-    return sin(i) / i;
-};
-const windowCosSum = (k) => {
-    let ik = 1 - k;
-    return (i, n) => k - ik * cos((math.TAU * i) / n);
-};
-const windowCosSum3 = (k1, k2, k3) => (i, n) => {
-    i /= n;
-    return k1 + k2 * cos(math.TAU * i) + k3 * cos(PI4 * i);
-};
-const windowCosSum4 = (k1, k2, k3, k4) => (i, n) => {
-    i /= n;
-    return k1 + k2 * cos(math.TAU * i) + k3 * cos(PI4 * i) + k4 * cos(PI6 * i);
-};
-const windowHann = windowCosSum(0.5);
-const windowHamming = windowCosSum(0.53836);
-const windowBlackman = windowCosSum3(0.42, -0.5, 0.08);
-const windowBlackmanHarris = windowCosSum4(0.35875, -0.48829, 0.14128, 0.01168);
-const windowNuttall = windowCosSum4(0.355768, -0.487396, 0.144232, -0.012604);
-const windowBlackmanNuttall = windowCosSum4(0.3635819, -0.4891775, 0.1365995, -0.0106411);
-const windowGauss = (a = 0.4) => (i, n) => {
-    n /= 2;
-    return Math.exp(-0.5 * ((i - n) / (a * n)) ** 2);
-};
-
-const complexArray = (n) => [
-    new Float64Array(n),
-    new Float64Array(n),
-];
-const copyComplex = (complex) => [
-    complex[0].slice(),
-    complex[1].slice(),
-];
-function conjugate(src, isImg = true) {
-    if (isComplex(src)) {
-        const n = src[0].length;
-        const res = complexArray(n * 2);
-        const [sreal, simg] = src;
-        const [dreal, dimg] = res;
-        dreal.set(sreal);
-        dimg.set(simg);
-        for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
-            dreal[j] = sreal[i];
-            dimg[j] = -simg[i];
-        }
-        return res;
-    }
-    else {
-        const n = src.length;
-        const dest = new Float64Array(n * 2);
-        dest.set(src);
-        for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
-            dest[j] = isImg ? -src[i] : src[i];
-        }
-        return dest;
-    }
-}
-const swapR = (real, n) => {
-    const n2 = n >> 1;
-    let ii;
-    let jj;
-    let k;
-    let t;
-    for (let i = 1, j = 1; i < n; i++) {
-        if (i < j) {
-            ii = i - 1;
-            jj = j - 1;
-            t = real[jj];
-            real[jj] = real[ii];
-            real[ii] = t;
-        }
-        k = n2;
-        while (k < j) {
-            j -= k;
-            k >>= 1;
-        }
-        j += k;
-    }
-};
-const swapRI = (real, img, n) => {
-    const n2 = n >> 1;
-    let ii;
-    let jj;
-    let k;
-    let t;
-    for (let i = 1, j = 1; i < n; i++) {
-        if (i < j) {
-            ii = i - 1;
-            jj = j - 1;
-            t = real[jj];
-            real[jj] = real[ii];
-            real[ii] = t;
-            t = img[jj];
-            img[jj] = img[ii];
-            img[ii] = t;
-        }
-        k = n2;
-        while (k < j) {
-            j -= k;
-            k >>= 1;
-        }
-        j += k;
-    }
-};
-const transform = (real, img, n) => {
-    let step = 1;
-    let prevStep;
-    let i, j, ii, ip;
-    let tr, ti;
-    let ur, ui;
-    let wr, wi;
-    let t;
-    for (let b = Math.ceil(Math.log2(n)); --b >= 0;) {
-        prevStep = step;
-        step <<= 1;
-        ur = 1;
-        ui = 0;
-        t = Math.PI / prevStep;
-        wr = Math.cos(t);
-        wi = -Math.sin(t);
-        for (j = 1; j <= prevStep; j++) {
-            for (i = j; i <= n; i += step) {
-                ip = i + prevStep - 1;
-                ii = i - 1;
-                tr = real[ip] * ur - img[ip] * ui;
-                ti = real[ip] * ui + img[ip] * ur;
-                real[ip] = real[ii] - tr;
-                img[ip] = img[ii] - ti;
-                real[ii] += tr;
-                img[ii] += ti;
-            }
-            t = ur;
-            ur = t * wr - ui * wi;
-            ui = t * wi + ui * wr;
-        }
-    }
-};
-const fft = (complex, window) => {
-    let real, img;
-    if (isComplex(complex)) {
-        real = complex[0];
-        img = complex[1];
-    }
-    else {
-        real = complex;
-    }
-    if (window) {
-        applyWindow(real, window);
-    }
-    const n = real.length;
-    if (img) {
-        swapRI(real, img, n);
-    }
-    else {
-        swapR(real, n);
-        img = new Float64Array(n);
-    }
-    transform(real, img, n);
-    return [real, img];
-};
-const ifft = (src) => {
-    let complex = isComplex(src)
-        ? src
-        : [new Float64Array(src.length), src];
-    fft([complex[1], complex[0]]);
-    return scaleFFT(complex, 1 / complex[0].length);
-};
-const scaleFFT = (complex, scale) => {
-    const [real, img] = complex;
-    const n = real.length;
-    for (let i = 0; i < n; i++) {
-        real[i] *= scale;
-        img[i] *= scale;
-    }
-    return [real, img];
-};
-const normalizeFFT = (complex, window = 2 / complex[0].length) => scaleFFT(complex, powerScale(window, 2));
-const denormalizeFFT = (complex, window = complex[0].length / 2) => scaleFFT(complex, invPowerScale(window, 2));
-const thresholdFFT = (complex, eps = 1e-12) => {
-    const [real, img] = complex;
-    for (let i = 0, n = real.length; i < n; i++) {
-        if (Math.hypot(real[i], img[i]) < eps) {
-            real[i] = img[i] = 0;
-        }
-    }
-    return complex;
-};
-const spectrumMag = (complex, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    for (let i = 0; i < n; i++) {
-        out[i] = Math.hypot(real[i], img[i]);
-    }
-    return out;
-};
-const spectrumPow = (complex, db = false, window = 2 / complex[0].length, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    const scale = powerScale(window, 2);
-    for (let i = 0; i < n; i++) {
-        const p = real[i] ** 2 + img[i] ** 2;
-        out[i] = db ? magDb(Math.sqrt(p) * scale) : p * scale;
-    }
-    return out;
-};
-const spectrumPhase = (complex, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    for (let i = 0; i < n; i++) {
-        out[i] = Math.atan2(img[i], real[i]);
-    }
-    return out;
-};
-const freqBin = (f, fs, n) => ((f * n) / fs) | 0;
-const binFreq = (bin, fs, n) => (bin * fs) / n;
-const fftFreq = (n, fs, m = n / 2) => {
-    const res = new Float64Array(m);
-    for (let i = 0; i <= m; i++) {
-        res[i] = binFreq(i, fs, n);
-    }
-    return res;
-};
-
-const filterResponseRaw = (zeroes, poles, freq, db = true) => {
-    const w0 = math.TAU * freq;
-    const [cp, sp] = convolve(poles, w0);
-    const [cz, sz] = convolve(zeroes, w0);
-    const mag = Math.sqrt((cz * cz + sz * sz) / (cp * cp + sp * sp));
-    const phase = Math.atan2(sp, cp) - Math.atan2(sz, cz);
-    return { freq, phase, mag: db ? magDb(mag) : mag };
-};
-const filterResponse = (coeffs, freq, db) => filterResponseRaw(coeffs.zeroes, coeffs.poles, freq, db);
-const freqRange = (fstart, fend, num) => line(fstart, fend, num - 1).take(num);
-const convolve = (coeffs, w0) => {
-    let c = 0;
-    let s = 0;
-    for (let i = coeffs.length; --i >= 0;) {
-        const k = math.cossin(w0 * i, coeffs[i]);
-        c += k[0];
-        s += k[1];
-    }
-    return [c, s];
-};
-
-exports.$Iterable = $Iterable;
-exports.ADSR = ADSR;
-exports.AGen = AGen;
-exports.AProc = AProc;
-exports.AProc2 = AProc2;
-exports.Add = Add;
-exports.AllPass1 = AllPass1;
-exports.Alt = Alt;
-exports.Biquad = Biquad;
-exports.CompP = CompP;
-exports.CompP2 = CompP2;
-exports.CompP3 = CompP3;
-exports.CompP4 = CompP4;
-exports.Const = Const;
-exports.Cosine = Cosine;
-exports.DCBlock = DCBlock;
-exports.Delay = Delay;
-exports.FeedbackDelay = FeedbackDelay;
-exports.Foldback = Foldback;
-exports.Impulse = Impulse;
-exports.ImpulseTrain = ImpulseTrain;
-exports.Integrator = Integrator;
-exports.MAdd = MAdd;
-exports.MapG1 = MapG1;
-exports.MapG2 = MapG2;
-exports.MapG3 = MapG3;
-exports.MapG4 = MapG4;
-exports.Mix = Mix;
-exports.Mul = Mul;
-exports.Multiplex = Multiplex;
-exports.OnePole = OnePole;
-exports.Osc = Osc;
-exports.PinkNoise = PinkNoise;
-exports.Reciprocal = Reciprocal;
-exports.SVF = SVF;
-exports.SinCos = SinCos;
-exports.WaveShaper = WaveShaper;
-exports.WhiteNoise = WhiteNoise;
-exports.add = add;
-exports.addG = addG;
-exports.additive = additive;
-exports.adsr = adsr;
-exports.allpass = allpass;
-exports.alt = alt;
-exports.altB = altB;
-exports.altT = altT;
-exports.applyWindow = applyWindow;
-exports.binFreq = binFreq;
-exports.biquad = biquad;
-exports.biquadBP = biquadBP;
-exports.biquadHP = biquadHP;
-exports.biquadHiShelf = biquadHiShelf;
-exports.biquadLP = biquadLP;
-exports.biquadLoShelf = biquadLoShelf;
-exports.biquadNotch = biquadNotch;
-exports.biquadPeak = biquadPeak;
-exports.compP = compP;
-exports.complexArray = complexArray;
-exports.conjugate = conjugate;
-exports.constant = constant;
-exports.copyComplex = copyComplex;
-exports.cos = cos$1;
-exports.cosine = cosine;
-exports.curve = curve;
-exports.dbMag = dbMag;
-exports.dcBlock = dcBlock;
-exports.delay = delay;
-exports.delayT = delayT;
-exports.denormalizeFFT = denormalizeFFT;
-exports.dsf = dsf;
-exports.dsfHOF = dsfHOF;
-exports.feedbackDelay = feedbackDelay;
-exports.fejer = fejer;
-exports.fft = fft;
-exports.fftFreq = fftFreq;
-exports.filterResponse = filterResponse;
-exports.filterResponseRaw = filterResponseRaw;
-exports.foldback = foldback;
-exports.framesMs = framesMs;
-exports.freqBin = freqBin;
-exports.freqMs = freqMs;
-exports.freqRad = freqRad;
-exports.freqRange = freqRange;
-exports.gibbs = gibbs;
-exports.ifft = ifft;
-exports.impulse = impulse;
-exports.impulseB = impulseB;
-exports.impulseT = impulseT;
-exports.impulseTrain = impulseTrain;
-exports.impulseTrainB = impulseTrainB;
-exports.impulseTrainT = impulseTrainT;
-exports.integralF = integralF;
-exports.integralFSquared = integralFSquared;
-exports.integralT = integralT;
-exports.integralTSquared = integralTSquared;
-exports.integrator = integrator;
-exports.invPowerScale = invPowerScale;
-exports.isComplex = isComplex;
-exports.iterable = iterable;
-exports.line = line;
-exports.madd = madd;
-exports.magDb = magDb;
-exports.mapG = mapG;
-exports.mixOsc = mixOsc;
-exports.mixOscHOF = mixOscHOF;
-exports.modOsc = modOsc;
-exports.msFrames = msFrames;
-exports.mul = mul;
-exports.multiplex = multiplex;
-exports.normFreq = normFreq;
-exports.normalizeFFT = normalizeFFT;
-exports.onepoleHP = onepoleHP;
-exports.onepoleLP = onepoleLP;
-exports.osc = osc;
-exports.parabolic = parabolic;
-exports.pinkNoise = pinkNoise;
-exports.pipe = pipe;
-exports.polyBLEP = polyBLEP;
-exports.powerMeanSquared = powerMeanSquared;
-exports.powerScale = powerScale;
-exports.powerSumSquared = powerSumSquared;
-exports.powerTimeIntegral = powerTimeIntegral;
-exports.product = product;
-exports.radFreq = radFreq;
-exports.reciprocal = reciprocal;
-exports.rect = rect;
-exports.rectHOF = rectHOF;
-exports.saw = saw;
-exports.sawAdditive = sawAdditive;
-exports.scaleFFT = scaleFFT;
-exports.sin = sin$1;
-exports.spectrumMag = spectrumMag;
-exports.spectrumPhase = spectrumPhase;
-exports.spectrumPow = spectrumPow;
-exports.squareAdditive = squareAdditive;
-exports.sum = sum;
-exports.svfAllpass = svfAllpass;
-exports.svfBP = svfBP;
-exports.svfHP = svfHP;
-exports.svfLP = svfLP;
-exports.svfNotch = svfNotch;
-exports.svfPeak = svfPeak;
-exports.sweep = sweep;
-exports.thresholdFFT = thresholdFFT;
-exports.tri = tri;
-exports.waveShaper = waveShaper;
-exports.waveshapeSigmoid = waveshapeSigmoid;
-exports.waveshapeSin = waveshapeSin;
-exports.waveshapeTan = waveshapeTan;
-exports.wavetable = wavetable;
-exports.whiteNoise = whiteNoise;
-exports.window = window;
-exports.windowBartlett = windowBartlett;
-exports.windowBlackman = windowBlackman;
-exports.windowBlackmanHarris = windowBlackmanHarris;
-exports.windowBlackmanNuttall = windowBlackmanNuttall;
-exports.windowGauss = windowGauss;
-exports.windowHamming = windowHamming;
-exports.windowHann = windowHann;
-exports.windowLanczos = windowLanczos;
-exports.windowNuttall = windowNuttall;
-exports.windowRect = windowRect;
-exports.windowSin = windowSin;
-exports.windowSinPow = windowSinPow;
-exports.windowWelch = windowWelch;