loudness-worklet 1.5.1 → 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
 
@@ -244,20 +242,20 @@ const worklet = new AudioWorkletNode(context, "loudness-processor", {
 Measurement results are sent back to the main thread via `port.onmessage` with the following format:
 
 ```typescript
-type AudioLoudnessSnapshot = {
+type LoudnessMeasurements = {
+  momentaryLoudness: number;
+  shortTermLoudness: number;
+  integratedLoudness: number;
+  maximumMomentaryLoudness: number;
+  maximumShortTermLoudness: number;
+  maximumTruePeakLevel: number;
+  loudnessRange: number;
+};
+
+type LoudnessSnapshot = {
   currentFrame: number;
   currentTime: number;
-  currentMetrics: [
-    {
-      momentaryLoudness: number;
-      shortTermLoudness: number;
-      integratedLoudness: number;
-      maximumMomentaryLoudness: number;
-      maximumShortTermLoudness: number;
-      maximumTruePeakLevel: number;
-      loudnessRange: number;
-    }
-  ];
+  currentMeasurements: LoudnessMeasurements[];
 };
 ```
 
@@ -271,7 +269,7 @@ type AudioLoudnessSnapshot = {
 | `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.5.1",
+  "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",
@@ -18,20 +18,22 @@
     "lufs",
     "lra",
     "javascript",
-    "typescript",
-    "lightweight"
+    "typescript"
   ],
   "type": "module",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./packages/lib/dist/index.js",
+  "types": "./packages/lib/dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./packages/lib/dist/index.d.ts",
+      "default": "./packages/lib/dist/index.js"
     }
   },
   "files": [
-    "dist"
+    "packages/lib/dist"
+  ],
+  "workspaces": [
+    "packages/*"
   ],
   "license": "MIT",
   "author": "lcweden",
@@ -44,29 +46,11 @@
     "url": "https://github.com/lcweden/loudness-worklet/issues"
   },
   "scripts": {
-    "dev": "vite --mode dev",
-    "demo": "vite --mode demo",
-    "test": "vitest",
-    "build": "vite build --mode static && vite build --mode demo",
-    "lib": "vite build --mode static && vite build --mode lib && tsc -p tsconfig.lib.json",
-    "prepare": "npm run lib",
-    "preview": "vite preview --mode demo",
-    "format": "prettier --write ."
+    "format": "biome format --write",
+    "lint": "biome lint --write"
   },
   "devDependencies": {
-    "@solidjs/router": "^0.15.3",
-    "@tailwindcss/vite": "^4.1.4",
-    "@types/audioworklet": "^0.0.85",
-    "@types/node": "^22.14.1",
-    "daisyui": "^5.0.28",
-    "echarts": "^6.0.0",
-    "prettier": "^3.5.3",
-    "prettier-plugin-tailwindcss": "^0.6.11",
-    "solid-js": "^1.9.5",
-    "tailwindcss": "^4.1.4",
-    "typescript": "~5.7.2",
-    "vite": "^6.3.1",
-    "vite-plugin-solid": "^2.11.6",
-    "vitest": "^3.2.2"
+    "@biomejs/biome": "2.3.8",
+    "@types/node": "^24.10.1"
   }
 }

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

@@ -0,0 +1,36 @@
+export declare function createLoudnessWorklet(context: BaseAudioContext, options?: LoudnessWorkletProcessorOptions): Promise<AudioWorkletNode>;
+
+export declare type LoudnessMeasurements = {
+    momentaryLoudness: number;
+    shortTermLoudness: number;
+    integratedLoudness: number;
+    maximumMomentaryLoudness: number;
+    maximumShortTermLoudness: number;
+    maximumTruePeakLevel: number;
+    loudnessRange: number;
+};
+
+export declare type LoudnessProcessorOptions = {
+    capacity?: number;
+    interval?: number;
+};
+
+export declare type LoudnessSnapshot = {
+    currentFrame: number;
+    currentTime: number;
+    currentMeasurements: LoudnessMeasurements[];
+};
+
+export declare class LoudnessWorkletNode extends AudioWorkletNode {
+    constructor(context: BaseAudioContext, options?: LoudnessWorkletProcessorOptions);
+    static loadModule(context: BaseAudioContext): Promise<void>;
+}
+
+export declare interface LoudnessWorkletProcessorOptions {
+    numberOfInputs?: AudioWorkletNodeOptions["numberOfInputs"];
+    numberOfOutputs?: AudioWorkletNodeOptions["numberOfOutputs"];
+    outputChannelCount?: AudioWorkletNodeOptions["outputChannelCount"];
+    processorOptions?: LoudnessProcessorOptions;
+}
+
+export { }

package/packages/lib/dist/index.js

@@ -0,0 +1,477 @@
+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] }
+}, C = {
+  lowpass: {
+    phase0: [
+      0.001708984375,
+      0.010986328125,
+      -0.0196533203125,
+      0.033203125,
+      -0.0594482421875,
+      0.1373291015625,
+      0.97216796875,
+      -0.102294921875,
+      0.047607421875,
+      -0.026611328125,
+      0.014892578125,
+      -0.00830078125
+    ],
+    phase1: [
+      -0.0291748046875,
+      0.029296875,
+      -0.0517578125,
+      0.089111328125,
+      -0.16650390625,
+      0.465087890625,
+      0.77978515625,
+      -0.2003173828125,
+      0.1015625,
+      -0.0582275390625,
+      0.0330810546875,
+      -0.0189208984375
+    ],
+    phase2: [
+      -0.0189208984375,
+      0.0330810546875,
+      -0.0582275390625,
+      0.1015625,
+      -0.2003173828125,
+      0.77978515625,
+      0.465087890625,
+      -0.16650390625,
+      0.089111328125,
+      -0.0517578125,
+      0.029296875,
+      -0.0291748046875
+    ],
+    phase3: [
+      -0.00830078125,
+      0.014892578125,
+      -0.026611328125,
+      0.047607421875,
+      -0.102294921875,
+      0.97216796875,
+      0.1373291015625,
+      -0.0594482421875,
+      0.033203125,
+      -0.0196533203125,
+      0.010986328125,
+      0.001708984375
+    ]
+  }
+}, 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);
+  #r = new Float32Array(2);
+  /**
+   * Creates a new BiquadraticFilter with given coefficients.
+   * @param { number[] } a - Feedback coefficients [a1, a2]
+   * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
+   */
+  constructor(e, i) {
+    this.reset(), this.set(e, i);
+  }
+  /**
+   * Processes a single input sample and returns the filtered output.
+   * @param { number } input - The input sample.
+   * @returns { number } - The filtered output sample.
+   */
+  process(e) {
+    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.
+   * @param { number[] } a - Feedback coefficients [a1, a2]
+   * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
+   * @returns { void }
+   */
+  set(e, i) {
+    e.length = 2, this.#t.set(e), i.length = 3, this.#e.set(i);
+  }
+  /**
+   * Resets the filter state.
+   * @returns { void }
+   */
+  reset() {
+    this.#s.fill(0), this.#r.fill(0);
+  }
+}
+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.#s = 0;
+  }
+  /**
+   * Processes a single input sample.
+   * @param {number} input - The input sample.
+   * @returns {number} - The filtered output sample.
+   */
+  process(e) {
+    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.#s = 0;
+  }
+}
+class I {
+  #t;
+  #e;
+  #s;
+  #r;
+  #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.#i = 0;
+  }
+  /**
+   * Adds an item 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.#i++, this.#r = (this.#r + 1) % this.#e;
+  }
+  /**
+   * Removes and returns the oldest item from the buffer.
+   * @returns { T | undefined }
+   */
+  pop() {
+    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.#i--, e;
+  }
+  /**
+   * Returns the oldest item from the buffer without removing it.
+   * @returns { T | undefined }
+   */
+  peek() {
+    if (!this.isEmpty())
+      return this.#t[this.#s];
+  }
+  /**
+   * Returns a slice of the buffer contents.
+   * @param { number } start - The starting index of the slice (inclusive).
+   * @param { number } end - The ending index of the slice (exclusive).
+   * @returns { T[] }
+   */
+  slice(e, i) {
+    if (e >= i)
+      return [];
+    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 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.#i === 0;
+  }
+  /**
+   * Checks if the buffer is full.
+   * @returns { boolean }
+   */
+  isFull() {
+    return this.#i === this.#e;
+  }
+  /** @type { number } */
+  get length() {
+    return this.#i;
+  }
+  /** @type { number } */
+  get capacity() {
+    return this.#e;
+  }
+  /** @type { IterableIterator<T> } */
+  *[Symbol.iterator]() {
+    for (let e = 0; e < this.#i; e++) {
+      const i = (this.#s + e) % this.#e;
+      yield this.#t[i];
+    }
+  }
+}
+class j extends AudioWorkletProcessor {
+  capacity;
+  interval;
+  previousTime = 0;
+  attenuation = 10 ** (-V / 20);
+  measurements;
+  kWeightingFilters = [];
+  overSamplingFilters = [];
+  overSampledValues = [];
+  overSampledValueDirtyFlags = [];
+  mEnergyBuffers = [];
+  mEnergySums = [];
+  mSampleAccumulators = [];
+  mTraces = [];
+  mTraceDirtyFlags = [];
+  sEnergyBuffers = [];
+  sEnergySums = [];
+  sSampleAccumulators = [];
+  sTraces = [];
+  sTraceDirtyFlags = [];
+  constructor(e) {
+    super();
+    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,
+        maximumMomentaryLoudness: Number.NEGATIVE_INFINITY,
+        maximumShortTermLoudness: Number.NEGATIVE_INFINITY,
+        maximumTruePeakLevel: Number.NEGATIVE_INFINITY,
+        loudnessRange: Number.NEGATIVE_INFINITY
+      };
+    }
+  }
+  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);
+          }
+          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 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.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.mSampleAccumulators[s] -= R;
+      }
+      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.sSampleAccumulators[s] -= b;
+      }
+      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 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.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 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 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;
+      }
+    }
+    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(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;
+  }
+  energyToLoudness(e) {
+    return -0.691 + 10 * Math.log10(Math.max(e, Number.EPSILON));
+  }
+  loudnessToEnergy(e) {
+    return 10 ** ((e + 0.691) / 10);
+  }
+}
+registerProcessor("loudness-processor", j);
+`, t = "loudness-processor";
+class a extends AudioWorkletNode {
+  constructor(n, s) {
+    super(n, t, s);
+  }
+  static async loadModule(n) {
+    return r(n);
+  }
+}
+async function h(e, n) {
+  return await r(e), new AudioWorkletNode(e, t, n);
+}
+async function r(e) {
+  const n = new Blob([i], { type: "application/javascript" }), s = URL.createObjectURL(n);
+  try {
+    await e.audioWorklet.addModule(s);
+  } finally {
+    URL.revokeObjectURL(s);
+  }
+}
+export {
+  a as LoudnessWorkletNode,
+  h as createLoudnessWorklet
+};

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-interface LoudnessWorkletProcessorOptions {
-    numberOfInputs?: AudioWorkletNodeOptions["numberOfInputs"];
-    numberOfOutputs?: AudioWorkletNodeOptions["numberOfOutputs"];
-    outputChannelCount?: AudioWorkletNodeOptions["outputChannelCount"];
-    processorOptions?: {
-        interval?: number;
-        capacity?: number;
-    };
-}
-declare class LoudnessWorkletNode extends AudioWorkletNode {
-    constructor(context: BaseAudioContext, options?: LoudnessWorkletProcessorOptions);
-    static loadModule(context: BaseAudioContext): Promise<void>;
-}
-declare function createLoudnessWorklet(context: BaseAudioContext, options?: LoudnessWorkletProcessorOptions): Promise<AudioWorkletNode>;
-export { createLoudnessWorklet, LoudnessWorkletNode };

package/dist/index.js

@@ -1,442 +0,0 @@
-const i = `/**
- * A lightweight and efficient AudioWorklet for real-time loudness measurement in the browser, compliant with the ITU-R BS.1770-5 standard.
- *
- * @file loudness.worklet.js
- * @version 1.5.1
- * @author lcweden
- * @license MIT
- * @see https://github.com/lcweden/loudness-worklet.git
- * @date 2025-11-18T12:38:50.840Z
- */\r
-\r
-class O {
-  #t = new Float32Array(2);
-  #e = new Float32Array(3);
-  #s = new Float32Array(2);
-  #r = new Float32Array(2);
-  /**
-   * Creates a new BiquadraticFilter with given coefficients.
-   * @param { number[] } a - Feedback coefficients [a1, a2]
-   * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
-   */
-  constructor(e, r) {
-    this.reset(), this.set(e, r);
-  }
-  /**
-   * Processes a single input sample and returns the filtered output.
-   * @param { number } input - The input sample.
-   * @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;
-  }
-  /**
-   * Sets new filter coefficients.
-   * @param { number[] } a - Feedback coefficients [a1, a2]
-   * @param { number[] } b - Feedforward coefficients [b0, b1, b2]
-   * @returns { void }
-   */
-  set(e, r) {
-    this.#t.set((e.length = 2, e)), this.#e.set((r.length = 3, r));
-  }
-  /**
-   * Resets the filter state.
-   * @returns { void }
-   */
-  reset() {
-    this.#s.fill(0), this.#r.fill(0);
-  }
-}
-class d {
-  #t;
-  #e;
-  #s = 0;
-  #r = 0;
-  #n = 0;
-  /**
-   * 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);
-  }
-  /**
-   * Adds an item to the buffer.
-   * @param 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;
-  }
-  /**
-   * Removes and returns the oldest item from the buffer.
-   * @returns { T | undefined }
-   */
-  pop() {
-    if (this.isEmpty())
-      return;
-    const e = this.#t[this.#s];
-    return this.#s = (this.#s + 1) % this.#e, this.#n--, e;
-  }
-  /**
-   * Returns the oldest item from the buffer without removing it.
-   * @returns { T | undefined }
-   */
-  peek() {
-    if (!this.isEmpty())
-      return this.#t[this.#s];
-  }
-  /**
-   * Returns a slice of the buffer contents.
-   * @param { number } start - The starting index of the slice (inclusive).
-   * @param { number } end - The ending index of the slice (exclusive).
-   * @returns { T[] }
-   */
-  slice(e = 0, r = this.#n) {
-    if (e < 0 && (e = 0), r > this.#n && (r = this.#n), e >= r)
-      return [];
-    const n = [];
-    for (let s = e; s < r; s++) {
-      const u = (this.#s + s) % this.#e;
-      n.push(this.#t[u]);
-    }
-    return n;
-  }
-  /**
-   * Checks if the buffer is empty.
-   * @returns { boolean }
-   */
-  isEmpty() {
-    return this.#n === 0;
-  }
-  /**
-   * Checks if the buffer is full.
-   * @returns { boolean }
-   */
-  isFull() {
-    return this.#n === this.#e;
-  }
-  /** @type { number } */
-  get length() {
-    return this.#n;
-  }
-  /** @type { number } */
-  get capacity() {
-    return this.#e;
-  }
-  /** @type { IterableIterator<T> } */
-  *[Symbol.iterator]() {
-    for (let e = 0; e < this.#n; e++) {
-      const r = (this.#s + e) % this.#e;
-      yield this.#t[r];
-    }
-  }
-}
-const L = {
-  highshelf: { a: [-1.69065929318241, 0.73248077421585], b: [1.53512485958697, -2.69169618940638, 1.19839281085285] },
-  highpass: { a: [-1.99004745483398, 0.99007225036621], b: [1, -2, 1] }
-}, R = {
-  lowpass: {
-    phase0: [
-      0.001708984375,
-      0.010986328125,
-      -0.0196533203125,
-      0.033203125,
-      -0.0594482421875,
-      0.1373291015625,
-      0.97216796875,
-      -0.102294921875,
-      0.047607421875,
-      -0.026611328125,
-      0.014892578125,
-      -0.00830078125
-    ],
-    phase1: [
-      -0.0291748046875,
-      0.029296875,
-      -0.0517578125,
-      0.089111328125,
-      -0.16650390625,
-      0.465087890625,
-      0.77978515625,
-      -0.2003173828125,
-      0.1015625,
-      -0.0582275390625,
-      0.0330810546875,
-      -0.0189208984375
-    ],
-    phase2: [
-      -0.0189208984375,
-      0.0330810546875,
-      -0.0582275390625,
-      0.1015625,
-      -0.2003173828125,
-      0.77978515625,
-      0.465087890625,
-      -0.16650390625,
-      0.089111328125,
-      -0.0517578125,
-      0.029296875,
-      -0.0291748046875
-    ],
-    phase3: [
-      -0.00830078125,
-      0.014892578125,
-      -0.026611328125,
-      0.047607421875,
-      -0.102294921875,
-      0.97216796875,
-      0.1373291015625,
-      -0.0594482421875,
-      0.033203125,
-      -0.0196533203125,
-      0.010986328125,
-      0.001708984375
-    ]
-  }
-}, G = {
-  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, B = 0.1, Y = 3, C = 0.1, j = 0.1, q = 0.95, w = 12.04, z = -70, K = -10, J = -70, Q = -20;
-class F {
-  #t;
-  #e;
-  /**
-   * Creates an instance of the filter.
-   * @param coefficients - The filter coefficients.
-   */
-  constructor(e) {
-    this.#t = e, this.#e = Array(e.length).fill(0);
-  }
-  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;
-    }
-  }
-  /**
-   * Resets the filter state.
-   * @returns { void }
-   */
-  reset() {
-    this.#e.fill(0);
-  }
-}
-class X extends AudioWorkletProcessor {
-  capacity = null;
-  interval = null;
-  lastTime = 0;
-  metrics = [];
-  kWeightingFilters = [];
-  truePeakFilters = [];
-  momentaryEnergyBuffers = [];
-  momentaryEnergyRunningSums = [];
-  momentarySampleAccumulators = [];
-  momentaryLoudnessHistories = [];
-  shortTermEnergyBuffers = [];
-  shortTermEnergyRunningSums = [];
-  shortTermLoudnessHistories = [];
-  shortTermSampleAccumulators = [];
-  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 d(Math.round(sampleRate * U)), this.momentaryLoudnessHistories[s] = this.capacity ? new d(Math.ceil(this.capacity / B)) : new Array(), this.shortTermEnergyRunningSums[s] = 0, this.shortTermSampleAccumulators[s] = 0, this.shortTermEnergyBuffers[s] = new d(Math.round(sampleRate * Y)), this.shortTermLoudnessHistories[s] = this.capacity ? new d(Math.ceil(this.capacity / C)) : new Array(), this.metrics[s] = {
-        momentaryLoudness: Number.NEGATIVE_INFINITY,
-        shortTermLoudness: Number.NEGATIVE_INFINITY,
-        integratedLoudness: Number.NEGATIVE_INFINITY,
-        maximumMomentaryLoudness: Number.NEGATIVE_INFINITY,
-        maximumShortTermLoudness: Number.NEGATIVE_INFINITY,
-        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(G[c] || G[1]), x = Math.pow(10, -w / 20);
-      (!this.kWeightingFilters[s] || this.kWeightingFilters[s].length !== c) && (this.kWeightingFilters[s] = Array.from({ length: c }, () => [
-        new O(L.highshelf.a, L.highshelf.b),
-        new O(L.highpass.a, L.highpass.b)
-      ])), (!this.truePeakFilters[s] || this.truePeakFilters[s].length !== c) && (this.truePeakFilters[s] = Array.from({ length: c }, () => [
-        new F(R.lowpass.phase0),
-        new F(R.lowpass.phase1),
-        new F(R.lowpass.phase2),
-        new F(R.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, v = H[t] ?? 1;
-          i += f * v;
-          const P = u[t][o] * x, 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)));
-          }
-          const W = 20 * Math.log10(Math.max(...b)) + w, V = this.metrics[s].maximumTruePeakLevel;
-          this.metrics[s].maximumTruePeakLevel = Math.max(V, W);
-        }
-        const g = i, p = this.momentaryEnergyBuffers[s].peek() ?? 0, I = this.momentaryEnergyBuffers[s].isFull() ? p : 0;
-        this.momentaryEnergyRunningSums[s] += g - I, this.momentaryEnergyBuffers[s].push(g);
-        const E = this.shortTermEnergyBuffers[s].peek() ?? 0, l = this.shortTermEnergyBuffers[s].isFull() ? E : 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.metrics[s].momentaryLoudness = h, this.metrics[s].maximumMomentaryLoudness = Math.max(
-            this.metrics[s].maximumMomentaryLoudness,
-            h
-          );
-        }
-      }
-      this.momentarySampleAccumulators[s] += A;
-      const _ = Math.round(sampleRate * B);
-      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.momentarySampleAccumulators[s] -= _;
-      }
-      this.shortTermSampleAccumulators[s] += A;
-      const M = Math.round(sampleRate * C);
-      for (; this.shortTermSampleAccumulators[s] >= M; ) {
-        if (this.shortTermEnergyBuffers[s].isFull()) {
-          const o = this.shortTermEnergyRunningSums[s] / this.shortTermEnergyBuffers[s].capacity, i = this.#s(o);
-          this.metrics[s].shortTermLoudness = i, this.metrics[s].maximumShortTermLoudness = Math.max(
-            this.metrics[s].maximumShortTermLoudness,
-            i
-          ), this.shortTermLoudnessHistories[s].push(i);
-        }
-        this.shortTermSampleAccumulators[s] -= M;
-      }
-      if (this.momentaryLoudnessHistories[s].length > 2) {
-        const o = Array.from(this.momentaryLoudnessHistories[s]).filter(
-          (i) => i > z
-        );
-        if (o.length > 2) {
-          const i = o.map(this.#r), p = i.reduce((t, h) => t + h, 0) / i.length, E = this.#s(p) + K, l = o.filter((t) => t > E);
-          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.metrics[s].integratedLoudness = T;
-          }
-        }
-      }
-      if (this.shortTermLoudnessHistories[s].length > 2) {
-        const o = Array.from(this.shortTermLoudnessHistories[s]).filter(
-          (i) => i > J
-        );
-        if (o.length > 2) {
-          const i = o.map(this.#r), p = i.reduce((t, h) => t + h, 0) / i.length, E = this.#s(p) + Q, l = o.filter((t) => t > E);
-          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));
-              return f === a ? t[a] : t[a] + (t[f] - t[a]) * (m * (t.length - 1) - a);
-            }), T = y - h;
-            this.metrics[s].loudnessRange = T;
-          }
-        }
-      }
-    }
-    return this.#e(e, r), this.#t(), !0;
-  }
-  #t() {
-    if (currentTime - this.lastTime >= Number(this.interval)) {
-      const e = { currentFrame, currentTime, currentMetrics: this.metrics };
-      this.port.postMessage(e), this.lastTime = currentTime;
-    }
-  }
-  #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) {
-    return -0.691 + 10 * Math.log10(Math.max(e, Number.EPSILON));
-  }
-  #r(e) {
-    return Math.pow(10, (e + 0.691) / 10);
-  }
-}
-registerProcessor("loudness-processor", X);
-`, t = "loudness-processor";
-class h extends AudioWorkletNode {
-  constructor(n, s) {
-    super(n, t, s);
-  }
-  static async loadModule(n) {
-    return r(n);
-  }
-}
-async function o(e, n) {
-  return await r(e), new AudioWorkletNode(e, t, n);
-}
-async function r(e) {
-  const n = new Blob([i], { type: "application/javascript" }), s = URL.createObjectURL(n);
-  try {
-    await e.audioWorklet.addModule(s);
-  } finally {
-    URL.revokeObjectURL(s);
-  }
-}
-export {
-  h as LoudnessWorkletNode,
-  o as createLoudnessWorklet
-};