@logue/reverb 1.2.16 → 1.3.0

package/README.md

@@ -87,6 +87,12 @@ sourceNode.connect(ctx.destination);
 sourceNode.play();
 ```
 
+### CDN Usage
+
+Not really intended for use with a CDN.
+
+The dependent libraries [@thi.ng/colored-noise](https://www.jsdelivr.com/package/npm/@thi.ng/colored-noise), [@thi.ng/random](https://www.jsdelivr.com/package/npm/@thi.ng/random) and [@thi.ng/transducers](https://www.jsdelivr.com/package/npm/@thi.ng/transducers) need to be loaded separately.
+
 ## Reference
 
 - [Web Audio API](https://www.w3.org/TR/webaudio/)

package/dist/Reverb.d.ts

@@ -131,7 +131,7 @@ export default class Reverb {
      * @param min - Minimum value
      * @param max - Maximum value
      */
-    private inRange;
+    private static inRange;
     /** Utility function for building an impulse response from the module parameters. */
     private buildImpulse;
     /**

package/dist/Reverb.es.js

@@ -5,13 +5,59 @@
  * @author Logue <logue@hotmail.co.jp>
  * @copyright 2019-2023 By Masashi Yoshikawa All rights reserved.
  * @license MIT
- * @version 1.2.16
+ * @version 1.3.0
  * @see {@link https://github.com/logue/Reverb.js}
  */
 
-import { SYSTEM } from '@thi.ng/random';
-import { white, violet, red, pink, green, blue } from '@thi.ng/colored-noise';
-import { take } from '@thi.ng/transducers';
+const INV_MAX = 1 / 2 ** 32;
+class ARandom {
+    float(norm = 1) {
+        return this.int() * INV_MAX * norm;
+    }
+    probability(p) {
+        return this.float() < p;
+    }
+    norm(norm = 1) {
+        return (this.int() * INV_MAX - 0.5) * 2 * norm;
+    }
+    normMinMax(min, max) {
+        const x = this.minmax(min, max);
+        return this.float() < 0.5 ? x : -x;
+    }
+    minmax(min, max) {
+        return this.float() * (max - min) + min;
+    }
+    minmaxInt(min, max) {
+        min |= 0;
+        return min + (this.int() % ((max | 0) - min));
+    }
+    minmaxUint(min, max) {
+        min >>>= 0;
+        return min + (this.int() % ((max >>> 0) - min));
+    }
+}
+
+const random = Math.random;
+/**
+ * A `Math.random()` based {@link IRandom} implementation. Also @see
+ * {@link SYSTEM}.
+ */
+class SystemRandom extends ARandom {
+    int() {
+        return (random() * 4294967296) /* 2**32 */ >>> 0;
+    }
+    float(norm = 1) {
+        return random() * norm;
+    }
+    norm(norm = 1) {
+        return (random() - 0.5) * 2 * norm;
+    }
+}
+/**
+ * Used as default PRNG throughout most other thi.ng projects, though usually is
+ * configurable.
+ */
+const SYSTEM = new SystemRandom();
 
 const defaults = {
   noise: "white",
@@ -29,9 +75,9 @@ const defaults = {
   once: false
 };
 
-const meta = {
-  version: "1.2.16",
-  date: "2023-07-21T03:58:24.313Z"
+const Meta = {
+  version: "1.3.0",
+  date: "2023-08-16T23:12:28.774Z"
 };
 
 const Noise = {
@@ -51,11 +97,252 @@ const Noise = {
   white: "white"
 };
 
+const DEFAULT_OPTS = {
+    bins: 2,
+    scale: 1,
+    rnd: SYSTEM,
+};
+
+const preseed = (n, scale, rnd) => {
+    const state = new Array(n);
+    for (let i = 0; i < n; i++) {
+        state[i] = rnd.norm(scale);
+    }
+    return state;
+};
+const sum = (src) => src.reduce((sum, x) => sum + x, 0);
+function* interleave(a, b) {
+    const src = [a[Symbol.iterator](), b[Symbol.iterator]()];
+    for (let i = 0; true; i ^= 1) {
+        const next = src[i].next();
+        if (next.done)
+            return;
+        yield next.value;
+    }
+}
+
+/**
+ * High-pass filtered noise. Opposite of {@link red}.
+ *
+ * @param opts -
+ */
+function* blue(opts) {
+    const { bins, scale, rnd } = {
+        ...DEFAULT_OPTS,
+        ...opts,
+    };
+    const state = preseed(bins, scale, rnd);
+    state.forEach((x, i) => (state[i] = i & 1 ? x : -x));
+    const invN = 1 / bins;
+    let acc = sum(state);
+    for (let i = 0, sign = -1; true; ++i >= bins && (i = 0)) {
+        acc -= state[i];
+        acc += state[i] = sign * rnd.norm(scale);
+        sign ^= 0xfffffffe;
+        yield sign * acc * invN;
+    }
+}
+
+/**
+ * Band-pass filtered noise (interleaved blue noise). Opposite of
+ * {@link violet}.
+ *
+ * @param opts -
+ */
+const green = (opts) => interleave(blue(opts), blue(opts));
+
+/**
+ * Returns number of 1 bits in `x`.
+ *
+ * @param x -
+ */
+const ctz32 = (x) => {
+    let c = 32;
+    x &= -x;
+    x && c--;
+    x & 0x0000ffff && (c -= 16);
+    x & 0x00ff00ff && (c -= 8);
+    x & 0x0f0f0f0f && (c -= 4);
+    x & 0x33333333 && (c -= 2);
+    x & 0x55555555 && (c -= 1);
+    return c;
+};
+
+/**
+ * Exponential decay (1/f) noise, based on Voss-McCarthy algorithm.
+ *
+ * @remarks
+ * The number of internal states should be in the [4..32] range (default: 8).
+ * Due to JS integer limitations, `n` > 32 are meaningless.
+ *
+ * References:
+ *
+ * - https://www.dsprelated.com/showarticle/908.php
+ * - https://www.firstpr.com.au/dsp/pink-noise/#Voss-McCartney
+ *
+ * @param opts -
+ */
+function* pink(opts) {
+    const { bins, scale, rnd } = {
+        ...DEFAULT_OPTS,
+        bins: 8,
+        ...opts,
+    };
+    const state = preseed(bins, scale, rnd);
+    const invN = 1 / bins;
+    let acc = sum(state);
+    for (let i = 0; true; i = (i + 1) >>> 0) {
+        const id = ctz32(i) % bins;
+        acc -= state[id];
+        acc += state[id] = rnd.norm(scale);
+        yield acc * invN;
+    }
+}
+
+/**
+ * Low-pass filtered noise (same as brown noise). Opposite of {@link blue}.
+ *
+ * @param opts -
+ */
+function* red(opts) {
+    const { bins, scale, rnd } = {
+        ...DEFAULT_OPTS,
+        ...opts,
+    };
+    const state = preseed(bins, scale, rnd);
+    const invN = 1 / bins;
+    let acc = sum(state);
+    for (let i = 0; true; ++i >= bins && (i = 0)) {
+        acc -= state[i];
+        acc += state[i] = rnd.norm(scale);
+        yield acc * invN;
+    }
+}
+
+/**
+ * Band-stop filtered noise (interleaved red noise). Opposite of {@link green}.
+ *
+ * @param opts -
+ */
+const violet = (opts) => interleave(red(opts), red(opts));
+
+/**
+ * Unfiltered noise w/ uniform distribution. Merely yields samples from
+ * given PRNG.
+ *
+ * @param opts -
+ */
+function* white(opts) {
+    const { scale, rnd } = { ...DEFAULT_OPTS, ...opts };
+    while (true) {
+        yield rnd.norm(scale);
+    }
+}
+
+const implementsFunction = (x, fn) => x != null && typeof x[fn] === "function";
+
+const ensureTransducer = (x) => implementsFunction(x, "xform") ? x.xform() : x;
+
+const isIterable = (x) => x != null && typeof x[Symbol.iterator] === "function";
+
+class Reduced {
+    constructor(val) {
+        this.value = val;
+    }
+    deref() {
+        return this.value;
+    }
+}
+const reduced = (x) => new Reduced(x);
+const isReduced = (x) => x instanceof Reduced;
+const ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
+const unreduced = (x) => (x instanceof Reduced ? x.deref() : x);
+
+/**
+ * Convenience helper for building a full {@link Reducer} using the identity
+ * function (i.e. `(x) => x`) as completion step (true for 90% of all
+ * bundled transducers).
+ *
+ * @param init - init step of reducer
+ * @param rfn - reduction step of reducer
+ */
+const reducer = (init, rfn) => [init, (acc) => acc, rfn];
+
+function push(xs) {
+    return xs
+        ? [...xs]
+        : reducer(() => [], (acc, x) => (acc.push(x), acc));
+}
+
+/**
+ * Takes a transducer and input iterable. Returns iterator of
+ * transformed results.
+ *
+ * @param xform -
+ * @param xs -
+ */
+function* iterator(xform, xs) {
+    const rfn = ensureTransducer(xform)(push());
+    const complete = rfn[1];
+    const reduce = rfn[2];
+    for (let x of xs) {
+        const y = reduce([], x);
+        if (isReduced(y)) {
+            yield* unreduced(complete(y.deref()));
+            return;
+        }
+        if (y.length) {
+            yield* y;
+        }
+    }
+    yield* unreduced(complete([]));
+}
+
+/**
+ * Reducer composition helper, internally used by various transducers
+ * during initialization. Takes existing reducer `rfn` (a 3-tuple) and a
+ * reducing function `fn`. Returns a new reducer tuple.
+ *
+ * @remarks
+ * `rfn[2]` reduces values of type `B` into an accumulator of type `A`.
+ * `fn` accepts values of type `C` and produces interim results of type
+ * `B`, which are then (possibly) passed to the "inner" `rfn[2]`
+ * function. Therefore the resulting reducer takes inputs of `C` and an
+ * accumulator of type `A`.
+ *
+ * It is assumed that `fn` internally calls `rfn[2]` to pass its own
+ * results for further processing by the nested reducer `rfn`.
+ *
+ * @example
+ * ```ts
+ * compR(rfn, fn)
+ * // [rfn[0], rfn[1], fn]
+ * ```
+ *
+ * @param rfn -
+ * @param fn -
+ */
+const compR = (rfn, fn) => [rfn[0], rfn[1], fn];
+
+function take(n, src) {
+    return isIterable(src)
+        ? iterator(take(n), src)
+        : (rfn) => {
+            const r = rfn[2];
+            let m = n;
+            return compR(rfn, (acc, x) => --m > 0
+                ? r(acc, x)
+                : m === 0
+                    ? ensureReduced(r(acc, x))
+                    : reduced(acc));
+        };
+}
+
 class Reverb {
   /** Version strings */
-  static version = meta.version;
+  static version = Meta.version;
   /** Build date */
-  static build = meta.date;
+  static build = Meta.date;
   /** AudioContext */
   ctx;
   /** Wet Level (Reverberated node) */
@@ -131,7 +418,7 @@ class Reverb {
    * @param mix - Ratio (0~1)
    */
   mix(mix) {
-    if (!this.inRange(mix, 0, 1)) {
+    if (!Reverb.inRange(mix, 0, 1)) {
       throw new RangeError("[Reverb.js] Dry/Wet ratio must be between 0 to 1.");
     }
     this.options.mix = mix;
@@ -144,7 +431,7 @@ class Reverb {
    * @param value - IR length
    */
   time(value) {
-    if (!this.inRange(value, 1, 50)) {
+    if (!Reverb.inRange(value, 1, 50)) {
       throw new RangeError(
         "[Reverb.js] Time length of inpulse response must be less than 50sec."
       );
@@ -158,7 +445,7 @@ class Reverb {
    * @param value - Decay value
    */
   decay(value) {
-    if (!this.inRange(value, 0, 100)) {
+    if (!Reverb.inRange(value, 0, 100)) {
       throw new RangeError(
         "[Reverb.js] Inpulse Response decay level must be less than 100."
       );
@@ -172,7 +459,7 @@ class Reverb {
    * @param value - Time[ms]
    */
   delay(value) {
-    if (!this.inRange(value, 0, 100)) {
+    if (!Reverb.inRange(value, 0, 100)) {
       throw new RangeError(
         "[Reverb.js] Inpulse Response delay time must be less than 100."
       );
@@ -203,7 +490,7 @@ class Reverb {
    * @param freq - Frequency
    */
   filterFreq(freq) {
-    if (!this.inRange(freq, 20, 2e4)) {
+    if (!Reverb.inRange(freq, 20, 2e4)) {
       throw new RangeError(
         "[Reverb.js] Filter frequrncy must be between 20 and 20000."
       );
@@ -217,7 +504,7 @@ class Reverb {
    * @param q - Quality
    */
   filterQ(q) {
-    if (!this.inRange(q, 0, 10)) {
+    if (!Reverb.inRange(q, 0, 10)) {
       throw new RangeError(
         "[Reverb.js] Filter quality value must be between 0 and 10."
       );
@@ -297,7 +584,7 @@ class Reverb {
    * @param min - Minimum value
    * @param max - Maximum value
    */
-  inRange(x, min, max) {
+  static inRange(x, min, max) {
     return (x - min) * (x - max) <= 0;
   }
   /** Utility function for building an impulse response from the module parameters. */
@@ -344,8 +631,5 @@ class Reverb {
     ];
   }
 }
-if (!window.Reverb) {
-  window.Reverb = Reverb;
-}
 
 export { Reverb as default };