@logue/reverb 1.3.4 → 1.3.7

package/dist/Reverb.es.js

@@ -5,84 +5,69 @@
  * @author Logue <logue@hotmail.co.jp>
  * @copyright 2019-2023 By Masashi Yoshikawa All rights reserved.
  * @license MIT
- * @version 1.3.4
+ * @version 1.3.7
  * @see {@link https://github.com/logue/Reverb.js}
  */
 
-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;
-        const range = (max | 0) - min;
-        return range ? min + (this.int() % range) : min;
-    }
-    minmaxUint(min, max) {
-        min >>>= 0;
-        const range = (max >>> 0) - min;
-        return range ? min + (this.int() % range) : min;
-    }
+const g = 23283064365386963e-26;
+class F {
+  float(e = 1) {
+    return this.int() * g * e;
+  }
+  probability(e) {
+    return this.float() < e;
+  }
+  norm(e = 1) {
+    return (this.int() * g - 0.5) * 2 * e;
+  }
+  normMinMax(e, s) {
+    const i = this.minmax(e, s);
+    return this.float() < 0.5 ? i : -i;
+  }
+  minmax(e, s) {
+    return this.float() * (s - e) + e;
+  }
+  minmaxInt(e, s) {
+    e |= 0;
+    const i = (s | 0) - e;
+    return i ? e + this.int() % i : e;
+  }
+  minmaxUint(e, s) {
+    e >>>= 0;
+    const i = (s >>> 0) - e;
+    return i ? e + this.int() % i : e;
+  }
 }
-
-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;
-    }
+const m = Math.random;
+class T extends F {
+  int() {
+    return m() * 4294967296 >>> 0;
+  }
+  float(e = 1) {
+    return m() * e;
+  }
+  norm(e = 1) {
+    return (m() - 0.5) * 2 * e;
+  }
 }
-/**
- * Used as default PRNG throughout most other thi.ng projects, though usually is
- * configurable.
- */
-const SYSTEM = new SystemRandom();
-
-const defaults = {
+const k = new T(), x = {
   noise: "white",
   scale: 1,
   peaks: 2,
-  randomAlgorithm: SYSTEM,
+  randomAlgorithm: k,
   decay: 2,
   delay: 0,
-  reverse: false,
+  reverse: !1,
   time: 2,
   filterType: "allpass",
   filterFreq: 2200,
   filterQ: 1,
   mix: 0.5,
-  once: false
-};
-
-const Meta = {
-  version: "1.3.4",
-  date: "2023-11-06T00:21:39.551Z"
-};
-
-const Noise = {
+  once: !1
+}, w = {
+  version: "1.3.7",
+  date: "2024-01-29T10:30:54.595Z"
+}, d = {
   /** Blue noise */
   blue: "blue",
   /** Brown noise (same as red noise) */
@@ -97,254 +82,112 @@ const Noise = {
   violet: "violet",
   /** White 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;
-    }
+}, p = {
+  bins: 2,
+  scale: 1,
+  rnd: k
+}, N = (t, e, s) => {
+  const i = new Array(t);
+  for (let n = 0; n < t; n++)
+    i[n] = s.norm(e);
+  return i;
+}, v = (t) => t.reduce((e, s) => e + s, 0);
+function* G(t, e) {
+  const s = [t[Symbol.iterator](), e[Symbol.iterator]()];
+  for (let i = 0; ; i ^= 1) {
+    const n = s[i].next();
+    if (n.done)
+      return;
+    yield n.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;
-    }
+function* b(t) {
+  const { bins: e, scale: s, rnd: i } = {
+    ...p,
+    ...t
+  }, n = N(e, s, i);
+  n.forEach((r, l) => n[l] = l & 1 ? r : -r);
+  const a = 1 / e;
+  let o = v(n);
+  for (let r = 0, l = -1; ; ++r >= e && (r = 0))
+    o -= n[r], o += n[r] = l * i.norm(s), l ^= 4294967294, yield l * o * a;
 }
-
-/**
- * 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;
+const C = (t) => G(b(t), b(t)), E = (t) => {
+  let e = 32;
+  return t &= -t, t && e--, t & 65535 && (e -= 16), t & 16711935 && (e -= 8), t & 252645135 && (e -= 4), t & 858993459 && (e -= 2), t & 1431655765 && (e -= 1), e;
 };
-
-/**
- * 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;
-    }
+function* j(t) {
+  const { bins: e, scale: s, rnd: i } = {
+    ...p,
+    bins: 8,
+    ...t
+  }, n = N(e, s, i), a = 1 / e;
+  let o = v(n);
+  for (let r = 0; ; r = r + 1 >>> 0) {
+    const l = E(r) % e;
+    o -= n[l], o += n[l] = i.norm(s), yield o * a;
+  }
 }
-
-/**
- * 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;
-    }
+function* y(t) {
+  const { bins: e, scale: s, rnd: i } = {
+    ...p,
+    ...t
+  }, n = N(e, s, i), a = 1 / e;
+  let o = v(n);
+  for (let r = 0; ; ++r >= e && (r = 0))
+    o -= n[r], o += n[r] = i.norm(s), yield o * a;
 }
-
-/**
- * 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 M = (t) => G(y(t), y(t));
+function* R(t) {
+  const { scale: e, rnd: s } = { ...p, ...t };
+  for (; ; )
+    yield s.norm(e);
 }
-
-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 S = (t, e) => t != null && typeof t[e] == "function", Q = (t) => S(t, "xform") ? t.xform() : t, q = (t) => t != null && typeof t[Symbol.iterator] == "function";
+class u {
+  value;
+  constructor(e) {
+    this.value = e;
+  }
+  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));
+const D = (t) => new u(t), L = (t) => t instanceof u, B = (t) => t instanceof u ? t : new u(t), I = (t) => t instanceof u ? t.deref() : t, O = (t, e) => [t, (s) => s, e];
+function U(t) {
+  return t ? [...t] : O(
+    () => [],
+    (e, s) => (e.push(s), e)
+  );
 }
-
-/**
- * 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;
-        }
+function* z(t, e) {
+  const s = Q(t)(U()), i = s[1], n = s[2];
+  for (let a of e) {
+    const o = n([], a);
+    if (L(o)) {
+      yield* I(i(o.deref()));
+      return;
     }
-    yield* unreduced(complete([]));
+    o.length && (yield* o);
+  }
+  yield* I(i([]));
 }
-
-/**
- * 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));
-        };
+const P = (t, e) => [t[0], t[1], e];
+function A(t, e) {
+  return q(e) ? z(A(t), e) : (s) => {
+    const i = s[2];
+    let n = t;
+    return P(
+      s,
+      (a, o) => --n > 0 ? i(a, o) : n === 0 ? B(i(a, o)) : D(a)
+    );
+  };
 }
-
-class Reverb {
+class h {
   /** Version strings */
-  static version = Meta.version;
+  static version = w.version;
   /** Build date */
-  static build = Meta.date;
+  static build = w.date;
   /** AudioContext */
   ctx;
   /** Wet Level (Reverberated node) */
@@ -362,211 +205,167 @@ class Reverb {
   /** Connected flag */
   isConnected;
   /** Noise Generator */
-  noise = white;
+  noise = R;
   /**
    * Constructor
    *
    * @param ctx - Root AudioContext
    * @param options - Configure
    */
-  constructor(ctx, options) {
-    this.ctx = ctx;
-    this.options = Object.assign(defaults, options);
-    this.wetGainNode = this.ctx.createGain();
-    this.dryGainNode = this.ctx.createGain();
-    this.filterNode = this.ctx.createBiquadFilter();
-    this.convolverNode = this.ctx.createConvolver();
-    this.outputNode = this.ctx.createGain();
-    this.isConnected = false;
-    this.filterType(this.options.filterType);
-    this.setNoise(this.options.noise);
-    this.buildImpulse();
-    this.mix(this.options.mix);
+  constructor(e, s) {
+    this.ctx = e, this.options = Object.assign(x, s), this.wetGainNode = this.ctx.createGain(), this.dryGainNode = this.ctx.createGain(), this.filterNode = this.ctx.createBiquadFilter(), this.convolverNode = this.ctx.createConvolver(), this.outputNode = this.ctx.createGain(), this.isConnected = !1, this.filterType(this.options.filterType), this.setNoise(this.options.noise), this.buildImpulse(), this.mix(this.options.mix);
   }
   /**
    * Connect the node for the reverb effect to the original sound node.
    *
    * @param sourceNode - Input source node
    */
-  connect(sourceNode) {
-    if (this.isConnected && this.options.once) {
-      this.isConnected = false;
-      return this.outputNode;
-    }
-    this.convolverNode.connect(this.filterNode);
-    this.filterNode.connect(this.wetGainNode);
-    sourceNode.connect(this.convolverNode);
-    sourceNode.connect(this.dryGainNode).connect(this.outputNode);
-    sourceNode.connect(this.wetGainNode).connect(this.outputNode);
-    this.isConnected = true;
-    return this.outputNode;
+  connect(e) {
+    return this.isConnected && this.options.once ? (this.isConnected = !1, this.outputNode) : (this.convolverNode.connect(this.filterNode), this.filterNode.connect(this.wetGainNode), e.connect(this.convolverNode), e.connect(this.dryGainNode).connect(this.outputNode), e.connect(this.wetGainNode).connect(this.outputNode), this.isConnected = !0, this.outputNode);
   }
   /**
    * Disconnect the reverb node
    *
    * @param sourceNode - Input source node
    */
-  disconnect(sourceNode) {
-    if (this.isConnected) {
-      this.convolverNode.disconnect(this.filterNode);
-      this.filterNode.disconnect(this.wetGainNode);
-    }
-    this.isConnected = false;
-    return sourceNode;
+  disconnect(e) {
+    return this.isConnected && (this.convolverNode.disconnect(this.filterNode), this.filterNode.disconnect(this.wetGainNode)), this.isConnected = !1, e;
   }
   /**
    * Dry/Wet ratio
    *
    * @param mix - Ratio (0~1)
    */
-  mix(mix) {
-    if (!Reverb.inRange(mix, 0, 1)) {
+  mix(e) {
+    if (!h.inRange(e, 0, 1))
       throw new RangeError("[Reverb.js] Dry/Wet ratio must be between 0 to 1.");
-    }
-    this.options.mix = mix;
-    this.dryGainNode.gain.value = 1 - this.options.mix;
-    this.wetGainNode.gain.value = this.options.mix;
+    this.options.mix = e, this.dryGainNode.gain.value = 1 - this.options.mix, this.wetGainNode.gain.value = this.options.mix;
   }
   /**
    * Set Impulse Response time length (second)
    *
    * @param value - IR length
    */
-  time(value) {
-    if (!Reverb.inRange(value, 1, 50)) {
+  time(e) {
+    if (!h.inRange(e, 1, 50))
       throw new RangeError(
         "[Reverb.js] Time length of inpulse response must be less than 50sec."
       );
-    }
-    this.options.time = value;
-    this.buildImpulse();
+    this.options.time = e, this.buildImpulse();
   }
   /**
    * Impulse response decay rate.
    *
    * @param value - Decay value
    */
-  decay(value) {
-    if (!Reverb.inRange(value, 0, 100)) {
+  decay(e) {
+    if (!h.inRange(e, 0, 100))
       throw new RangeError(
         "[Reverb.js] Inpulse Response decay level must be less than 100."
       );
-    }
-    this.options.decay = value;
-    this.buildImpulse();
+    this.options.decay = e, this.buildImpulse();
   }
   /**
    * Delay before reverberation starts
    *
    * @param value - Time[ms]
    */
-  delay(value) {
-    if (!Reverb.inRange(value, 0, 100)) {
+  delay(e) {
+    if (!h.inRange(e, 0, 100))
       throw new RangeError(
         "[Reverb.js] Inpulse Response delay time must be less than 100."
       );
-    }
-    this.options.delay = value;
-    this.buildImpulse();
+    this.options.delay = e, this.buildImpulse();
   }
   /**
    * Reverse the impulse response.
    *
    * @param reverse - Reverse IR
    */
-  reverse(reverse) {
-    this.options.reverse = reverse;
-    this.buildImpulse();
+  reverse(e) {
+    this.options.reverse = e, this.buildImpulse();
   }
   /**
    * Filter for impulse response
    *
    * @param type - Filiter Type
    */
-  filterType(type = "allpass") {
-    this.filterNode.type = this.options.filterType = type;
+  filterType(e = "allpass") {
+    this.filterNode.type = this.options.filterType = e;
   }
   /**
    * Filter frequency applied to impulse response
    *
    * @param freq - Frequency
    */
-  filterFreq(freq) {
-    if (!Reverb.inRange(freq, 20, 2e4)) {
+  filterFreq(e) {
+    if (!h.inRange(e, 20, 2e4))
       throw new RangeError(
         "[Reverb.js] Filter frequrncy must be between 20 and 20000."
       );
-    }
-    this.options.filterFreq = freq;
-    this.filterNode.frequency.value = this.options.filterFreq;
+    this.options.filterFreq = e, this.filterNode.frequency.value = this.options.filterFreq;
   }
   /**
    * Filter quality.
    *
    * @param q - Quality
    */
-  filterQ(q) {
-    if (!Reverb.inRange(q, 0, 10)) {
+  filterQ(e) {
+    if (!h.inRange(e, 0, 10))
       throw new RangeError(
-        "[Reverb.js] Filter quality value must be between 0 and 10."
+        "[Reverb.js] Filter Q value must be between 0 and 10."
       );
-    }
-    this.options.filterQ = q;
-    this.filterNode.Q.value = this.options.filterQ;
+    this.options.filterQ = e, this.filterNode.Q.value = this.options.filterQ;
   }
   /**
    * set IR source noise peaks
    *
    * @param p - Peaks
    */
-  peaks(p) {
-    this.options.peaks = p;
-    this.buildImpulse();
+  peaks(e) {
+    this.options.peaks = e, this.buildImpulse();
   }
   /**
    * set IR source noise scale.
    *
    * @param s - Scale
    */
-  scale(s) {
-    this.options.scale = s;
-    this.buildImpulse();
+  scale(e) {
+    this.options.scale = e, this.buildImpulse();
   }
   /**
    * set IR source noise generator.
    *
    * @param a - Algorithm
    */
-  randomAlgorithm(a) {
-    this.options.randomAlgorithm = a;
-    this.buildImpulse();
+  randomAlgorithm(e) {
+    this.options.randomAlgorithm = e, this.buildImpulse();
   }
   /**
    * Inpulse Response Noise algorithm.
    *
    * @param type - IR noise algorithm type.
    */
-  setNoise(type) {
-    this.options.noise = type;
-    switch (type) {
-      case Noise.blue:
-        this.noise = blue;
+  setNoise(e) {
+    switch (this.options.noise = e, e) {
+      case d.blue:
+        this.noise = b;
         break;
-      case Noise.green:
-        this.noise = green;
+      case d.green:
+        this.noise = C;
         break;
-      case Noise.pink:
-        this.noise = pink;
+      case d.pink:
+        this.noise = j;
         break;
-      case Noise.red:
-      case Noise.brown:
-        this.noise = red;
+      case d.red:
+      case d.brown:
+        this.noise = y;
         break;
-      case Noise.violet:
-        this.noise = violet;
+      case d.violet:
+        this.noise = M;
         break;
       default:
-        this.noise = white;
+        this.noise = R;
     }
     this.buildImpulse();
   }
@@ -575,9 +374,8 @@ class Reverb {
    *
    * @param algorithm - Algorythm
    */
-  setRandomAlgorythm(algorithm) {
-    this.options.randomAlgorithm = algorithm;
-    this.buildImpulse();
+  setRandomAlgorythm(e) {
+    this.options.randomAlgorithm = e, this.buildImpulse();
   }
   /**
    * Return true if in range, otherwise false
@@ -586,44 +384,27 @@ class Reverb {
    * @param min - Minimum value
    * @param max - Maximum value
    */
-  static inRange(x, min, max) {
-    return (x - min) * (x - max) <= 0;
+  static inRange(e, s, i) {
+    return (e - s) * (e - i) <= 0;
   }
   /** Utility function for building an impulse response from the module parameters. */
   buildImpulse() {
-    const rate = this.ctx.sampleRate;
-    const duration = Math.max(rate * this.options.time, 1);
-    const delayDuration = rate * this.options.delay;
-    const impulse = this.ctx.createBuffer(2, duration, rate);
-    const impulseL = new Float32Array(duration);
-    const impulseR = new Float32Array(duration);
-    const noiseL = this.getNoise(duration);
-    const noiseR = this.getNoise(duration);
-    for (let i = 0; i < duration; i++) {
-      let n = 0;
-      if (i < delayDuration) {
-        impulseL[i] = 0;
-        impulseR[i] = 0;
-        n = this.options.reverse ?? false ? duration - (i - delayDuration) : i - delayDuration;
-      } else {
-        n = this.options.reverse ?? false ? duration - i : i;
-      }
-      impulseL[i] = (noiseL[i] ?? 0) * (1 - n / duration) ** this.options.decay;
-      impulseR[i] = (noiseR[i] ?? 0) * (1 - n / duration) ** this.options.decay;
+    const e = this.ctx.sampleRate, s = Math.max(e * this.options.time, 1), i = e * this.options.delay, n = this.ctx.createBuffer(2, s, e), a = new Float32Array(s), o = new Float32Array(s), r = this.getNoise(s), l = this.getNoise(s);
+    for (let c = 0; c < s; c++) {
+      let f = 0;
+      c < i ? (a[c] = 0, o[c] = 0, f = this.options.reverse ?? !1 ? s - (c - i) : c - i) : f = this.options.reverse ?? !1 ? s - c : c, a[c] = (r[c] ?? 0) * (1 - f / s) ** this.options.decay, o[c] = (l[c] ?? 0) * (1 - f / s) ** this.options.decay;
     }
-    impulse.getChannelData(0).set(impulseL);
-    impulse.getChannelData(1).set(impulseR);
-    this.convolverNode.buffer = impulse;
+    n.getChannelData(0).set(a), n.getChannelData(1).set(o), this.convolverNode.buffer = n;
   }
   /**
    * Noise source
    *
    * @param duration - length of IR.
    */
-  getNoise(duration) {
+  getNoise(e) {
     return [
-      ...take(
-        duration,
+      ...A(
+        e,
         this.noise({
           bins: this.options.peaks,
           scale: this.options.scale,
@@ -633,5 +414,6 @@ class Reverb {
     ];
   }
 }
-
-export { Reverb as default };
+export {
+  h as default
+};