loudness-worklet 1.5.0 → 1.6.0

package/README.md

@@ -1,13 +1,13 @@
 # Loudness Audio Worklet Processor
 
 [![npm version](https://img.shields.io/npm/v/loudness-worklet.svg)](https://www.npmjs.com/package/loudness-worklet)
-[![license](https://img.shields.io/github/license/lcweden/loudness-audio-worklet-processor.svg)](LICENSE)
+[![license](https://img.shields.io/github/license/lcweden/loudness-worklet.svg)](LICENSE)
 
 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-audio-worklet-processor/blob/main/public/screenshots/meter.png)](https://lcweden.github.io/loudness-audio-worklet-processor/)
+[![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-audio-worklet-processor/">Demo</a></p>
+<p align="center"><a href="https://lcweden.github.io/loudness-worklet/">Demo</a></p>
 
 ## Features
 
@@ -23,17 +23,19 @@ A loudness meter for the `Web Audio API`, based on the [ITU-R BS.1770-5](https:/
 Import directly in your code:
 
 ```javascript
-const module = new URL("https://lcweden.github.io/loudness-audio-worklet-processor/loudness.worklet.js");
-audioContext.audioWorklet.addModule(module);
+const module = "https://lcweden.github.io/loudness-worklet/loudness.worklet.js";
+await audioContext.audioWorklet.addModule(module);
+const worklet = new AudioWorkletNode(audioContext, "loudness-processor");
 ```
 
 ### Download
 
-1. Download the pre-built file: [loudness.worklet.js](https://lcweden.github.io/loudness-audio-worklet-processor/loudness.worklet.js).
+1. Download the pre-built file: [loudness.worklet.js](https://lcweden.github.io/loudness-worklet/loudness.worklet.js).
 2. Place `loudness.worklet.js` in your project directory (e.g., `/public/`).
 
 ```javascript
-audioContext.audioWorklet.addModule("loudness.worklet.js");
+await audioContext.audioWorklet.addModule("loudness.worklet.js");
+const worklet = new AudioWorkletNode(audioContext, "loudness-processor");
 ```
 
 ### NPM
@@ -49,23 +51,61 @@ Use helper functions to create and load the worklet:
 ```javascript
 import { createLoudnessWorklet, LoudnessWorkletNode } from "loudness-worklet";
 
-const worklet = await createLoudnessWorklet(audioContext, {
-  processorOptions: {
-    interval: 0.1,
-    capacity: 600
-  }
-});
+const worklet = await createLoudnessWorklet(audioContext);
 
 // or
 
 await LoudnessWorkletNode.loadModule(audioContext);
+const worklet = new LoudnessWorkletNode(audioContext);
+```
 
-const worklet = new LoudnessWorkletNode(audioContext, {
-  processorOptions: {
-    interval: 0.1,
-    capacity: 600
-  }
-});
+## Concepts
+
+### Contexts
+
+Provide the execution environment for audio processing.
+
+#### AudioContext
+
+`AudioContext` is used for real-time audio processing, such as live audio input from a microphone or media stream.
+
+#### OfflineAudioContext
+
+`OfflineAudioContext` is used for processing audio data offline, allowing for rendering and analysis without requiring real-time playback.
+
+### Nodes
+
+Nodes are the building blocks of an audio graph, representing audio sources, processing modules, and destinations. The following nodes are commonly used as a source input:
+
+#### AudioBufferSourceNode
+
+`AudioBufferSourceNode` is used to play audio data stored in an `AudioBuffer`, typically for pre-recorded audio files.
+
+```javascript
+const audioContext = new AudioContext();
+const arrayBuffer = await file.arrayBuffer();
+const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+const bufferSource = new AudioBufferSourceNode(audioContext, { buffer: audioBuffer });
+```
+
+#### MediaStreamAudioSourceNode
+
+`MediaStreamAudioSourceNode` is used to play audio from a `MediaStream`, such as a live microphone input or a video element.
+
+```javascript
+const audioContext = new AudioContext();
+const mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+const mediaStreamSource = new MediaStreamAudioSourceNode(audioContext, { mediaStream });
+```
+
+#### MediaElementAudioSourceNode
+
+`MediaElementAudioSourceNode` is used to play audio from an HTML `<audio>` or `<video>` element.
+
+```javascript
+const audioContext = new AudioContext();
+const mediaElement = document.querySelector("audio");
+const elementSource = new MediaElementAudioSourceNode(audioContext, { mediaElement });
 ```
 
 ## Quick Start
@@ -75,13 +115,13 @@ const worklet = new LoudnessWorkletNode(audioContext, {
 This example shows the easiest way to get started with the Loudness Audio Worklet Processor.
 
 ```html
-<!doctype html>
+<!DOCTYPE html>
 <html>
   <body>
     <button>Share Screen</button>
     <pre></pre>
     <script>
-      const script = "https://lcweden.github.io/loudness-audio-worklet-processor/loudness.worklet.js";
+      const module = "https://lcweden.github.io/loudness-worklet/loudness.worklet.js";
       const button = document.querySelector("button");
       const pre = document.querySelector("pre");
 
@@ -91,15 +131,15 @@ This example shows the easiest way to get started with the Loudness Audio Workle
         const context = new AudioContext();
 
         // Load the loudness worklet processor
-        await context.audioWorklet.addModule(script);
+        await context.audioWorklet.addModule(module);
 
         // Create the audio node from the stream
         const source = new MediaStreamAudioSourceNode(context, { mediaStream });
         // Create the loudness worklet node
         const worklet = new AudioWorkletNode(context, "loudness-processor", {
           processorOptions: {
-            interval: 0.1,
-            capacity: 600 // it means 1 minute of history can be stored
+            interval: 0.1, // every 0.1s a message will be sent
+            capacity: 600 // 1 minute of history can be stored
           }
         });
 
@@ -117,65 +157,53 @@ This example shows the easiest way to get started with the Loudness Audio Workle
 
 ### File-based measurement
 
-Suppose you already have an audio file (e.g., from an input[type="file"]):
+You can measure the loudness of audio files using `OfflineAudioContext`.
 
 ```javascript
-const arrayBuffer = await file.arrayBuffer();
-const audioBuffer = await new AudioContext().decodeAudioData(arrayBuffer);
+import { LoudnessWorkletNode } from "loudness-worklet";
 
-const { numberOfChannels, length, sampleRate } = audioBuffer;
-const context = new OfflineAudioContext(numberOfChannels, length, sampleRate);
-
-await context.audioWorklet.addModule("loudness.worklet.js");
-
-const source = new AudioBufferSourceNode(context, { buffer: audioBuffer });
-const worklet = new AudioWorkletNode(context, "loudness-processor");
-
-// Or using the helper function
-//
-// import { createLoudnessWorklet } from "loudness-worklet";
-//
-// const worklet = await createLoudnessWorklet(audioContext, {
-//   processorOptions: {
-//     interval: 0.1,
-//     capacity: 600
-//    }
-//  });
-
-worklet.port.onmessage = (event) => {
-  console.log("Loudness Data:", event.data);
-};
+const input = document.querySelector("input");
+
+input.addEventListener("change", async (event) => {
+  const file = event.target.files[0];
+  const arrayBuffer = await file.arrayBuffer();
+  const audioBuffer = await new AudioContext().decodeAudioData(arrayBuffer);
+  const { numberOfChannels, length, sampleRate } = audioBuffer;
+  const context = new OfflineAudioContext(numberOfChannels, length, sampleRate);
+
+  await LoudnessWorkletNode.loadModule(context);
+
+  const source = new AudioBufferSourceNode(context, { buffer: audioBuffer });
+  const worklet = new LoudnessWorkletNode(context);
+
+  worklet.port.onmessage = (event) => console.log("Loudness Data:", event.data);
 
-source.connect(worklet).connect(context.destination);
-source.start();
+  source.connect(worklet).connect(context.destination);
+  source.start();
 
-context.startRendering();
+  await context.startRendering();
+});
 ```
 
 ### Live-based measurement
 
-Supports `MediaStream` or `MediaElement` sources:
+Supports all kinds of audio input.
 
 ```javascript
-const context = new AudioContext({ sampleRate: 48000 });
-
-await context.audioWorklet.addModule("loudness.worklet.js");
+import { createLoudnessWorklet } from "loudness-worklet";
 
-const audioTrack = mediaStream.getAudioTracks()[0];
-const { channelCount } = audioTrack.getSettings();
-
-const source = new MediaStreamAudioSourceNode(context, { mediaStream });
-const worklet = new AudioWorkletNode(context, "loudness-processor", {
-  processorOptions: {
-    capacity: 600 // Seconds of history to keep, prevent memory overflow
-  }
+const mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+const context = new AudioContext({ sampleRate: 48000 });
+const source = context.createMediaStreamSource(mediaStream);
+const worklet = await createLoudnessWorklet(context, {
+  processorOptions: { interval: 1, capacity: 600 }
 });
 
-worklet.port.onmessage = (event) => {
-  console.log("Loudness Data:", event.data);
-};
+worklet.port.onmessage = (event) => console.log("Loudness Data:", event.data);
+source.connect(worklet);
 
-source.connect(worklet).connect(context.destination);
+// worklet.connect(context.destination);
+// Optionally connect to destination for monitoring (echo)
 ```
 
 ## API
@@ -196,6 +224,8 @@ The `AudioWorkletNode` constructor accepts the following options:
 
 #### Example
 
+Most of the time, you only need to set `processorOptions`.
+
 ```javascript
 const { numberOfChannels, length, sampleRate } = audioBuffer;
 const worklet = new AudioWorkletNode(context, "loudness-processor", {
@@ -214,20 +244,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[];
 };
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loudness-worklet",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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,55 +18,39 @@
     "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",
-  "homepage": "https://lcweden.github.io/loudness-audio-worklet-processor/",
+  "homepage": "https://lcweden.github.io/loudness-worklet/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/lcweden/loudness-audio-worklet-processor.git"
+    "url": "https://github.com/lcweden/loudness-worklet.git"
   },
   "bugs": {
-    "url": "https://github.com/lcweden/loudness-audio-worklet-processor/issues"
+    "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,34 @@
+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 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?: {
+        interval?: number;
+        capacity?: number;
+    };
+}
+
+export { }

package/{dist → packages/lib/dist}/index.js

@@ -1,142 +1,10 @@
-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.0
- * @author lcweden
- * @license MIT
- * @see https://github.com/lcweden/loudness-audio-worklet-processor.git
- * @date 2025-10-07T13:01:56.024Z
- */\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] },
+const i = `const d = {
+  highshelf: {
+    a: [-1.69065929318241, 0.73248077421585],
+    b: [1.53512485958697, -2.69169618940638, 1.19839281085285]
+  },
   highpass: { a: [-1.99004745483398, 0.99007225036621], b: [1, -2, 1] }
-}, R = {
+}, L = {
   lowpass: {
     phase0: [
       0.001708984375,
@@ -195,12 +63,32 @@ const L = {
       0.001708984375
     ]
   }
-}, G = {
+}, 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 },
+  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,
@@ -241,8 +129,47 @@ const L = {
     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 {
+}, 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 {
+  #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) {
+    e.length = 2, this.#t.set(e), r.length = 3, this.#e.set(r);
+  }
+  /**
+   * Resets the filter state.
+   * @returns { void }
+   */
+  reset() {
+    this.#s.fill(0), this.#r.fill(0);
+  }
+}
+class R {
   #t;
   #e;
   /**
@@ -272,11 +199,96 @@ class F {
     this.#e.fill(0);
   }
 }
+class F {
+  #t;
+  #e;
+  #s;
+  #r;
+  #n;
+  /**
+   * 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;
+  }
+  /**
+   * 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.#t[this.#s] = void 0, 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, r) {
+    if (e >= r)
+      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]);
+    }
+    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];
+    }
+  }
+}
 class X extends AudioWorkletProcessor {
   capacity = null;
   interval = null;
   lastTime = 0;
-  metrics = [];
+  measurements = [];
   kWeightingFilters = [];
   truePeakFilters = [];
   momentaryEnergyBuffers = [];
@@ -295,7 +307,15 @@ class X extends AudioWorkletProcessor {
       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] = {
+      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] = {
         momentaryLoudness: Number.NEGATIVE_INFINITY,
         shortTermLoudness: Number.NEGATIVE_INFINITY,
         integratedLoudness: Number.NEGATIVE_INFINITY,
@@ -309,42 +329,69 @@ class X extends AudioWorkletProcessor {
     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)
-      ]));
+      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, v = H[t] ?? 1;
-          i += f * v;
-          const P = u[t][o] * x, k = sampleRate >= 96e3 ? 2 : 4, b = [];
+          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)));
           }
-          const W = 20 * Math.log10(Math.max(...b)) + w, V = this.metrics[s].maximumTruePeakLevel;
-          this.metrics[s].maximumTruePeakLevel = Math.max(V, W);
+          const W = 20 * Math.log10(Math.max(...b)) + C, V = this.measurements[s].maximumTruePeakLevel;
+          this.measurements[s].maximumTruePeakLevel = Math.max(
+            V,
+            W
+          );
         }
-        const g = i, p = this.momentaryEnergyBuffers[s].peek() ?? 0, I = this.momentaryEnergyBuffers[s].isFull() ? p : 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 E = this.shortTermEnergyBuffers[s].peek() ?? 0, l = this.shortTermEnergyBuffers[s].isFull() ? E : 0;
+        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.metrics[s].momentaryLoudness = h, this.metrics[s].maximumMomentaryLoudness = Math.max(
-            this.metrics[s].maximumMomentaryLoudness,
+          this.measurements[s].momentaryLoudness = h, this.measurements[s].maximumMomentaryLoudness = Math.max(
+            this.measurements[s].maximumMomentaryLoudness,
             h
           );
         }
       }
       this.momentarySampleAccumulators[s] += A;
-      const _ = Math.round(sampleRate * B);
+      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);
@@ -353,44 +400,77 @@ class X extends AudioWorkletProcessor {
         this.momentarySampleAccumulators[s] -= _;
       }
       this.shortTermSampleAccumulators[s] += A;
-      const M = Math.round(sampleRate * C);
+      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.metrics[s].shortTermLoudness = i, this.metrics[s].maximumShortTermLoudness = Math.max(
-            this.metrics[s].maximumShortTermLoudness,
+          this.measurements[s].shortTermLoudness = i, this.measurements[s].maximumShortTermLoudness = Math.max(
+            this.measurements[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
-        );
+        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);
+          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.metrics[s].integratedLoudness = T;
+            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;
           }
         }
       }
       if (this.shortTermLoudnessHistories[s].length > 2) {
-        const o = Array.from(this.shortTermLoudnessHistories[s]).filter(
-          (i) => i > J
-        );
+        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);
+          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] = [
+            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 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;
+            this.measurements[s].loudnessRange = T;
           }
         }
       }
@@ -399,7 +479,11 @@ class X extends AudioWorkletProcessor {
   }
   #t() {
     if (currentTime - this.lastTime >= Number(this.interval)) {
-      const e = { currentFrame, currentTime, currentMetrics: this.metrics };
+      const e = {
+        currentFrame,
+        currentTime,
+        currentMeasurements: this.measurements
+      };
       this.port.postMessage(e), this.lastTime = currentTime;
     }
   }
@@ -412,12 +496,12 @@ class X extends AudioWorkletProcessor {
     return -0.691 + 10 * Math.log10(Math.max(e, Number.EPSILON));
   }
   #r(e) {
-    return Math.pow(10, (e + 0.691) / 10);
+    return 10 ** ((e + 0.691) / 10);
   }
 }
 registerProcessor("loudness-processor", X);
 `, t = "loudness-processor";
-class o extends AudioWorkletNode {
+class h extends AudioWorkletNode {
   constructor(n, s) {
     super(n, t, s);
   }
@@ -425,7 +509,7 @@ class o extends AudioWorkletNode {
     return r(n);
   }
 }
-async function h(e, n) {
+async function a(e, n) {
   return await r(e), new AudioWorkletNode(e, t, n);
 }
 async function r(e) {
@@ -437,6 +521,6 @@ async function r(e) {
   }
 }
 export {
-  o as LoudnessWorkletNode,
-  h as createLoudnessWorklet
+  h as LoudnessWorkletNode,
+  a 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 };