pixi-effects 0.27.0 → 0.27.2

package/dist/loader.css

@@ -1,7 +1,7 @@
 /*
  * pixi-effects loader: one line of HTML on the page, a few lines of CSS, no JavaScript of your own.
  *
- *   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/pixi-effects@0.27.0/dist/loader.css">
+ *   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/pixi-effects@0.27.2/dist/loader.css">
  *   <div class="stage" style="position: relative">                      <!-- any box the canvas sits in, with position: relative -->
  *     <canvas id="stage" width="1280" height="720"></canvas>
  *     <div class="pe-loader" data-label="LOADING"></div>                <!-- or class="pe-loader pe-loader--bar" -->

package/dist/{music-4O367SPR.cjs → music-6MTHQEXS.cjs}

@@ -6,8 +6,50 @@ var chunkTWZNOUM7_cjs = require('./chunk-TWZNOUM7.cjs');
 var TAU = Math.PI * 2;
 var SR = 44100;
 function setSampleRate(sr) {
+  if (sr !== SR) clearVoiceTables();
   SR = sr;
 }
+function clearVoiceTables() {
+  KEYS_TABLES.clear();
+  BELL_TABLES.clear();
+}
+var BELL_TABLES = /* @__PURE__ */ new Map();
+function bellTables(f, k, n) {
+  const key = f + "/" + k;
+  let tb = BELL_TABLES.get(key);
+  if (tb && tb.n >= n) return tb;
+  const len = Math.max(n, tb ? tb.n * 2 : 0);
+  const s35 = new Float64Array(len), e5 = new Float64Array(len), ek = new Float64Array(len), s276 = new Float64Array(len), e4 = new Float64Array(len);
+  for (let i = 0; i < len; i++) {
+    const t = i / SR;
+    s35[i] = Math.sin(TAU * f * 3.5 * t);
+    e5[i] = Math.exp(-t * 5);
+    ek[i] = Math.exp(-t * k);
+    s276[i] = Math.sin(TAU * f * 2.76 * t);
+    e4[i] = Math.exp(-t * 4);
+  }
+  tb = { s35, e5, ek, s276, e4, n: len };
+  BELL_TABLES.set(key, tb);
+  return tb;
+}
+var KEYS_TABLES = /* @__PURE__ */ new Map();
+function keysTables(f, n) {
+  let tb = KEYS_TABLES.get(f);
+  if (tb && tb.n >= n) return tb;
+  const len = Math.max(n, tb ? tb.n * 2 : 0);
+  const decay = new Float64Array(len), s14 = new Float64Array(len), s1 = new Float64Array(len), e18 = new Float64Array(len), e32 = new Float64Array(len);
+  for (let i = 0; i < len; i++) {
+    const t = i / SR;
+    decay[i] = Math.exp(-t * (1.1 + f / 1500));
+    s14[i] = Math.sin(TAU * f * 14 * t);
+    s1[i] = Math.sin(TAU * f * t);
+    e18[i] = Math.exp(-t * 18);
+    e32[i] = Math.exp(-t * 3.2);
+  }
+  tb = { decay, s14, s1, e18, e32, n: len };
+  KEYS_TABLES.set(f, tb);
+  return tb;
+}
 var mtof = (m) => 440 * 2 ** ((m - 69) / 12);
 var Biquad = class {
   b0 = 1;
@@ -46,6 +88,10 @@ var Biquad = class {
     this.a1 = -2 * c / a0;
     this.a2 = (1 - al) / a0;
   }
+  /** All four memories are so small that anything this filter outputs from silence on rounds to 0 in a Float32Array (below half its smallest number). */
+  settled() {
+    return Math.abs(this.x1) < 1e-47 && Math.abs(this.x2) < 1e-47 && Math.abs(this.y1) < 1e-47 && Math.abs(this.y2) < 1e-47;
+  }
   run(x) {
     const y = this.b0 * x + this.b1 * this.x1 + this.b2 * this.x2 - this.a1 * this.y1 - this.a2 * this.y2;
     this.x2 = this.x1;
@@ -62,28 +108,27 @@ var adsr = (t, dur, a, d, s, r) => {
   const base = dur < a ? dur / a : dur < a + d ? 1 - (1 - s) * ((dur - a) / d) : s;
   return Math.max(0, base * (1 - (t - dur) / r));
 };
-function addTo(out, start, i, l, r) {
-  const k = start + i;
-  if (k >= 0 && k < out.L.length) {
-    out.L[k] += l;
-    out.R[k] += r;
-  }
-}
 var INSTRUMENTS = ["keys", "pluck", "pad", "bass", "sub", "lead", "bell", "musicbox"];
 var VOICES = {
   // electric piano: two FM operators (tine + bell), a little stereo chorus
   keys(m, dur, vel, out, start, rnd, o) {
     const f = mtof(m), rel = o.release ?? 0.5, total = dur + rel + 1.2;
-    const n = Math.floor(Math.min(total, 6) * SR), idx = 1.1 + 2.2 * vel, det = 1 + (rnd() - 0.5) * 2e-3;
-    for (let i = 0; i < n; i++) {
+    const n = Math.min(Math.floor(Math.min(total, 6) * SR), Math.ceil((dur + rel) * SR) + 2), idx = 1.1 + 2.2 * vel, det = 1 + (rnd() - 0.5) * 2e-3;
+    const lim = Math.min(n, out.L.length - start);
+    const tb = keysTables(f, lim), dcy = tb.decay, s14 = tb.s14, s1 = tb.s1, e18 = tb.e18, e32 = tb.e32;
+    for (let i = 0; i < lim; i++) {
       const t = i / SR;
-      const decay = Math.exp(-t * (1.1 + f / 1500));
-      const mod = Math.sin(TAU * f * 14 * t) * idx * 0.12 * Math.exp(-t * 18) + Math.sin(TAU * f * t) * idx * Math.exp(-t * 3.2);
+      const decay = dcy[i];
+      const mod = s14[i] * idx * 0.12 * e18[i] + s1[i] * idx * e32[i];
       const body = Math.sin(TAU * f * t + mod) * decay;
       const body2 = Math.sin(TAU * f * det * t + mod * 0.9) * decay;
       const env = t < dur ? 1 : Math.max(0, 1 - (t - dur) / rel);
       const a = Math.min(1, t / 4e-3) * env * 0.5 * vel;
-      addTo(out, start, i, a * (body * 0.7 + body2 * 0.3), a * (body * 0.3 + body2 * 0.7));
+      {
+        const wl = a * (body * 0.7 + body2 * 0.3), wr = a * (body * 0.3 + body2 * 0.7);
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // plucked string (Karplus–Strong with a darker loss filter): guitar / harp / koto
@@ -94,36 +139,65 @@ var VOICES = {
     const rel = o.release ?? 0.25, total = Math.min(dur + rel + 0.4, 5), n = Math.floor(total * SR), loss = 0.9965 - 0.5 / (f + 100);
     let p = 0, prev = 0;
     const pan = (rnd() - 0.5) * 0.3;
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const cur = buf[p], nxt = buf[(p + 1) % len];
       buf[p] = loss * 0.5 * (cur + nxt);
       p = (p + 1) % len;
       const t = i / SR, env = t < dur ? 1 : Math.max(0, 1 - (t - dur) / rel);
       const y = (cur - prev * 0.2) * env * 0.55 * vel;
       prev = cur;
-      addTo(out, start, i, y * (1 - pan), y * (1 + pan));
+      {
+        const wl = y * (1 - pan), wr = y * (1 + pan);
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // warm pad: five detuned band-limited saws through a slow low-pass
   pad(m, dur, vel, out, start, rnd, o) {
     const f = mtof(m), A = o.attack ?? 0.7, R = o.release ?? 1.4, n = Math.floor((dur + R) * SR);
-    const voices = [-0.14, -0.07, 0, 0.07, 0.14].map((c, k) => ({ ph: rnd(), f: f * 2 ** (c / 12 * 0.6), pan: (k - 2) / 2.5 }));
+    const cs = [-0.14, -0.07, 0, 0.07, 0.14];
+    const st = (k) => f * 2 ** (cs[k] / 12 * 0.6) / SR, gL = (k) => 1 - (k - 2) / 2.5, gR = (k) => 1 + (k - 2) / 2.5;
+    let p0 = rnd(), p1 = rnd(), p2 = rnd(), p3 = rnd(), p4 = rnd();
+    const d0 = st(0), d1 = st(1), d2 = st(2), d3 = st(3), d4 = st(4);
+    const gl0 = gL(0), gl1 = gL(1), gl2 = gL(2), gl3 = gL(3), gl4 = gL(4), gr0 = gR(0), gr1 = gR(1), gr2 = gR(2), gr3 = gR(3), gr4 = gR(4);
     const cut = Math.min(1800, 500 + f * 1.5);
     const lp = new Biquad("lp", cut, 0.6), lp2 = new Biquad("lp", cut, 0.6);
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const t = i / SR;
-      let l = 0, r = 0;
-      for (const v of voices) {
-        const dt = v.f / SR;
-        v.ph += dt;
-        if (v.ph >= 1) v.ph -= 1;
-        const s = saw(v.ph, dt);
-        l += s * (1 - v.pan) * 0.5;
-        r += s * (1 + v.pan) * 0.5;
-      }
+      let l = 0, r = 0, sv;
+      p0 += d0;
+      if (p0 >= 1) p0 -= 1;
+      sv = saw(p0, d0);
+      l += sv * gl0 * 0.5;
+      r += sv * gr0 * 0.5;
+      p1 += d1;
+      if (p1 >= 1) p1 -= 1;
+      sv = saw(p1, d1);
+      l += sv * gl1 * 0.5;
+      r += sv * gr1 * 0.5;
+      p2 += d2;
+      if (p2 >= 1) p2 -= 1;
+      sv = saw(p2, d2);
+      l += sv * gl2 * 0.5;
+      r += sv * gr2 * 0.5;
+      p3 += d3;
+      if (p3 >= 1) p3 -= 1;
+      sv = saw(p3, d3);
+      l += sv * gl3 * 0.5;
+      r += sv * gr3 * 0.5;
+      p4 += d4;
+      if (p4 >= 1) p4 -= 1;
+      sv = saw(p4, d4);
+      l += sv * gl4 * 0.5;
+      r += sv * gr4 * 0.5;
       const env = t < dur ? Math.min(1, t / A) : Math.max(0, Math.min(1, dur / A) * (1 - (t - dur) / R));
       const g = env * 0.11 * vel;
-      addTo(out, start, i, lp.run(l) * g, lp2.run(r) * g);
+      {
+        const wl = lp.run(l) * g, wr = lp2.run(r) * g;
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // synth bass: saw + sine sub, filter envelope
@@ -131,7 +205,7 @@ var VOICES = {
     const f = mtof(m), rel = o.release ?? 0.12, n = Math.floor((dur + rel) * SR);
     let ph = 0, ph2 = 0;
     const lp = new Biquad("lp", 400, 1.1);
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const t = i / SR, dt = f / SR;
       ph = (ph + dt) % 1;
       ph2 = (ph2 + dt) % 1;
@@ -139,19 +213,27 @@ var VOICES = {
       const s = lp.run(saw(ph, dt)) * 0.55 + Math.sin(TAU * ph2) * 0.55;
       const env = t < dur ? Math.min(1, t / 6e-3) * (0.75 + 0.25 * Math.exp(-t * 4)) : Math.max(0, 1 - (t - dur) / rel) * 0.75;
       const y = s * env * 0.5 * vel;
-      addTo(out, start, i, y, y);
+      {
+        const wl = y, wr = y;
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // a pure sine bass: a soft heartbeat or sub (no filter sweep, hardly any upper harmonics)
   sub(m, dur, vel, out, start, _rnd, o) {
     const f = mtof(m), rel = o.release ?? 0.2, n = Math.floor((dur + rel) * SR);
     let ph = 0;
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const t = i / SR;
       ph += TAU * f / SR;
       const env = t < dur ? Math.min(1, t / (o.attack ?? 0.012)) * (0.8 + 0.2 * Math.exp(-t * 5)) : Math.max(0, 1 - (t - dur) / rel) * 0.8;
       const y = (Math.sin(ph) + 0.12 * Math.sin(2 * ph)) * env * 0.6 * vel;
-      addTo(out, start, i, y, y);
+      {
+        const wl = y, wr = y;
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // lead: soft saw / triangle with a delayed vibrato
@@ -159,7 +241,7 @@ var VOICES = {
     const f = mtof(m), rel = o.release ?? 0.18, A = o.attack ?? 0.02, n = Math.floor((dur + rel) * SR);
     let ph = rnd(), ph2 = rnd();
     const lp = new Biquad("lp", 2600 + 1800 * vel, 0.8);
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const t = i / SR, vib = 1 + 35e-4 * Math.sin(TAU * 5.3 * t) * Math.min(1, Math.max(0, (t - 0.18) / 0.3));
       const dt = f * vib / SR;
       ph = (ph + dt) % 1;
@@ -167,38 +249,56 @@ var VOICES = {
       const tri = 4 * Math.abs(ph - 0.5) - 1;
       const s = lp.run(saw(ph2, dt) * 0.35 + tri * 0.65);
       const y = s * adsr(t, dur, A, 0.15, 0.7, rel) * 0.28 * vel;
-      addTo(out, start, i, y * 0.9, y * 1.1);
+      {
+        const wl = y * 0.9, wr = y * 1.1;
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // bell / glockenspiel: inharmonic FM; `ring` is how many seconds it keeps sounding
   bell(m, dur, vel, out, start, rnd, o) {
     const f = mtof(m), ring = o.ring ?? 2.5, n = Math.floor(Math.min(dur + ring, 6) * SR), pan = (rnd() - 0.5) * 0.6;
     const k = 1.5 * (2.5 / ring);
-    for (let i = 0; i < n; i++) {
+    const lim = Math.min(n, out.L.length - start);
+    const tb = bellTables(f, k, lim), s35 = tb.s35, e5 = tb.e5, ek = tb.ek, s276 = tb.s276, e4 = tb.e4;
+    for (let i = 0; i < lim; i++) {
       const t = i / SR;
-      const mod = Math.sin(TAU * f * 3.5 * t) * 1.6 * Math.exp(-t * 5);
-      const s = Math.sin(TAU * f * t + mod) * Math.exp(-t * k) + Math.sin(TAU * f * 2.76 * t) * 0.25 * Math.exp(-t * 4);
+      const mod = s35[i] * 1.6 * e5[i];
+      const s = Math.sin(TAU * f * t + mod) * ek[i] + s276[i] * 0.25 * e4[i];
       const y = s * Math.min(1, t / 2e-3) * 0.3 * vel;
-      addTo(out, start, i, y * (1 - pan), y * (1 + pan));
+      {
+        const wl = y * (1 - pan), wr = y * (1 + pan);
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   },
   // music box: a bright tine with a strong upper partial and a short, dry ring
   musicbox(m, dur, vel, out, start, rnd, o) {
     const f = mtof(m), ring = o.ring ?? 1.3, n = Math.floor(Math.min(dur + ring, 4) * SR), pan = (rnd() - 0.5) * 0.4;
-    for (let i = 0; i < n; i++) {
+    for (let i = 0, lim = Math.min(n, out.L.length - start); i < lim; i++) {
       const t = i / SR;
       const s = Math.sin(TAU * f * t) * Math.exp(-t * (3.2 / ring * 1.3)) + Math.sin(TAU * f * 4 * t) * 0.22 * Math.exp(-t * (9 / ring)) + Math.sin(TAU * f * 6.8 * t) * 0.08 * Math.exp(-t * 18);
       const y = s * Math.min(1, t / 15e-4) * 0.34 * vel;
-      addTo(out, start, i, y * (1 - pan), y * (1 + pan));
+      {
+        const wl = y * (1 - pan), wr = y * (1 + pan);
+        out.L[start + i] += wl;
+        out.R[start + i] += wr;
+      }
     }
   }
 };
 var DRUMS = ["kick", "snare", "hat", "openhat", "clap", "rim", "tom", "crash", "shaker", "sleigh"];
 function hitDrum(kind, vel, out, start, rnd) {
-  const mono = (n, f) => {
+  const mono = (n, f, gl = 1, gr = 1) => {
+    const lim = Math.min(n, out.L.length - start), L = out.L, R = out.R;
     for (let i = 0; i < n; i++) {
-      const [l, r] = f(i / SR);
-      addTo(out, start, i, l, r);
+      const o = f(i / SR);
+      if (i < lim) {
+        L[start + i] += o * gl;
+        R[start + i] += o * gr;
+      }
     }
   };
   const len = (s) => Math.floor(s * SR);
@@ -207,7 +307,7 @@ function hitDrum(kind, vel, out, start, rnd) {
     mono(len(0.5), (t) => {
       ph += TAU * (45 + 110 * Math.exp(-t * 28)) / SR;
       const o = (Math.sin(ph) * Math.exp(-t * 7.5) + (t < 4e-3 ? (rnd() - 0.5) * 0.5 : 0)) * 0.95 * vel;
-      return [o, o];
+      return o;
     });
   } else if (kind === "snare") {
     const bp = new Biquad("bp", 1900, 0.9), hp = new Biquad("hp", 700, 0.7);
@@ -216,50 +316,50 @@ function hitDrum(kind, vel, out, start, rnd) {
       ph += TAU * (185 - 40 * t) / SR;
       const nz = hp.run(bp.run(rnd() * 2 - 1)) * 2.2;
       const o = (nz * Math.exp(-t * 17) + Math.sin(ph) * Math.exp(-t * 26) * 0.6) * 0.6 * vel;
-      return [o * 0.95, o * 1.05];
-    });
+      return o;
+    }, 0.95, 1.05);
   } else if (kind === "clap") {
     const bp = new Biquad("bp", 1500, 1.2);
     mono(len(0.35), (t) => {
       const burst = t < 0.033 ? Math.exp(-(t * 1e3 % 11) * 0.5) : Math.exp(-(t - 0.033) * 22);
       const o = bp.run(rnd() * 2 - 1) * 2.4 * burst * 0.5 * vel;
-      return [o, o * 0.9];
-    });
+      return o;
+    }, 1, 0.9);
   } else if (kind === "hat" || kind === "openhat") {
     const hp = new Biquad("hp", 7500, 0.8), dec = kind === "hat" ? 55 : 9;
     mono(len(kind === "hat" ? 0.12 : 0.6), (t) => {
       const o = hp.run(rnd() * 2 - 1) * Math.exp(-t * dec) * 0.35 * vel;
-      return [o * 0.8, o * 1.2];
-    });
+      return o;
+    }, 0.8, 1.2);
   } else if (kind === "rim") {
     let ph = 0;
     const bp = new Biquad("bp", 3200, 4);
     mono(len(0.1), (t) => {
       ph += TAU * 1750 / SR;
       const o = (Math.sin(ph) * 0.5 + bp.run(rnd() * 2 - 1)) * Math.exp(-t * 70) * 0.5 * vel;
-      return [o, o];
+      return o;
     });
   } else if (kind === "tom") {
     let ph = 0;
     mono(len(0.5), (t) => {
       ph += TAU * (95 + 70 * Math.exp(-t * 15)) / SR;
       const o = Math.sin(ph) * Math.exp(-t * 7) * 0.7 * vel;
-      return [o, o];
+      return o;
     });
   } else if (kind === "crash") {
     const hp = new Biquad("hp", 5200, 0.7), bp = new Biquad("bp", 9e3, 0.6);
     mono(len(1.8), (t) => {
       const nz = rnd() * 2 - 1;
       const o = (hp.run(nz) * 0.7 + bp.run(nz) * 0.5) * (0.55 * Math.exp(-t * 2.6) + 0.45 * Math.exp(-t * 11)) * 0.5 * vel;
-      return [o * 0.9, o * 1.1];
-    });
+      return o;
+    }, 0.9, 1.1);
   } else if (kind === "shaker") {
     const bp = new Biquad("bp", 6500, 1.4);
     mono(len(0.16), (t) => {
       const env = (t < 0.018 ? t / 0.018 : 1) * Math.exp(-t * 28);
       const o = bp.run(rnd() * 2 - 1) * env * 1.4 * 0.3 * vel;
-      return [o * 0.85, o * 1.15];
-    });
+      return o;
+    }, 0.85, 1.15);
   } else {
     const bp = new Biquad("bp", 7800, 1);
     const partials = [4200, 5630, 6900, 8350];
@@ -267,11 +367,11 @@ function hitDrum(kind, vel, out, start, rnd) {
       let s = 0;
       for (let k = 0; k < partials.length; k++) s += Math.sin(TAU * partials[k] * t * (1 + k * 7e-4)) * (0.5 + 0.5 * Math.sin(TAU * (19 + k * 3.1) * t + k)) * Math.exp(-t * (7 + k * 2));
       const o = (s * 0.11 + bp.run(rnd() * 2 - 1) * Math.exp(-t * 16) * 0.5) * Math.min(1, t / 3e-3) * vel * 0.8;
-      return [o * 0.85, o * 1.15];
-    });
+      return o;
+    }, 0.85, 1.15);
   }
 }
-function reverb(send, out, wet, size = 0.8) {
+function* reverbSteps(send, out, wet, size = 0.8) {
   const L = out.L, R = out.R, sL = send.L, sR = send.R;
   const scale = SR / 44100;
   const comb = (len) => ({ b: new Float32Array(Math.max(8, Math.round(len * scale))), i: 0, fb: size, d: 0, damp: 0.35 });
@@ -279,29 +379,40 @@ function reverb(send, out, wet, size = 0.8) {
     c: [1116, 1188, 1277, 1356, 1422, 1491].map((l) => comb(l + off)),
     a: [556, 441, 341].map((l) => ({ b: new Float32Array(Math.max(8, Math.round((l + off) * scale))), i: 0 }))
   });
-  const run = (x, ch) => {
-    let y = 0;
-    for (const c of ch.c) {
-      const o = c.b[c.i];
-      c.d = o * (1 - c.damp) + c.d * c.damp;
-      c.b[c.i] = x * 0.03 + c.d * c.fb;
-      c.i = (c.i + 1) % c.b.length;
-      y += o;
-    }
-    for (const a of ch.a) {
-      const o = a.b[a.i], inp = y;
-      a.b[a.i] = inp + o * 0.5;
-      a.i = (a.i + 1) % a.b.length;
-      y = o - inp;
+  const chL = mk(0), chR = mk(23);
+  const block = (i, stop) => {
+    for (; i < stop; i++) {
+      const m = (sL[i] + sR[i]) * 0.5;
+      L[i] += runFlat(m, chL) * wet;
+      R[i] += runFlat(m, chR) * wet;
     }
-    return y;
   };
-  const chL = mk(0), chR = mk(23);
-  for (let i = 0; i < L.length; i++) {
-    const m = (sL[i] + sR[i]) * 0.5;
-    L[i] += run(m, chL) * wet;
-    R[i] += run(m, chR) * wet;
+  for (let i = 0; i < L.length; ) {
+    yield i / L.length;
+    const stop = Math.min(L.length, (i | 16383) + 1);
+    block(i, stop);
+    i = stop;
+  }
+}
+function runFlat(x, ch) {
+  let y = 0;
+  const cs = ch.c, as = ch.a;
+  for (let k = 0; k < 6; k++) {
+    const c = cs[k], b = c.b;
+    const o = b[c.i];
+    c.d = o * (1 - c.damp) + c.d * c.damp;
+    b[c.i] = x * 0.03 + c.d * c.fb;
+    c.i = c.i + 1 === b.length ? 0 : c.i + 1;
+    y += o;
   }
+  for (let k = 0; k < 3; k++) {
+    const a = as[k], b = a.b;
+    const o = b[a.i], inp = y;
+    b[a.i] = inp + o * 0.5;
+    a.i = a.i + 1 === b.length ? 0 : a.i + 1;
+    y = o - inp;
+  }
+  return y;
 }
 
 // src/audio/music/notation.ts
@@ -723,6 +834,18 @@ function rng(seed) {
     return ((t ^ t >>> 14) >>> 0) / 4294967296;
   };
 }
+function extent(b) {
+  let lo = b.L.length, hi = -1;
+  for (let i = 0; i < b.L.length; i++) if (b.L[i] !== 0 || b.R[i] !== 0) {
+    lo = i;
+    break;
+  }
+  for (let i = b.L.length - 1; i >= lo; i--) if (b.L[i] !== 0 || b.R[i] !== 0) {
+    hi = i;
+    break;
+  }
+  return [lo, hi];
+}
 function musicLength(m) {
   return m.seconds + m.tail;
 }
@@ -745,8 +868,41 @@ function musicBeatTimes(m, until = m.seconds) {
   }
   return times.filter((t) => t < until);
 }
-function renderMusic(m, sampleRate, length, loop = false) {
+function toneRun(scratch, a, b, i, stop, end) {
+  const L = scratch.L, R = scratch.R;
+  const a0 = a[0], a1 = a[1], b0 = b[0], b1 = b[1];
+  for (; i < stop && (i < end || !(a0.settled() && a1.settled() && b0.settled() && b1.settled())); i++) {
+    L[i] = a1.run(a0.run(L[i]));
+    R[i] = b1.run(b0.run(R[i]));
+  }
+  return i;
+}
+function mixRun(scratch, out, send, i, stop, level, constant, g, gl, gr, rv, sampleRate) {
+  const sL = scratch.L, sR = scratch.R, oL = out.L, oR = out.R, eL = send.L, eR = send.R;
+  for (; i < stop; i++) {
+    if (!constant) g = level(i / sampleRate);
+    const l = sL[i] * g * gl, r = sR[i] * g * gr;
+    oL[i] += l;
+    oR[i] += r;
+    eL[i] += l * rv;
+    eR[i] += r * rv;
+  }
+}
+function tanhRun(out, i, stop, acc) {
+  const L = out.L, R = out.R;
+  let peak = acc[0], sum = acc[1];
+  for (; i < stop; i++) {
+    const l = L[i] = Math.tanh(L[i] * 0.9), r = R[i] = Math.tanh(R[i] * 0.9);
+    peak = Math.max(peak, Math.abs(l), Math.abs(r));
+    sum += l * l + r * r;
+  }
+  acc[0] = peak;
+  acc[1] = sum;
+}
+function* renderMusicSteps(m, sampleRate, length, loop) {
   setSampleRate(sampleRate);
+  const units = m.tracks.length + (m.drums.length ? 1 : 0) + 2;
+  let unit = 0;
   const total = Math.max(2, Math.round(length * sampleRate));
   const rnd = rng(m.seed);
   const map = new TempoMap(m.tempo);
@@ -761,6 +917,15 @@ function renderMusic(m, sampleRate, length, loop = false) {
   const levelAt = (vol) => {
     if (typeof vol === "number") return () => vol;
     const pts = vol.map(([b, v]) => [map.seconds(b), v]);
+    if (!loop && pts.every((p, i) => i === 0 || p[0] >= pts[i - 1][0])) {
+      let j = 1;
+      return (sec) => {
+        if (sec <= pts[0][0]) return pts[0][1];
+        while (j < pts.length && !(sec < pts[j][0])) j++;
+        if (j < pts.length) return pts[j - 1][1] + (pts[j][1] - pts[j - 1][1]) * (sec - pts[j - 1][0]) / (pts[j][0] - pts[j - 1][0]);
+        return pts[pts.length - 1][1];
+      };
+    }
     return (sec) => {
       const t = loop && loopSec > 0 ? sec % loopSec : sec;
       if (t <= pts[0][0]) return pts[0][1];
@@ -772,11 +937,11 @@ function renderMusic(m, sampleRate, length, loop = false) {
   };
   for (const tr of m.tracks) {
     const inst = VOICES[tr.inst];
-    scratch.L.fill(0);
-    scratch.R.fill(0);
     for (let r = 0; r < repeats; r++) {
       const offset = r * loopSec;
-      for (const e of tr.events) {
+      for (let ei = 0; ei < tr.events.length; ei++) {
+        const e = tr.events[ei];
+        yield (unit + ei / tr.events.length) / units;
         const strum = e.midi.length > 1 ? tr.strum : 0;
         const startBeat = swingShift(e.t);
         const lenSec = Math.max(0.05, (map.seconds(e.t + e.dur) - map.seconds(e.t)) * tr.legato);
@@ -788,26 +953,37 @@ function renderMusic(m, sampleRate, length, loop = false) {
         });
       }
     }
+    const [lo, hi] = extent(scratch);
+    let end = hi + 1;
     if (tr.tone < 1) {
       const fc = 400 * 50 ** tr.tone;
       const a = [new Biquad("lp", fc, 0.7), new Biquad("lp", fc, 0.7)], b = [new Biquad("lp", fc, 0.7), new Biquad("lp", fc, 0.7)];
-      for (let i = 0; i < total; i++) {
-        scratch.L[i] = a[1].run(a[0].run(scratch.L[i]));
-        scratch.R[i] = b[1].run(b[0].run(scratch.R[i]));
+      let i = lo;
+      for (; ; ) {
+        const stop = Math.min(total, (i | 65535) + 1);
+        const j = toneRun(scratch, a, b, i, stop, end);
+        if (j < stop || j >= total) {
+          i = j;
+          break;
+        }
+        i = j;
+        yield (unit + 0.9) / units;
       }
+      end = Math.max(end, i);
     }
     const level = levelAt(tr.vol), pan = Math.max(-1, Math.min(1, tr.pan));
     const gl = Math.cos((pan + 1) * Math.PI / 4) * 1.3, gr = Math.sin((pan + 1) * Math.PI / 4) * 1.3;
     const constant = typeof tr.vol === "number";
     let g = constant ? level(0) : 0;
-    for (let i = 0; i < total; i++) {
-      if (!constant) g = level(i / sampleRate);
-      const l = scratch.L[i] * g * gl, r = scratch.R[i] * g * gr;
-      out.L[i] += l;
-      out.R[i] += r;
-      send.L[i] += l * tr.reverb;
-      send.R[i] += r * tr.reverb;
+    for (let i = lo; i < end; ) {
+      const stop = Math.min(end, (i | 65535) + 1);
+      mixRun(scratch, out, send, i, stop, level, constant, g, gl, gr, tr.reverb, sampleRate);
+      i = stop;
+      yield (unit + 0.95) / units;
     }
+    scratch.L.fill(0, lo, end);
+    scratch.R.fill(0, lo, end);
+    unit++;
   }
   if (m.drums.length) {
     scratch.L.fill(0);
@@ -815,6 +991,7 @@ function renderMusic(m, sampleRate, length, loop = false) {
     for (let r = 0; r < repeats; r++) {
       const offset = r * loopSec;
       for (const s of m.drums) {
+        yield unit / units;
         const end = Math.min(s.to, m.beats);
         for (let rep = 0; s.from + rep * s.repeat < end - 1e-6; rep++) for (const d of s.drums) for (const h of d.hits) {
           const beat = s.from + rep * s.repeat + h.i / m.grid;
@@ -833,14 +1010,18 @@ function renderMusic(m, sampleRate, length, loop = false) {
       send.L[i] += l;
       send.R[i] += r;
     }
+    unit++;
   }
-  reverb(send, out, m.reverb, 0.8);
-  let peak = 0, sum = 0;
-  for (let i = 0; i < total; i++) {
-    const l = out.L[i] = Math.tanh(out.L[i] * 0.9), r = out.R[i] = Math.tanh(out.R[i] * 0.9);
-    peak = Math.max(peak, Math.abs(l), Math.abs(r));
-    sum += l * l + r * r;
+  for (const f of reverbSteps(send, out, m.reverb, 0.8)) yield (unit + f) / units;
+  unit++;
+  const acc = new Float64Array(2);
+  for (let i = 0; i < total; ) {
+    const stop = Math.min(total, (i | 65535) + 1);
+    tanhRun(out, i, stop, acc);
+    i = stop;
+    yield (unit + 0.5 * i / total) / units;
   }
+  const peak = acc[0], sum = acc[1];
   const rms = Math.sqrt(sum / (2 * total));
   const gain = peak > 0 ? Math.min(MUSIC_PEAK / peak, RMS_CAP / Math.max(rms, 1e-9)) : 0;
   const fade = Math.min(Math.floor(0.4 * sampleRate), total >> 2);
@@ -849,8 +1030,24 @@ function renderMusic(m, sampleRate, length, loop = false) {
     out.L[i] *= gain * f;
     out.R[i] *= gain * f;
   }
+  clearVoiceTables();
   return [out.L, out.R];
 }
+function renderMusic(m, sampleRate, length, loop = false) {
+  const it = renderMusicSteps(m, sampleRate, length, loop);
+  for (; ; ) {
+    const r = it.next();
+    if (r.done) return r.value;
+  }
+}
+async function renderMusicAsync(m, sampleRate, length, loop = false, pace) {
+  const it = renderMusicSteps(m, sampleRate, length, loop);
+  for (; ; ) {
+    const r = it.next();
+    if (r.done) return r.value;
+    if (pace) await pace(r.value);
+  }
+}
 
 exports.CHORD_KINDS = CHORD_KINDS;
 exports.DEFAULT_TAIL = DEFAULT_TAIL;
@@ -867,6 +1064,7 @@ exports.noteToMidi = noteToMidi;
 exports.parseDrumGrid = parseDrumGrid;
 exports.parseNotes = parseNotes;
 exports.renderMusic = renderMusic;
+exports.renderMusicAsync = renderMusicAsync;
 exports.resolveMusic = resolveMusic;
-//# sourceMappingURL=music-4O367SPR.cjs.map
-//# sourceMappingURL=music-4O367SPR.cjs.map
+//# sourceMappingURL=music-6MTHQEXS.cjs.map
+//# sourceMappingURL=music-6MTHQEXS.cjs.map