loudness-worklet 1.6.0 → 1.6.2

package/README.md

@@ -5,9 +5,7 @@
 
 A loudness meter for the `Web Audio API`, based on the [ITU-R BS.1770-5](https://www.itu.int/rec/R-REC-BS.1770) standard and implemented as an AudioWorkletProcessor.
 
-[![screenshot](https://github.com/lcweden/loudness-worklet/blob/main/public/screenshots/meter.png)](https://lcweden.github.io/loudness-worklet/)
-
-<p align="center"><a href="https://lcweden.github.io/loudness-worklet/">Demo</a></p>
+[![screenshot](https://github.com/lcweden/loudness-worklet/blob/main/packages/web/public/screenshots/meter.png)](https://lcweden.github.io/loudness-worklet/)
 
 ## Features
 
@@ -271,7 +269,7 @@ type LoudnessSnapshot = {
 | `maximumMomentaryLoudness` | `LUFS`/`LKFS` |
 | `maximumShortTermLoudness` | `LUFS`/`LKFS` |
 | `maximumTruePeakLevel`     | `dBTP`        |
-| `loudnessRange`            | `LRA`         |
+| `loudnessRange`            | `LU`         |
 
 ### Supported Channels
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loudness-worklet",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "A lightweight and efficient AudioWorklet for real-time loudness measurement in the browser, compliant with the ITU-R BS.1770-5 standard.",
   "keywords": [
     "web-audio",

package/packages/lib/dist/index.d.ts

@@ -10,6 +10,11 @@ export declare type LoudnessMeasurements = {
     loudnessRange: number;
 };
 
+export declare type LoudnessProcessorOptions = {
+    capacity?: number;
+    interval?: number;
+};
+
 export declare type LoudnessSnapshot = {
     currentFrame: number;
     currentTime: number;
@@ -25,10 +30,7 @@ export declare interface LoudnessWorkletProcessorOptions {
     numberOfInputs?: AudioWorkletNodeOptions["numberOfInputs"];
     numberOfOutputs?: AudioWorkletNodeOptions["numberOfOutputs"];
     outputChannelCount?: AudioWorkletNodeOptions["outputChannelCount"];
-    processorOptions?: {
-        interval?: number;
-        capacity?: number;
-    };
+    processorOptions?: LoudnessProcessorOptions;
 }
 
 export { }

package/packages/lib/dist/index.js

@@ -1,10 +1,10 @@
-const i = `const d = {
+const i = `const x = {
   highshelf: {
     a: [-1.69065929318241, 0.73248077421585],
     b: [1.53512485958697, -2.69169618940638, 1.19839281085285]
   },
   highpass: { a: [-1.99004745483398, 0.99007225036621], b: [1, -2, 1] }
-}, L = {
+}, C = {
   lowpass: {
     phase0: [
       0.001708984375,
@@ -63,74 +63,41 @@ const i = `const d = {
       0.001708984375
     ]
   }
-}, O = {
-  1: { mono: 1 },
-  2: { L: 1, R: 1 },
-  6: { L: 1, R: 1, C: 1, LFE: 0, Ls: 1.41, Rs: 1.41 },
-  8: {
-    L: 1,
-    R: 1,
-    C: 1,
-    LFE: 0,
-    Lss: 1.41,
-    Rss: 1.41,
-    Lrs: 1,
-    Rrs: 1
-  },
-  10: {
-    L: 1,
-    R: 1,
-    C: 1,
-    LFE: 0,
-    Ls: 1.41,
-    Rs: 1.41,
-    Tfl: 1,
-    Tfr: 1,
-    Tbl: 1,
-    Tbr: 1
-  },
-  12: {
-    L: 1,
-    R: 1,
-    C: 1,
-    LFE: 0,
-    Lss: 1.41,
-    Rss: 1.41,
-    Lrs: 1,
-    Rrs: 1,
-    Tfl: 1,
-    Tfr: 1,
-    Tbl: 1,
-    Tbr: 1
-  },
-  24: {
-    FL: 1.41,
-    FR: 1.41,
-    FC: 1,
-    LFE1: 0,
-    BL: 1,
-    BR: 1,
-    FLc: 1,
-    FRc: 1,
-    BC: 1,
-    LFE2: 0,
-    SiL: 1.41,
-    SiR: 1.41,
-    TpFL: 1,
-    TpFR: 1,
-    TpFC: 1,
-    TpC: 1,
-    TpBL: 1,
-    TpBR: 1,
-    TpSiL: 1,
-    TpSiR: 1,
-    TpBC: 1,
-    BtFC: 1,
-    BtFL: 1,
-    BtFR: 1
-  }
-}, U = 0.4, G = 0.1, Y = 3, B = 0.1, j = 0.1, q = 0.95, C = 12.04, z = -70, K = -10, J = -70, Q = -20;
-class x {
+}, B = {
+  1: [1],
+  2: [1, 1],
+  6: [1, 1, 1, 0, 1.41, 1.41],
+  8: [1, 1, 1, 0, 1.41, 1.41, 1, 1],
+  10: [1, 1, 1, 0, 1.41, 1.41, 1, 1, 1, 1],
+  12: [1, 1, 1, 0, 1.41, 1.41, 1, 1, 1, 1, 1],
+  24: [
+    1.41,
+    1.41,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    1.41,
+    1.41,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1
+  ]
+}, P = 0.4, M = 0.1, H = 3, O = 0.1, W = 0.1, k = 0.95, V = 12.04, U = -70, Y = -10, z = -70, K = -20;
+class D {
   #t = new Float32Array(2);
   #e = new Float32Array(3);
   #s = new Float32Array(2);
@@ -140,8 +107,8 @@ class x {
    * @param { number[] } a - Feedback coefficients [a1, a2]
    * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
    */
-  constructor(e, r) {
-    this.reset(), this.set(e, r);
+  constructor(e, i) {
+    this.reset(), this.set(e, i);
   }
   /**
    * Processes a single input sample and returns the filtered output.
@@ -149,8 +116,8 @@ class x {
    * @returns { number } - The filtered output sample.
    */
   process(e) {
-    const r = this.#e[0] * e + this.#e[1] * this.#s[0] + this.#e[2] * this.#s[1] - this.#t[0] * this.#r[0] - this.#t[1] * this.#r[1];
-    return this.#s[1] = this.#s[0], this.#s[0] = e, this.#r[1] = this.#r[0], this.#r[0] = r, r;
+    const i = this.#e[0] * e + this.#e[1] * this.#s[0] + this.#e[2] * this.#s[1] - this.#t[0] * this.#r[0] - this.#t[1] * this.#r[1];
+    return this.#s[1] = this.#s[0], this.#s[0] = e, this.#r[1] = this.#r[0], this.#r[0] = i, i;
   }
   /**
    * Sets new filter coefficients.
@@ -158,8 +125,8 @@ class x {
    * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
    * @returns { void }
    */
-  set(e, r) {
-    e.length = 2, this.#t.set(e), r.length = 3, this.#e.set(r);
+  set(e, i) {
+    e.length = 2, this.#t.set(e), i.length = 3, this.#e.set(i);
   }
   /**
    * Resets the filter state.
@@ -169,56 +136,59 @@ class x {
     this.#s.fill(0), this.#r.fill(0);
   }
 }
-class R {
+class N {
   #t;
   #e;
+  #s;
   /**
    * Creates an instance of the filter.
    * @param coefficients - The filter coefficients.
    */
   constructor(e) {
-    this.#t = e, this.#e = Array(e.length).fill(0);
+    this.#t = e, this.#e = Array(e.length).fill(0), this.#s = 0;
   }
+  /**
+   * Processes a single input sample.
+   * @param {number} input - The input sample.
+   * @returns {number} - The filtered output sample.
+   */
   process(e) {
-    if (Array.isArray(e))
-      return e.map((n) => this.process(n));
-    {
-      const r = e;
-      this.#e.pop(), this.#e.unshift(r);
-      let n = 0;
-      for (let s = 0; s < this.#t.length; s++)
-        n += this.#t[s] * this.#e[s];
-      return n;
+    this.#e[this.#s] = e, this.#s = (this.#s + 1) % this.#e.length;
+    let i = 0;
+    for (let g = 0; g < this.#t.length; g++) {
+      const s = (this.#s - 1 - g + this.#e.length) % this.#e.length;
+      i += this.#t[g] * this.#e[s];
     }
+    return i;
   }
   /**
    * Resets the filter state.
    * @returns { void }
    */
   reset() {
-    this.#e.fill(0);
+    this.#e.fill(0), this.#s = 0;
   }
 }
-class F {
+class I {
   #t;
   #e;
   #s;
   #r;
-  #n;
+  #i;
   /**
    * Creates a new CircularBuffer with given capacity.
    * @param { number } capacity - The maximum number of items the buffer can hold.
    */
   constructor(e) {
-    this.#e = e || 0, this.#t = new Array(e), this.#s = 0, this.#r = 0, this.#n = 0;
+    this.#e = e || 0, this.#t = new Array(e), this.#s = 0, this.#r = 0, this.#i = 0;
   }
   /**
    * Adds an item to the buffer.
-   * @param item - The item to add to the buffer.
+   * @param { T } item - The item to add to the buffer.
    * @returns { void }
    */
   push(e) {
-    this.#t[this.#r] = e, this.isFull() ? this.#s = (this.#s + 1) % this.#e : this.#n++, this.#r = (this.#r + 1) % this.#e;
+    this.#t[this.#r] = e, this.isFull() ? this.#s = (this.#s + 1) % this.#e : this.#i++, this.#r = (this.#r + 1) % this.#e;
   }
   /**
    * Removes and returns the oldest item from the buffer.
@@ -228,7 +198,7 @@ class F {
     if (this.isEmpty())
       return;
     const e = this.#t[this.#s];
-    return this.#t[this.#s] = void 0, this.#s = (this.#s + 1) % this.#e, this.#n--, e;
+    return this.#t[this.#s] = void 0, this.#s = (this.#s + 1) % this.#e, this.#i--, e;
   }
   /**
    * Returns the oldest item from the buffer without removing it.
@@ -244,33 +214,44 @@ class F {
    * @param { number } end - The ending index of the slice (exclusive).
    * @returns { T[] }
    */
-  slice(e, r) {
-    if (e >= r)
+  slice(e, i) {
+    if (e >= i)
       return [];
-    const n = [];
-    for (let s = Math.max(0, e); s < Math.min(this.#n, r); s++) {
-      const u = (this.#s + s) % this.#e;
-      n.push(this.#t[u]);
+    const g = [];
+    for (let s = Math.max(0, e); s < Math.min(this.#i, i); s++) {
+      const n = (this.#s + s) % this.#e;
+      g.push(this.#t[n]);
     }
-    return n;
+    return g;
+  }
+  /**
+   * Adds an item to the buffer and
+   * returns undefined if the buffer is not full,
+   * otherwise returns the oldest item from the buffer without removing it.
+   *
+   * @param item
+   */
+  evict(e) {
+    const i = this.isFull() ? this.peek() : void 0;
+    return this.push(e), i;
   }
   /**
    * Checks if the buffer is empty.
    * @returns { boolean }
    */
   isEmpty() {
-    return this.#n === 0;
+    return this.#i === 0;
   }
   /**
    * Checks if the buffer is full.
    * @returns { boolean }
    */
   isFull() {
-    return this.#n === this.#e;
+    return this.#i === this.#e;
   }
   /** @type { number } */
   get length() {
-    return this.#n;
+    return this.#i;
   }
   /** @type { number } */
   get capacity() {
@@ -278,44 +259,39 @@ class F {
   }
   /** @type { IterableIterator<T> } */
   *[Symbol.iterator]() {
-    for (let e = 0; e < this.#n; e++) {
-      const r = (this.#s + e) % this.#e;
-      yield this.#t[r];
+    for (let e = 0; e < this.#i; e++) {
+      const i = (this.#s + e) % this.#e;
+      yield this.#t[i];
     }
   }
 }
-class X extends AudioWorkletProcessor {
-  capacity = null;
-  interval = null;
-  lastTime = 0;
-  measurements = [];
+class j extends AudioWorkletProcessor {
+  capacity;
+  interval;
+  previousTime = 0;
+  attenuation = 10 ** (-V / 20);
+  measurements;
   kWeightingFilters = [];
-  truePeakFilters = [];
-  momentaryEnergyBuffers = [];
-  momentaryEnergyRunningSums = [];
-  momentarySampleAccumulators = [];
-  momentaryLoudnessHistories = [];
-  shortTermEnergyBuffers = [];
-  shortTermEnergyRunningSums = [];
-  shortTermLoudnessHistories = [];
-  shortTermSampleAccumulators = [];
+  overSamplingFilters = [];
+  overSampledValues = [];
+  overSampledValueDirtyFlags = [];
+  mEnergyBuffers = [];
+  mEnergySums = [];
+  mSampleAccumulators = [];
+  mTraces = [];
+  mTraceDirtyFlags = [];
+  sEnergyBuffers = [];
+  sEnergySums = [];
+  sSampleAccumulators = [];
+  sTraces = [];
+  sTraceDirtyFlags = [];
   constructor(e) {
     super();
-    const { numberOfInputs: r = 1, processorOptions: n } = e;
-    if (n) {
-      const { capacity: s, interval: u } = n;
-      this.capacity = s ?? null, this.interval = u ?? null;
-    }
-    for (let s = 0; s < r; s++)
-      this.momentaryEnergyRunningSums[s] = 0, this.momentarySampleAccumulators[s] = 0, this.momentaryEnergyBuffers[s] = new F(
-        Math.round(sampleRate * U)
-      ), this.momentaryLoudnessHistories[s] = this.capacity ? new F(
-        Math.ceil(this.capacity / G)
-      ) : [], this.shortTermEnergyRunningSums[s] = 0, this.shortTermSampleAccumulators[s] = 0, this.shortTermEnergyBuffers[s] = new F(
-        Math.round(sampleRate * Y)
-      ), this.shortTermLoudnessHistories[s] = this.capacity ? new F(
-        Math.ceil(this.capacity / B)
-      ) : [], this.measurements[s] = {
+    const { numberOfInputs: i = 1, processorOptions: g } = e, { capacity: s, interval: n } = g;
+    this.capacity = s || 0, this.interval = n || 0, this.measurements = [];
+    for (let h = 0; h < i; h++) {
+      const F = Math.round(sampleRate * P), T = Math.round(sampleRate * H), L = Math.ceil(this.capacity / M), _ = Math.ceil(this.capacity / O);
+      this.mEnergySums[h] = 0, this.mSampleAccumulators[h] = 0, this.mEnergyBuffers[h] = new I(F), this.mTraces[h] = this.capacity ? new I(L) : [], this.sEnergySums[h] = 0, this.sSampleAccumulators[h] = 0, this.sEnergyBuffers[h] = new I(T), this.sTraces[h] = this.capacity ? new I(_) : [], this.measurements[h] = {
         momentaryLoudness: Number.NEGATIVE_INFINITY,
         shortTermLoudness: Number.NEGATIVE_INFINITY,
         integratedLoudness: Number.NEGATIVE_INFINITY,
@@ -324,184 +300,159 @@ class X extends AudioWorkletProcessor {
         maximumTruePeakLevel: Number.NEGATIVE_INFINITY,
         loudnessRange: Number.NEGATIVE_INFINITY
       };
+    }
   }
-  process(e, r) {
-    const n = e.length;
-    for (let s = 0; s < n; s++) {
-      if (!e[s].length) continue;
-      const u = e[s], c = u.length, A = u[0].length, H = Object.values(
-        O[c] || O[1]
-      ), v = 10 ** (-C / 20);
-      (!this.kWeightingFilters[s] || this.kWeightingFilters[s].length !== c) && (this.kWeightingFilters[s] = Array.from(
-        { length: c },
-        () => [
-          new x(
-            d.highshelf.a,
-            d.highshelf.b
-          ),
-          new x(
-            d.highpass.a,
-            d.highpass.b
-          )
-        ]
-      )), (!this.truePeakFilters[s] || this.truePeakFilters[s].length !== c) && (this.truePeakFilters[s] = Array.from(
-        { length: c },
-        () => [
-          new R(
-            L.lowpass.phase0
-          ),
-          new R(
-            L.lowpass.phase1
-          ),
-          new R(
-            L.lowpass.phase2
-          ),
-          new R(
-            L.lowpass.phase3
-          )
-        ]
-      ));
-      for (let o = 0; o < A; o++) {
-        let i = 0;
-        for (let t = 0; t < c; t++) {
-          const h = u[t][o], [y, T] = this.kWeightingFilters[s][t], m = y.process(h), f = T.process(m) ** 2, w = H[t] ?? 1;
-          i += f * w;
-          const P = u[t][o] * v, k = sampleRate >= 96e3 ? 2 : 4, b = [];
-          for (let N = 0; N < k; N++) {
-            const D = this.truePeakFilters[s][t][N];
-            b.push(Math.abs(D.process(P)));
+  process(e, i, g) {
+    for (let s = 0; s < e.length; s++) {
+      if (!e[s].length)
+        continue;
+      const n = e[s].length, h = e[s][0].length, F = sampleRate >= 96e3 ? 2 : 4, T = B[n], L = this.mEnergyBuffers[s].capacity, _ = this.sEnergyBuffers[s].capacity;
+      if (!this.kWeightingFilters[s] || this.kWeightingFilters[s].length !== n) {
+        const { highshelf: o, highpass: t } = x;
+        this.kWeightingFilters[s] = this.kWeightingFilters[s] || [];
+        for (let a = 0; a < n; a++)
+          this.kWeightingFilters[s][a] = [
+            new D(o.a, o.b),
+            new D(t.a, t.b)
+          ];
+      }
+      if (!this.overSamplingFilters[s] || this.overSamplingFilters[s].length !== n) {
+        const { lowpass: o } = C, { phase0: t, phase1: a, phase2: f, phase3: u } = o;
+        this.overSamplingFilters[s] = this.overSamplingFilters[s] || [];
+        for (let l = 0; l < n; l++)
+          this.overSamplingFilters[s][l] = [
+            new N(t),
+            new N(a),
+            new N(f),
+            new N(u)
+          ];
+      }
+      for (let o = 0; o < h; o++) {
+        let t = 0;
+        for (let u = 0; u < n; u++) {
+          const l = e[s][u][o], [m, r] = this.kWeightingFilters[s][u], E = m.process(l), y = r.process(E), S = y * y, c = T[u] ?? 1;
+          t += S * c;
+          const d = l * this.attenuation;
+          let p = 0;
+          for (let v = 0; v < F; v++) {
+            const w = this.overSamplingFilters[s][u][v], G = Math.abs(w.process(d));
+            p < G && (p = G);
           }
-          const W = 20 * Math.log10(Math.max(...b)) + C, V = this.measurements[s].maximumTruePeakLevel;
-          this.measurements[s].maximumTruePeakLevel = Math.max(
-            V,
-            W
-          );
+          this.overSampledValues[s] !== void 0 ? p > this.overSampledValues[s] && (this.overSampledValues[s] = p, this.overSampledValueDirtyFlags[s] = !0) : (this.overSampledValues[s] = p, this.overSampledValueDirtyFlags[s] = !0);
         }
-        const g = i, E = this.momentaryEnergyBuffers[s].peek() ?? 0, I = this.momentaryEnergyBuffers[s].isFull() ? E : 0;
-        this.momentaryEnergyRunningSums[s] += g - I, this.momentaryEnergyBuffers[s].push(g);
-        const p = this.shortTermEnergyBuffers[s].peek() ?? 0, l = this.shortTermEnergyBuffers[s].isFull() ? p : 0;
-        if (this.shortTermEnergyRunningSums[s] += g - l, this.shortTermEnergyBuffers[s].push(g), this.momentaryEnergyBuffers[s].isFull()) {
-          const t = this.momentaryEnergyRunningSums[s] / this.momentaryEnergyBuffers[s].capacity, h = this.#s(t);
-          this.measurements[s].momentaryLoudness = h, this.measurements[s].maximumMomentaryLoudness = Math.max(
-            this.measurements[s].maximumMomentaryLoudness,
-            h
-          );
+        const a = this.mEnergyBuffers[s].evict(t) ?? 0;
+        this.mEnergySums[s] += t - a;
+        const f = this.sEnergyBuffers[s].evict(t) ?? 0;
+        if (this.sEnergySums[s] += t - f, this.mEnergyBuffers[s].isFull()) {
+          const u = this.mEnergySums[s] / L, l = this.energyToLoudness(u), m = this.measurements[s].maximumMomentaryLoudness, r = Math.max(l, m);
+          this.measurements[s].momentaryLoudness = l, this.measurements[s].maximumMomentaryLoudness = r;
         }
       }
-      this.momentarySampleAccumulators[s] += A;
-      const _ = Math.round(
-        sampleRate * G
-      );
-      for (; this.momentarySampleAccumulators[s] >= _; ) {
-        if (this.momentaryEnergyBuffers[s].isFull()) {
-          const o = this.momentaryEnergyRunningSums[s] / this.momentaryEnergyBuffers[s].capacity, i = this.#s(o);
-          this.momentaryLoudnessHistories[s].push(i);
+      this.mSampleAccumulators[s] += h, this.sSampleAccumulators[s] += h;
+      const R = Math.round(sampleRate * M), b = Math.round(sampleRate * O);
+      for (; this.mSampleAccumulators[s] >= R; ) {
+        if (this.mEnergyBuffers[s].isFull()) {
+          const o = this.mEnergySums[s] / L, t = this.energyToLoudness(o);
+          this.mTraces[s].push(t), this.mTraceDirtyFlags[s] = !0;
         }
-        this.momentarySampleAccumulators[s] -= _;
+        this.mSampleAccumulators[s] -= R;
       }
-      this.shortTermSampleAccumulators[s] += A;
-      const M = Math.round(
-        sampleRate * B
-      );
-      for (; this.shortTermSampleAccumulators[s] >= M; ) {
-        if (this.shortTermEnergyBuffers[s].isFull()) {
-          const o = this.shortTermEnergyRunningSums[s] / this.shortTermEnergyBuffers[s].capacity, i = this.#s(o);
-          this.measurements[s].shortTermLoudness = i, this.measurements[s].maximumShortTermLoudness = Math.max(
-            this.measurements[s].maximumShortTermLoudness,
-            i
-          ), this.shortTermLoudnessHistories[s].push(i);
+      for (; this.sSampleAccumulators[s] >= b; ) {
+        if (this.sEnergyBuffers[s].isFull()) {
+          const o = this.sEnergySums[s] / _, t = this.energyToLoudness(o), a = this.measurements[s].maximumShortTermLoudness, f = Math.max(t, a);
+          this.measurements[s].shortTermLoudness = t, this.measurements[s].maximumShortTermLoudness = f, this.sTraces[s].push(t), this.sTraceDirtyFlags[s] = !0;
         }
-        this.shortTermSampleAccumulators[s] -= M;
+        this.sSampleAccumulators[s] -= b;
       }
-      if (this.momentaryLoudnessHistories[s].length > 2) {
-        const o = Array.from(
-          this.momentaryLoudnessHistories[s]
-        ).filter((i) => i > z);
+      if (this.mTraces[s].length > 2 && this.mTraceDirtyFlags[s]) {
+        const o = [];
+        for (const t of this.mTraces[s])
+          t > U && o.push(t);
         if (o.length > 2) {
-          const i = o.map(
-            this.#r
-          ), E = i.reduce(
-            (t, h) => t + h,
-            0
-          ) / i.length, p = this.#s(
-            E
-          ) + K, l = o.filter(
-            (t) => t > p
-          );
-          if (l.length > 2) {
-            const t = l.map(
-              this.#r
-            ), y = t.reduce(
-              (m, a) => m + a,
-              0
-            ) / t.length, T = this.#s(
-              y
-            );
-            this.measurements[s].integratedLoudness = T;
+          const t = [];
+          for (const r of o)
+            t.push(this.loudnessToEnergy(r));
+          let a = 0;
+          for (const r of t)
+            a += r;
+          const f = a / t.length, l = this.energyToLoudness(f) + Y, m = [];
+          for (const r of o)
+            r > l && m.push(r);
+          if (m.length > 2) {
+            const r = [];
+            for (const c of m)
+              r.push(this.loudnessToEnergy(c));
+            let E = 0;
+            for (const c of r)
+              E += c;
+            const y = E / r.length, S = this.energyToLoudness(y);
+            this.measurements[s].integratedLoudness = S;
           }
         }
+        this.mTraceDirtyFlags[s] = !1;
       }
-      if (this.shortTermLoudnessHistories[s].length > 2) {
-        const o = Array.from(
-          this.shortTermLoudnessHistories[s]
-        ).filter((i) => i > J);
+      if (this.sTraces[s].length > 2 && this.sTraceDirtyFlags[s]) {
+        const o = [];
+        for (const t of this.sTraces[s])
+          t > z && o.push(t);
         if (o.length > 2) {
-          const i = o.map(
-            this.#r
-          ), E = i.reduce(
-            (t, h) => t + h,
-            0
-          ) / i.length, p = this.#s(
-            E
-          ) + Q, l = o.filter(
-            (t) => t > p
-          );
-          if (l.length > 2) {
-            const t = l.toSorted(
-              (m, a) => m - a
-            ), [h, y] = [
-              j,
-              q
-            ].map((m) => {
-              const a = Math.floor(
-                m * (t.length - 1)
-              ), f = Math.ceil(
-                m * (t.length - 1)
+          const t = [];
+          for (const r of o)
+            t.push(this.loudnessToEnergy(r));
+          let a = 0;
+          for (const r of t)
+            a += r;
+          const f = a / t.length, l = this.energyToLoudness(f) + K, m = [];
+          for (const r of o)
+            r > l && m.push(r);
+          if (m.length > 2) {
+            const r = m.sort((c, d) => c - d), [E, y] = [
+              W,
+              k
+            ].map((c) => {
+              const d = Math.floor(
+                c * (r.length - 1)
+              ), p = Math.ceil(
+                c * (r.length - 1)
               );
-              return f === a ? t[a] : t[a] + (t[f] - t[a]) * (m * (t.length - 1) - a);
-            }), T = y - h;
-            this.measurements[s].loudnessRange = T;
+              return p === d ? r[d] : r[d] + (r[p] - r[d]) * (c * (r.length - 1) - d);
+            }), S = y - E;
+            this.measurements[s].loudnessRange = S;
           }
         }
+        this.sTraceDirtyFlags[s] = !1;
       }
     }
-    return this.#e(e, r), this.#t(), !0;
-  }
-  #t() {
-    if (currentTime - this.lastTime >= Number(this.interval)) {
-      const e = {
+    if (currentTime - this.previousTime >= Number(this.interval)) {
+      for (let n = 0; n < this.measurements.length; n++) {
+        const h = this.overSampledValues[n];
+        if (this.overSampledValueDirtyFlags[n]) {
+          const T = 20 * Math.log10(h) + V;
+          this.measurements[n].maximumTruePeakLevel = T, this.overSampledValueDirtyFlags[n] = !1;
+        }
+      }
+      const s = {
         currentFrame,
         currentTime,
         currentMeasurements: this.measurements
       };
-      this.port.postMessage(e), this.lastTime = currentTime;
+      this.port.postMessage(s), this.previousTime = currentTime;
     }
+    for (let s = 0; s < Math.min(e.length, i.length); s++)
+      for (let n = 0; n < Math.min(e[s].length, i[s].length); n++)
+        i[s][n].set(e[s][n]);
+    return !0;
   }
-  #e(e, r) {
-    for (let n = 0; n < Math.min(e.length, r.length); n++)
-      for (let s = 0; s < Math.min(e[n].length, r[n].length); s++)
-        r[n][s].set(e[n][s]);
-  }
-  #s(e) {
+  energyToLoudness(e) {
     return -0.691 + 10 * Math.log10(Math.max(e, Number.EPSILON));
   }
-  #r(e) {
+  loudnessToEnergy(e) {
     return 10 ** ((e + 0.691) / 10);
   }
 }
-registerProcessor("loudness-processor", X);
+registerProcessor("loudness-processor", j);
 `, t = "loudness-processor";
-class h extends AudioWorkletNode {
+class a extends AudioWorkletNode {
   constructor(n, s) {
     super(n, t, s);
   }
@@ -509,7 +460,7 @@ class h extends AudioWorkletNode {
     return r(n);
   }
 }
-async function a(e, n) {
+async function h(e, n) {
   return await r(e), new AudioWorkletNode(e, t, n);
 }
 async function r(e) {
@@ -521,6 +472,6 @@ async function r(e) {
   }
 }
 export {
-  h as LoudnessWorkletNode,
-  a as createLoudnessWorklet
+  a as LoudnessWorkletNode,
+  h as createLoudnessWorklet
 };