@thi.ng/dsp 4.6.16 → 4.6.18

package/merge.js

@@ -1,23 +1,21 @@
 import { AGen } from "./agen.js";
 import {} from "./api.js";
-/**
- * Returns a new {@link IGen} which merges signals from multiple mono
- * {@link IGen}s into a multi-channel (e.g. stereo) tuples/values.
- *
- * @param channels
- */
-export const merge = (...channels) => new Merge(channels, 0);
-export const mergeT = (channels, init) => new Merge(channels, init);
-export class Merge extends AGen {
-    _channels;
-    constructor(_channels, init) {
-        super(new Array(_channels.length).fill(init));
-        this._channels = _channels;
-    }
-    channel(i) {
-        return this._channels[i];
-    }
-    next() {
-        return this._channels.map((x) => x.next());
-    }
+const merge = (...channels) => new Merge(channels, 0);
+const mergeT = (channels, init) => new Merge(channels, init);
+class Merge extends AGen {
+  constructor(_channels, init) {
+    super(new Array(_channels.length).fill(init));
+    this._channels = _channels;
+  }
+  channel(i) {
+    return this._channels[i];
+  }
+  next() {
+    return this._channels.map((x) => x.next());
+  }
 }
+export {
+  Merge,
+  merge,
+  mergeT
+};

package/mix.js

@@ -1,20 +1,24 @@
 import { clamp01 } from "@thi.ng/math/interval";
 import { AProc2 } from "./aproc.js";
 import { __ensureGenN } from "./internal/ensure.js";
-export const mix = (t) => new Mix(t);
-export class Mix extends AProc2 {
-    _t;
-    constructor(t = 0.5) {
-        super(0);
-        this.mix = t;
-    }
-    get mix() {
-        return this._t.deref();
-    }
-    set mix(t) {
-        this._t = __ensureGenN(t, clamp01);
-    }
-    next(a, b) {
-        return (this._val = a + (b - a) * this._t.next());
-    }
+const mix = (t) => new Mix(t);
+class Mix extends AProc2 {
+  _t;
+  constructor(t = 0.5) {
+    super(0);
+    this.mix = t;
+  }
+  get mix() {
+    return this._t.deref();
+  }
+  set mix(t) {
+    this._t = __ensureGenN(t, clamp01);
+  }
+  next(a, b) {
+    return this._val = a + (b - a) * this._t.next();
+  }
 }
+export {
+  Mix,
+  mix
+};

package/mul.js

@@ -1,40 +1,26 @@
 import { AGen } from "./agen.js";
-/**
- * Returns new multiply gen, producing `y(t) = factor * y(t-1)`, using
- * given `factor` and `start` values.
- *
- * Also see {@link exp}.
- *
- * @param factor -
- * @param start -
- * @param clamp -
- */
-export const mul = (factor, start, clamp) => new Mul(factor, start, clamp);
-export class Mul extends AGen {
-    _factor;
-    _start;
-    _clamp;
-    constructor(_factor = 1, _start = 1, _clamp) {
-        super(0);
-        this._factor = _factor;
-        this._start = _start;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    copy() {
-        return new Mul(this._factor, this._start, this._clamp);
-    }
-    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 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();
+  }
+  copy() {
+    return new Mul(this._factor, this._start, this._clamp);
+  }
+  reset() {
+    this._val = this._start / this._factor;
+    return this;
+  }
+  next() {
+    let v = this._val * this._factor;
+    return this._val = this._clamp !== void 0 ? this._start < this._clamp ? Math.min(v, this._clamp) : Math.max(v, this._clamp) : v;
+  }
 }
+export {
+  Mul,
+  mul
+};

package/multiplex.js

@@ -1,14 +1,18 @@
 import { AProc } from "./aproc.js";
-export function multiplex(...procs) {
-    return new Multiplex(procs);
+function multiplex(...procs) {
+  return new Multiplex(procs);
 }
-export class Multiplex extends AProc {
-    _procs;
-    constructor(procs) {
-        super(procs.map((p) => p.deref()));
-        this._procs = procs;
-    }
-    next(x) {
-        return (this._val = this._procs.map((p) => p.next(x)));
-    }
+class Multiplex extends AProc {
+  _procs;
+  constructor(procs) {
+    super(procs.map((p) => p.deref()));
+    this._procs = procs;
+  }
+  next(x) {
+    return this._val = this._procs.map((p) => p.next(x));
+  }
 }
+export {
+  Multiplex,
+  multiplex
+};

package/onepole.js

@@ -1,47 +1,46 @@
 import { TAU } from "@thi.ng/math/api";
 import { clamp05 } from "@thi.ng/math/interval";
 import { AProc } from "./aproc.js";
-export const onepoleLP = (fc) => new OnePole("lp", fc);
-export const onepoleHP = (fc) => new OnePole("hp", fc);
-/**
- * https://www.earlevel.com/main/2012/12/15/a-one-pole-filter/
- */
-export class OnePole extends AProc {
-    _type;
-    _freq;
-    _a0;
-    _b1;
-    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 = clamp05(fc);
-        if (this._type === "lp") {
-            this._b1 = Math.exp(-TAU * fc);
-            this._a0 = 1 - this._b1;
-        }
-        else {
-            this._b1 = -Math.exp(-TAU * (0.5 - fc));
-            this._a0 = 1 + this._b1;
-        }
-    }
-    filterCoeffs() {
-        return {
-            zeroes: [this._a0],
-            poles: [1, this._type === "lp" ? this._b1 : -this._b1],
-        };
+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);
+  }
+  _a0;
+  _b1;
+  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 = clamp05(fc);
+    if (this._type === "lp") {
+      this._b1 = Math.exp(-TAU * fc);
+      this._a0 = 1 - this._b1;
+    } else {
+      this._b1 = -Math.exp(-TAU * (0.5 - fc));
+      this._a0 = 1 + this._b1;
     }
+  }
+  filterCoeffs() {
+    return {
+      zeroes: [this._a0],
+      poles: [1, this._type === "lp" ? this._b1 : -this._b1]
+    };
+  }
 }
+export {
+  OnePole,
+  onepoleHP,
+  onepoleLP
+};

package/osc-additive.js

@@ -1,58 +1,30 @@
 import { identity } from "@thi.ng/api/fn";
 import { gibbs } from "./anti-alias.js";
 import { sin } from "./osc-sin.js";
-/**
- * Higher order function to produce an additive version of given
- * {@link StatelessOscillator}. Returns new oscillator function.
- *
- * @remarks
- * The `freqFn` and `ampFn` functions are used to compute respective frequency
- * and amplitude factors for each of the `n` requested harmonics (given in [i,n]
- * range).
- *
- * @param osc -
- * @param freqFn -
- * @param ampFn -
- * @param n -
- */
-export 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));
+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 (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;
-    };
+    return dc + amp * y;
+  };
+};
+const squareAdditive = (n = 8, useGibbs = true) => additive(
+  sin,
+  (i) => 2 * (i - 1) + 1,
+  (i) => 1 / (2 * (i - 1) + 1) * (useGibbs ? gibbs(n, i) : 1),
+  n
+);
+const sawAdditive = (n = 8, useGibbs = true) => additive(sin, identity, (i) => 1 / i * (useGibbs ? gibbs(n, i) : 1), n);
+export {
+  additive,
+  sawAdditive,
+  squareAdditive
 };
-/**
- * Returns a {@link StatelessOscillator} which constructs a square waveform from
- * `n` partials. If `useGibbs` is true (default), also applies {@link gibbs} to
- * each partial.
- *
- * @remarks
- * Interactive graph of this oscillator:
- * https://www.desmos.com/calculator/irugw6gnhy
- *
- * @param n - number of partials
- * @param useGibbs -
- */
-export const squareAdditive = (n = 8, useGibbs = true) => additive(sin, (i) => 2 * (i - 1) + 1, (i) => (1 / (2 * (i - 1) + 1)) * (useGibbs ? gibbs(n, i) : 1), n);
-/**
- * Returns a {@link StatelessOscillator} which constructs a sawtooth waveform
- * from `n` partials. If `useGibbs` is true (default), also applies
- * {@link gibbs} to each partial.
- *
- * @remarks
- * Interactive graph of this oscillator:
- * https://www.desmos.com/calculator/irugw6gnhy
- *
- * @param n - number of partials
- * @param useGibbs -
- */
-export const sawAdditive = (n = 8, useGibbs = true) => additive(sin, identity, (i) => (1 / i) * (useGibbs ? gibbs(n, i) : 1), n);

package/osc-cos.js

@@ -1,2 +1,5 @@
 import { TAU } from "@thi.ng/math/api";
-export const cos = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.cos(phase * freq * TAU);
+const cos = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.cos(phase * freq * TAU);
+export {
+  cos
+};

package/osc-dsf.js

@@ -1,56 +1,19 @@
 import { TAU } from "@thi.ng/math/api";
-/**
- * Oscillator using Discrete Summation Formula:
- *
- * `y(t) = (1-a^2) * sin(2πt) / (1 + a^2 - 2a * cos(b * 2πt))`
- *
- * @remarks
- * `alpha` should be in [0..1) interval, `beta` is used as factor for
- * the base `freq` and used for the cosine modulation term. The default
- * config for both params is 0.5, 1.0 respectively, creating a waveform
- * similar to a bandlimited sawtooth. If both params are zero, the
- * result is a pure sine.
- *
- * Note: Higher `alpha` values cause an increasing number (and
- * amplitude) of spikes in the waveform. Therefore, the higher the
- * `alpha`, the lower `amp` should be to avoid excessive out-of-range
- * values.
- *
- * References:
- * - https://www.desmos.com/calculator/klvl9oszfm
- * - https://ccrma.stanford.edu/files/papers/stanm5.pdf
- *
- * @param phase -
- * @param freq -
- * @param amp -
- * @param dc -
- * @param alpha -
- * @param beta -
- */
-export const dsf = (phase, freq, amp = 1, dc = 0, alpha = 0.5, beta = 1) => {
-    const aa = alpha * alpha;
-    const a2 = 2 * alpha;
+const dsf = (phase, freq, amp = 1, dc = 0, alpha = 0.5, beta = 1) => {
+  const aa = alpha * alpha;
+  const a2 = 2 * alpha;
+  phase *= 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 *= TAU * freq;
-    return (amp *
-        (((1 - aa) * Math.sin(phase)) /
-            (1 + aa - a2 * Math.cos(beta * phase))) +
-        dc);
+    return amp * ((1 - aa) * Math.sin(phase) / (1 + aa - a2 * Math.cos(beta * phase))) + dc;
+  };
 };
-/**
- * Higher order version of {@link dsf} oscillator with pre-configured
- * params. Slightly faster, but not dynamically changeable waveform.
- *
- * @param alpha -
- * @param beta -
- */
-export const dsfHOF = (alpha = 0.5, beta = 1) => {
-    const aa = alpha * alpha;
-    const a2 = 2 * alpha;
-    return (phase, freq, amp = 1, dc = 0) => {
-        phase *= TAU * freq;
-        return (amp *
-            (((1 - aa) * Math.sin(phase)) /
-                (1 + aa - a2 * Math.cos(beta * phase))) +
-            dc);
-    };
+export {
+  dsf,
+  dsfHOF
 };

package/osc-mix.js

@@ -1,21 +1,7 @@
 import { mix as _mix } from "@thi.ng/math/mix";
-/**
- * HOF oscillator. Takes 2 stateless oscillator fns and returns new
- * oscillator function which produces an interpolated result of both.
- * The returned function takes an additional `mix` arg ([0..1] range)
- * control contributions of either oscillator (default: 0.5 aka 50/50
- * ratio).
- *
- * @param osc1 -
- * @param osc2 -
- */
-export const mixOsc = (osc1, osc2) => (phase, freq, amp = 1, dc = 0, t = 0.5) => _mix(osc1(phase, freq, amp, dc), osc2(phase, freq, amp, dc), t);
-/**
- * Similar to {@link mixOsc}, but with `mix` arg ([0..1] range)
- * directly given to HOF and not changeable after.
- *
- * @param osc1 -
- * @param osc2 -
- * @param mix -
- */
-export const mixOscHOF = (osc1, osc2, mix = 0.5) => (phase, freq, amp = 1, dc = 0) => _mix(osc1(phase, freq, amp, dc), osc2(phase, freq, amp, dc), mix);
+const mixOsc = (osc1, osc2) => (phase, freq, amp = 1, dc = 0, t = 0.5) => _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) => _mix(osc1(phase, freq, amp, dc), osc2(phase, freq, amp, dc), mix);
+export {
+  mixOsc,
+  mixOscHOF
+};

package/osc-parabolic.js

@@ -1,14 +1,5 @@
 import { fract } from "@thi.ng/math/prec";
-/**
- * Parabolic waveform oscillator.
- *
- * @remarks
- * Reference:
- * - https://www.desmos.com/calculator/gsobpc8hsy
- *
- * @param phase -
- * @param freq -
- * @param amp -
- * @param dc -
- */
-export const parabolic = (phase, freq, amp = 1, dc = 0) => dc + amp * (8 * (fract(phase * freq) - 0.5) ** 2 - 1);
+const parabolic = (phase, freq, amp = 1, dc = 0) => dc + amp * (8 * (fract(phase * freq) - 0.5) ** 2 - 1);
+export {
+  parabolic
+};

package/osc-rect.js

@@ -1,9 +1,7 @@
 import { fract } from "@thi.ng/math/prec";
-export const rect = (phase, freq, amp = 1, dc = 0, duty = 0.5) => dc + amp * (fract(phase * freq) < duty ? 1 : -1);
-/**
- * Higher order version of {@link rect} with pre-configured `duty` width
- * (in the (0..1) range).
- *
- * @param duty -
- */
-export const rectHOF = (duty = 0.5) => (phase, freq, amp, dc) => rect(phase, freq, amp, dc, duty);
+const rect = (phase, freq, amp = 1, dc = 0, duty = 0.5) => dc + amp * (fract(phase * freq) < duty ? 1 : -1);
+const rectHOF = (duty = 0.5) => (phase, freq, amp, dc) => rect(phase, freq, amp, dc, duty);
+export {
+  rect,
+  rectHOF
+};

package/osc-saw.js

@@ -1,2 +1,5 @@
 import { fract } from "@thi.ng/math/prec";
-export const saw = (phase, freq, amp = 1, dc = 0) => dc + amp * (1 - 2 * fract(phase * freq));
+const saw = (phase, freq, amp = 1, dc = 0) => dc + amp * (1 - 2 * fract(phase * freq));
+export {
+  saw
+};

package/osc-sin.js

@@ -1,2 +1,5 @@
 import { TAU } from "@thi.ng/math/api";
-export const sin = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.sin(phase * freq * TAU);
+const sin = (phase, freq, amp = 1, dc = 0) => dc + amp * Math.sin(phase * freq * TAU);
+export {
+  sin
+};

package/osc-tri.js

@@ -1,2 +1,5 @@
 import { fract } from "@thi.ng/math/prec";
-export const tri = (phase, freq, amp = 1, dc = 0) => dc + amp * (Math.abs(fract(phase * freq) * 4 - 2) - 1);
+const tri = (phase, freq, amp = 1, dc = 0) => dc + amp * (Math.abs(fract(phase * freq) * 4 - 2) - 1);
+export {
+  tri
+};

package/osc-wavetable.js

@@ -1,12 +1,15 @@
 import { mix as _mix } from "@thi.ng/math/mix";
 import { fract } from "@thi.ng/math/prec";
-export const wavetable = (table, interpolate = _mix) => {
-    const n = table.length;
-    const n1 = n - 1;
-    return (phase, freq, amp = 1, dc = 0) => {
-        phase = 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 wavetable = (table, interpolate = _mix) => {
+  const n = table.length;
+  const n1 = n - 1;
+  return (phase, freq, amp = 1, dc = 0) => {
+    phase = 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);
+  };
+};
+export {
+  wavetable
 };