@thi.ng/dsp 4.6.16 → 4.6.17

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -84,7 +84,7 @@ For Node.js REPL:
 const dsp = await import("@thi.ng/dsp");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 7.74 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 7.52 KB
 
 ## Dependencies
 

package/add.js

@@ -1,40 +1,26 @@
 import { AGen } from "./agen.js";
-/**
- * Creates a new `Add` gen using given `step` (default: 1.0) and `start`
- * (default: 0.0) values, producing: `y(t) = step + y(t-1)`. If `clamp` is
- * given, the resulting output will be clamped to that value (min or max depends
- * on sign of `start - clamp`).
- *
- * @param step -
- * @param start -
- * @param clamp -
- */
-export const add = (step, start, clamp) => new Add(step, start, clamp);
-export class Add extends AGen {
-    _step;
-    _start;
-    _clamp;
-    constructor(_step = 1, _start = 0, _clamp) {
-        super(0);
-        this._step = _step;
-        this._start = _start;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    copy() {
-        return new Add(this._step, this._start, this._clamp);
-    }
-    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 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();
+  }
+  copy() {
+    return new Add(this._step, this._start, this._clamp);
+  }
+  reset() {
+    this._val = this._start - this._step;
+    return this;
+  }
+  next() {
+    let v = this._val + this._step;
+    return this._val = this._clamp !== void 0 ? this._start < this._clamp ? Math.min(v, this._clamp) : Math.max(v, this._clamp) : v;
+  }
 }
+export {
+  Add,
+  add
+};

package/addg.js

@@ -1,20 +1,5 @@
 import { MapG1 } from "./mapg.js";
-/**
- * Creates a new {@link IGen} using given `step` gen and `start
- * (default: 0) value, producing: `y(t) = step(t) + y(t-1)`.
- *
- * @remarks
- * Note this is different to {@link sum}, which merely sums given
- * argument gens for each step, but doesn't for a reduction like this
- * gen.
- *
- * @example
- * ```ts
- * addg(constant(1), 10).take(5)
- * // [ 10, 11, 12, 13, 14 ]
- * ```
- *
- * @param step -
- * @param start -
- */
-export const addG = (step, start = 0) => new MapG1((a, b) => a + b, step, start - step.deref());
+const addG = (step, start = 0) => new MapG1((a, b) => a + b, step, start - step.deref());
+export {
+  addG
+};

package/adsr.js

@@ -2,164 +2,156 @@ import { clamp01 } from "@thi.ng/math/interval";
 import { add } from "./add.js";
 import { AGen } from "./agen.js";
 import { curve } from "./curve.js";
-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 = {}));
-/**
- * Time based ADSR envelope gen with customizable exponential attack,
- * decay and release curves.
- *
- * @remarks
- * The attack, decay and release options are to be given in samples
- * (`num = time_in_seconds * sample_rate`). Unless the sustain length
- * (`slen` opt) is finite (default: ∞), the release phase of the
- * envelope MUST be triggered manually by calling {@link ADSR.release}.
- * If only attack & decay phases are required, initialize the sustain
- * level to zero and configure `dcurve` to adjust falloff shape.
- *
- * The envelope can be re-used & restarted by calling
- * {@link ADSR.reset}. This will move the internal state back to the
- * beginning of the attack phase and start producing a new envelope with
- * current settings. Note: Any changes done to the envelope parameters
- * are only guaranteed to be fully applied after reset.
- *
- * The `acurve` and `dcurve` options can be used to control the
- * exponential curvature of the attack, decay and release phases.
- * Recommended range [0.0001 - 100] (curved -> linear).
- *
- * @param opts -
- */
-export const adsr = (opts) => new ADSR(opts);
-export class ADSR extends AGen {
-    _phase;
-    _curve;
-    _atime;
-    _dtime;
-    _rtime;
-    _acurve;
-    _dcurve;
-    _sustain;
-    _speriod;
-    _gain;
-    constructor(opts) {
-        super(0);
-        opts = {
-            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();
+var EnvPhase = /* @__PURE__ */ ((EnvPhase2) => {
+  EnvPhase2[EnvPhase2["ATTACK"] = 0] = "ATTACK";
+  EnvPhase2[EnvPhase2["DECAY"] = 1] = "DECAY";
+  EnvPhase2[EnvPhase2["SUSTAIN"] = 2] = "SUSTAIN";
+  EnvPhase2[EnvPhase2["RELEASE"] = 3] = "RELEASE";
+  EnvPhase2[EnvPhase2["IDLE"] = 4] = "IDLE";
+  return EnvPhase2;
+})(EnvPhase || {});
+const adsr = (opts) => new ADSR(opts);
+class ADSR extends AGen {
+  _phase;
+  _curve;
+  _atime;
+  _dtime;
+  _rtime;
+  _acurve;
+  _dcurve;
+  _sustain;
+  _speriod;
+  _gain;
+  constructor(opts) {
+    super(0);
+    opts = {
+      a: 0,
+      d: 0,
+      s: 1,
+      r: 0,
+      acurve: 0.1,
+      dcurve: 1e-3,
+      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();
+  }
+  copy() {
+    return new ADSR({
+      a: this._atime,
+      d: this._dtime,
+      s: this._sustain,
+      r: this._rtime,
+      acurve: this._acurve,
+      dcurve: this._dcurve,
+      gain: this._gain,
+      slen: this._speriod
+    });
+  }
+  reset() {
+    this._phase = 0 /* ATTACK */;
+    this._curve = curve(0, 1, this._atime + 1, this._acurve, true);
+    this._val = 0;
+    return this;
+  }
+  release() {
+    if (this._phase < 3 /* RELEASE */) {
+      this._phase = 3 /* RELEASE */;
+      this._curve = curve(
+        this._sustain,
+        0,
+        this._rtime + 1,
+        this._dcurve,
+        true
+      );
     }
-    copy() {
-        return new ADSR({
-            a: this._atime,
-            d: this._dtime,
-            s: this._sustain,
-            r: this._rtime,
-            acurve: this._acurve,
-            dcurve: this._dcurve,
-            gain: this._gain,
-            slen: this._speriod,
-        });
-    }
-    reset() {
-        this._phase = EnvPhase.ATTACK;
-        this._curve = curve(0, 1, this._atime + 1, this._acurve, true);
-        this._val = 0;
-        return this;
-    }
-    release() {
-        if (this._phase < EnvPhase.RELEASE) {
-            this._phase = EnvPhase.RELEASE;
-            this._curve = curve(this._sustain, 0, this._rtime + 1, this._dcurve, true);
+  }
+  isSustained() {
+    return this._phase === 2 /* SUSTAIN */;
+  }
+  isDone() {
+    return this._phase === 4 /* IDLE */;
+  }
+  next() {
+    let v;
+    switch (this._phase) {
+      case 4 /* IDLE */:
+        return 0;
+      case 0 /* ATTACK */:
+        v = this._curve.next();
+        if (v >= 1) {
+          v = 1;
+          this._phase = 1 /* DECAY */;
+          this._curve = curve(
+            1,
+            this._sustain,
+            this._dtime + 1,
+            this._dcurve,
+            true
+          );
         }
-    }
-    isSustained() {
-        return this._phase === EnvPhase.SUSTAIN;
-    }
-    isDone() {
-        return this._phase === EnvPhase.IDLE;
-    }
-    next() {
-        let v;
-        switch (this._phase) {
-            case EnvPhase.IDLE:
-                return 0;
-            case EnvPhase.ATTACK:
-                v = this._curve.next();
-                if (v >= 1) {
-                    v = 1;
-                    this._phase = EnvPhase.DECAY;
-                    this._curve = curve(1, this._sustain, this._dtime + 1, this._dcurve, true);
-                }
-                break;
-            case EnvPhase.DECAY:
-                v = this._curve.next();
-                if (v <= this._sustain) {
-                    v = this._sustain;
-                    this._phase = EnvPhase.SUSTAIN;
-                    this._curve = add(1, 1);
-                }
-                break;
-            case EnvPhase.SUSTAIN:
-                if (this._curve.next() >= this._speriod) {
-                    this.release();
-                }
-                return this._val;
-            case EnvPhase.RELEASE:
-                v = this._curve.next();
-                if (v < 0) {
-                    v = 0;
-                    this._phase = EnvPhase.IDLE;
-                }
+        break;
+      case 1 /* DECAY */:
+        v = this._curve.next();
+        if (v <= this._sustain) {
+          v = this._sustain;
+          this._phase = 2 /* SUSTAIN */;
+          this._curve = add(1, 1);
+        }
+        break;
+      case 2 /* SUSTAIN */:
+        if (this._curve.next() >= this._speriod) {
+          this.release();
+        }
+        return this._val;
+      case 3 /* RELEASE */:
+        v = this._curve.next();
+        if (v < 0) {
+          v = 0;
+          this._phase = 4 /* IDLE */;
         }
-        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);
-    }
-    /**
-     * Sets sustain level & duration. If the latter is omitted, the
-     * current value will be retained.
-     *
-     * @param level -
-     * @param duration -
-     */
-    setSustain(level, duration) {
-        this._sustain = 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;
     }
+    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);
+  }
+  /**
+   * Sets sustain level & duration. If the latter is omitted, the
+   * current value will be retained.
+   *
+   * @param level -
+   * @param duration -
+   */
+  setSustain(level, duration) {
+    this._sustain = clamp01(level);
+    duration !== void 0 && (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;
+  }
 }
+export {
+  ADSR,
+  adsr
+};

package/agen.js

@@ -1,23 +1,19 @@
 import { __take } from "./internal/take.js";
-/**
- * Abstract base class for unit gens in this package. Provides
- * [`IDeref`](https://docs.thi.ng/umbrella/api/interfaces/IDeref.html) to obtain
- * the gen's current value and `Iterable` implementations to use gens as ES6
- * iterables.
- */
-export class AGen {
-    _val;
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-    *[Symbol.iterator]() {
-        while (true)
-            yield this.next();
-    }
-    take(num, out = [], idx = 0) {
-        return __take(this, num, out, idx);
-    }
+class AGen {
+  constructor(_val) {
+    this._val = _val;
+  }
+  deref() {
+    return this._val;
+  }
+  *[Symbol.iterator]() {
+    while (true)
+      yield this.next();
+  }
+  take(num, out = [], idx = 0) {
+    return __take(this, num, out, idx);
+  }
 }
+export {
+  AGen
+};

package/allpass.js

@@ -1,42 +1,41 @@
 import { PI, QUARTER_PI } from "@thi.ng/math/api";
 import { clamp05 } from "@thi.ng/math/interval";
 import { AProc } from "./aproc.js";
-/**
- * One-pole allpass filter.
- *
- * @param freq - normalized center freq
- */
-export const allpass = (freq) => new AllPass1(freq);
-export class AllPass1 extends AProc {
-    _freq;
-    _coeff;
-    _z1;
-    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 = clamp05(freq);
-        this._coeff = Math.tan(freq * PI - QUARTER_PI);
-    }
+const allpass = (freq) => new AllPass1(freq);
+class AllPass1 extends AProc {
+  _freq;
+  _coeff;
+  _z1;
+  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 = clamp05(freq);
+    this._coeff = Math.tan(freq * PI - QUARTER_PI);
+  }
 }
+export {
+  AllPass1,
+  allpass
+};

package/alt.js

@@ -1,24 +1,28 @@
 import { AGen } from "./agen.js";
-export const alt = (n = 1) => new Alt(n, -n);
-export const altT = (a, b) => new Alt(a, b);
-export const altB = (x = true) => new Alt(x, !x);
-export class Alt extends AGen {
-    _a;
-    _b;
-    _flip = true;
-    constructor(_a, _b) {
-        super(_b);
-        this._a = _a;
-        this._b = _b;
-    }
-    copy() {
-        return new Alt(this._a, this._b);
-    }
-    reset() {
-        this._flip = true;
-        return this;
-    }
-    next() {
-        return (this._val = (this._flip = !this._flip) ? this._b : this._a);
-    }
+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;
+  }
+  _flip = true;
+  copy() {
+    return new Alt(this._a, this._b);
+  }
+  reset() {
+    this._flip = true;
+    return this;
+  }
+  next() {
+    return this._val = (this._flip = !this._flip) ? this._b : this._a;
+  }
 }
+export {
+  Alt,
+  alt,
+  altB,
+  altT
+};

package/anti-alias.js

@@ -1,38 +1,9 @@
 import { HALF_PI } from "@thi.ng/math/api";
-/**
- * Reference:
- * - https://en.wikipedia.org/wiki/Gibbs_phenomenon
- * - https://web.archive.org/web/20031210115616/http://www.musicdsp.org/files/bandlimited.pdf
- *
- * [Interactive graph](https://www.desmos.com/calculator/irugw6gnhy)
- *
- * @param n - number of octaves
- * @param i - curr octave [1..n]
- */
-export const gibbs = (n, i) => Math.cos(((i - 1) * HALF_PI) / n) ** 2;
-/**
- * Fejér weight for `k`-th harmonic in a Fourier series of length `n`.
- *
- * @remarks
- * Used for attenuating the {@link gibbs} factor when summing a Fourier series.
- * Linearly attentuates higher harmonics, with the first bin receiving a weight
- * on 1 and the last bin `1/n`.
- *
- * @param k -
- * @param n -
- */
-export const fejer = (k, n) => (n - k) / n;
-/**
- * Polynomial attenuation to create bandlimited version of a signal.
- *
- * - http://research.spa.aalto.fi/publications/papers/smc2010-phaseshaping/
- * - http://www.kvraudio.com/forum/viewtopic.php?t=375517
- *
- * @param dt - time step
- * @param t - normalized phase
- */
-export 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 gibbs = (n, i) => Math.cos((i - 1) * 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;
+export {
+  fejer,
+  gibbs,
+  polyBLEP
+};

package/api.js

@@ -1 +0,0 @@
-export {};