@thi.ng/dsp 4.6.16 → 4.6.18

package/foldback.js

@@ -1,38 +1,29 @@
 import { foldback as _foldback } from "@thi.ng/math/interval";
 import { AProc } from "./aproc.js";
-/**
- * Recursively folds input into `[-thresh .. +thresh]` interval and
- * amplifies it with `amp` (default: 1/thresh).
- *
- * @remarks
- * Reference:
- * - https://www.desmos.com/calculator/lkyf2ag3ta
- *
- * @param thresh - fold threshold
- * @param amp - post amplifier
- */
-export const foldback = (thresh, amp) => new Foldback(thresh, amp);
-export class Foldback extends AProc {
-    _thresh;
-    _amp;
-    constructor(_thresh = 1, _amp = 1 / _thresh) {
-        super(0);
-        this._thresh = _thresh;
-        this._amp = _amp;
-    }
-    next(x) {
-        return (this._val = _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 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 = _foldback(this._thresh, x) * this._amp;
+  }
+  threshold() {
+    return this._thresh;
+  }
+  setThreshold(t) {
+    this._thresh = t;
+  }
+  amp() {
+    return this._amp;
+  }
+  setAmp(a) {
+    this._amp = a;
+  }
 }
+export {
+  Foldback,
+  foldback
+};

package/impulse-train.js

@@ -1,39 +1,37 @@
 import { AGen } from "./agen.js";
-/**
- * https://en.wikipedia.org/wiki/Dirac_comb
- *
- * @param period -
- * @param start -
- */
-export const impulseTrain = (period, start) => new ImpulseTrain(1, 0, period, start);
-export const impulseTrainT = (on, off, period, start) => new ImpulseTrain(on, off, period, start);
-export const impulseTrainB = (period, start) => new ImpulseTrain(true, false, period, start);
-export class ImpulseTrain extends AGen {
-    _on;
-    _off;
-    _period;
-    _pos;
-    _startpos;
-    constructor(_on, _off, _period, _pos = 0) {
-        super(_off);
-        this._on = _on;
-        this._off = _off;
-        this._period = _period;
-        this._pos = _pos;
-        this._startpos = --this._pos;
-    }
-    copy() {
-        return new ImpulseTrain(this._on, this._off, this._period, this._startpos + 1);
-    }
-    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 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;
+  }
+  _startpos;
+  copy() {
+    return new ImpulseTrain(
+      this._on,
+      this._off,
+      this._period,
+      this._startpos + 1
+    );
+  }
+  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;
+  }
 }
+export {
+  ImpulseTrain,
+  impulseTrain,
+  impulseTrainB,
+  impulseTrainT
+};

package/impulse.js

@@ -1,44 +1,29 @@
 import { AGen } from "./agen.js";
-/**
- * Numeric version of {@link impulseT}, using given `on` (default: 1) as
- * initial value and zero for the remaining values.
- *
- * @param on -
- */
-export const impulse = (on = 1) => new Impulse(on, 0);
-/**
- * Creates a new impulse gen, producing a single `on` for the first
- * invocation of {@link IGen.next}, then only `off` thereafter.
- *
- * @param on - impulse value
- * @param off -
- */
-export const impulseT = (on, off) => new Impulse(on, off);
-/**
- * Boolean version of {@link impulseT}, using given `start` (default:
- * true) as initial value and its inverse for the remaining values.
- *
- * @param start -
- */
-export const impulseB = (start = true) => new Impulse(start, !start);
-export class Impulse extends AGen {
-    _on;
-    _off;
-    constructor(_on, _off) {
-        super(_on);
-        this._on = _on;
-        this._off = _off;
-    }
-    copy() {
-        return new Impulse(this._on, this._off);
-    }
-    reset() {
-        this._val = this._on;
-        return this;
-    }
-    next() {
-        const x = this._val;
-        this._val = this._off;
-        return x;
-    }
+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;
+  }
+  copy() {
+    return new Impulse(this._on, this._off);
+  }
+  reset() {
+    this._val = this._on;
+    return this;
+  }
+  next() {
+    const x = this._val;
+    this._val = this._off;
+    return x;
+  }
 }
+export {
+  Impulse,
+  impulse,
+  impulseB,
+  impulseT
+};

package/integrator.js

@@ -1,34 +1,29 @@
 import { AProc } from "./aproc.js";
-/**
- * Leaky integrator.
- *
- * https://en.wikipedia.org/wiki/Leaky_integrator
- *
- * @param coeff - leak (default: 1)
- */
-export const integrator = (coeff, start) => new Integrator(coeff, start);
-export class Integrator extends AProc {
-    _coeff;
-    _start;
-    constructor(_coeff = 1, _start = 0) {
-        super(_start);
-        this._coeff = _coeff;
-        this._start = _start;
-    }
-    copy() {
-        return new Integrator(this._coeff, this._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;
-    }
+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;
+  }
+  copy() {
+    return new Integrator(this._coeff, this._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;
+  }
 }
+export {
+  Integrator,
+  integrator
+};

package/internal/ensure.js

@@ -1,3 +1,6 @@
 import { isNumber } from "@thi.ng/checks/is-number";
 import { Const } from "../const.js";
-export const __ensureGenN = (x, clamp) => isNumber(x) ? new Const(clamp(x)) : x;
+const __ensureGenN = (x, clamp) => isNumber(x) ? new Const(clamp(x)) : x;
+export {
+  __ensureGenN
+};

package/internal/take.js

@@ -1,6 +1,9 @@
-export const __take = (src, num, out = [], idx = 0) => {
-    for (; num-- > 0;) {
-        out[idx++] = src.next();
-    }
-    return out;
+const __take = (src, num, out = [], idx = 0) => {
+  for (; num-- > 0; ) {
+    out[idx++] = src.next();
+  }
+  return out;
+};
+export {
+  __take
 };

package/iterable.js

@@ -1,46 +1,35 @@
 import { __take } from "./internal/take.js";
-/**
- * Wraps given ES6 iterable to provide full {@link IGen} implementation.
- *
- * @remarks
- * Calling `.next()` on this wrapped instance will always succeed, even if the
- * original iterable already is exhausted (in which case the last valid value
- * will be repeated ad infinitum).
- *
- * The `initial` value is required to satisfy `.deref()` and the case where the
- * iterable doesn't provide a single value.
- *
- * @param src -
- * @param initial -
- */
-export const iterable = (src, initial) => new $Iterable(src, initial);
-export class $Iterable {
-    _iter;
-    _val;
-    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) {
-        return __take(this, num, out, idx);
+const iterable = (src, initial) => new $Iterable(src, initial);
+class $Iterable {
+  _iter;
+  _val;
+  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) {
+    return __take(this, num, out, idx);
+  }
 }
+export {
+  $Iterable,
+  iterable
+};

package/line.js

@@ -1,27 +1,12 @@
 import { Add } from "./add.js";
-/**
- * Timebased version of {@link add}. Creates a new `Add` gen based on
- * given `start` (default: 0) and `end` (default: 1) positions and
- * tracing a line over `num` steps.
- *
- * @remarks
- * Unless `skipFirst` is true, the `end` value is only reached at `num +
- * 1` steps. The line will NOT stop at `end` but continue indefinitely
- * if more than `n + 1` values are requested from the generator.
- *
- * @example
- * ```ts
- * line(0, 1, 5).take(7)
- * // [ 0, 0.2, 0.4, 0.6, 0.8, 1, 1.2 ]
- * ```
- *
- * @param start - start value
- * @param end - end value
- * @param num - num steps (default: 10)
- * @param skipFirst - true to skip start value (default: false)
- * @param clampEnd - true to clamp curve at end value (default: false)
- */
-export 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 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 : void 0
+  );
+};
+export {
+  line
 };

package/madd.js

@@ -1,42 +1,27 @@
 import { AGen } from "./agen.js";
-/**
- * Returns new multiply-add gen producing `y(t) = factor * y(t-1) +
- * offset`. If `clamp` is given, the curve will be clamped at that
- * value.
- *
- * @param factor - default 1
- * @param start - default 1
- * @param offset - default 0
- * @param clamp - optional final value
- */
-export const madd = (factor, start, offset, clamp) => new MAdd(factor, start, offset, clamp);
-export class MAdd extends AGen {
-    _factor;
-    _start;
-    _offset;
-    _clamp;
-    constructor(_factor = 1, _start = 1, _offset = 0, _clamp) {
-        super(0);
-        this._factor = _factor;
-        this._start = _start;
-        this._offset = _offset;
-        this._clamp = _clamp;
-        this.reset();
-    }
-    copy() {
-        return new MAdd(this._factor, this._start, this._offset, this._clamp);
-    }
-    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 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();
+  }
+  copy() {
+    return new MAdd(this._factor, this._start, this._offset, this._clamp);
+  }
+  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 !== void 0 ? this._start < this._clamp ? Math.min(v, this._clamp) : Math.max(v, this._clamp) : v;
+  }
 }
+export {
+  MAdd,
+  madd
+};

package/mapg.js

@@ -1,76 +1,84 @@
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { AGen } from "./agen.js";
-export 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:
-            illegalArity(args.length);
-    }
+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:
+      illegalArity(args.length);
+  }
 }
-export class MapG1 extends AGen {
-    _op;
-    _a;
-    constructor(_op, _a, init) {
-        super(init);
-        this._op = _op;
-        this._a = _a;
-    }
-    next() {
-        return (this._val = this._op(this._a.next(), this._val));
-    }
+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);
+  }
 }
-export class MapG2 extends AGen {
-    _op;
-    _a;
-    _b;
-    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 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
+    );
+  }
 }
-export class MapG3 extends AGen {
-    _op;
-    _a;
-    _b;
-    _c;
-    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 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
+    );
+  }
 }
-export class MapG4 extends AGen {
-    _op;
-    _a;
-    _b;
-    _c;
-    _d;
-    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));
-    }
+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
+    );
+  }
 }
+export {
+  MapG1,
+  MapG2,
+  MapG3,
+  MapG4,
+  mapG
+};