npm - hypnosound - Versions diffs - 1.0.0 - Mend

hypnosound 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/.nvmrc +1 -0
package/LICENSE +21 -0
package/README.md +2 -0
package/cmd.js +3 -0
package/index.html +54 -0
package/index.js +111 -0
package/package.json +29 -0
package/src/audio/energy.js +16 -0
package/src/audio/index.js +11 -0
package/src/audio/spectralCentroid.js +33 -0
package/src/audio/spectralCrest.js +19 -0
package/src/audio/spectralEntropy.js +31 -0
package/src/audio/spectralFlux.js +19 -0
package/src/audio/spectralKurtosis.js +36 -0
package/src/audio/spectralRolloff.js +21 -0
package/src/audio/spectralRoughness.js +18 -0
package/src/audio/spectralSkew.js +33 -0
package/src/audio/spectralSpread.js +40 -0
package/src/utils/calculateStats.js +194 -0

package/.nvmrc ADDED Viewed

	@@ -0,0 +1 @@
1	+ node --version

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2024 hypnodroid
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ # hypnosound
2	+ A little library for analyzing audio

package/cmd.js ADDED Viewed

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import AudioProcessor from './index.js'
+console.log(AudioProcessor)

package/index.html ADDED Viewed

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Audio Capture and Analysis</title>
+</head>
+<body>
+    <button id="start">Start Listening</button>
+    <script type="module">
+        import AudioProcessor from './index.js'
+        document.getElementById('start').addEventListener('click', async () => {
+          const a = new AudioProcessor()
+            try {
+                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+                const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                const source = audioContext.createMediaStreamSource(stream);
+                const analyser = audioContext.createAnalyser();
+                source.connect(analyser);
+                analyser.fftSize = 32768; // Or whatever size you need
+                const bufferLength = analyser.frequencyBinCount;
+                const dataArray = new Uint8Array(bufferLength);
+                const draw = () => {
+                    requestAnimationFrame(draw);
+                    analyser.getByteFrequencyData(dataArray);
+                    // This is where the magic happens, but be careful what you log...
+                    console.log({
+                      energy: a.energy(dataArray),
+                      spectralCentroid: a.spectralCentroid(dataArray),
+                      spectralCrest: a.spectralCrest(dataArray),
+                      spectralEntropy: a.spectralEntropy(dataArray),
+                      spectralFlux: a.spectralFlux(dataArray),
+                      spectralKurtosis: a.spectralKurtosis(dataArray),
+                      spectralRolloff: a.spectralRolloff(dataArray),
+                      spectralRoughness: a.spectralRoughness(dataArray),
+                      spectralSkew: a.spectralSkew(dataArray),
+                      spectralSpread: a.spectralSpread(dataArray),
+                    });
+                    // console.log(a.spectralCentroid(dataArray).value);
+                };
+                draw();
+            } catch (error) {
+                console.error('Something went wrong:', error);
+            }
+        });
+    </script>
+</body>
+</html>

package/index.js ADDED Viewed

@@ -0,0 +1,111 @@
+import { makeCalculateStats } from "./src/utils/calculateStats.js";
+import energy from "./src/audio/energy.js";
+import spectralCentroid from "./src/audio/spectralCentroid.js";
+import spectralCrest from "./src/audio/spectralCrest.js";
+import spectralEntropy from "./src/audio/spectralEntropy.js";
+import spectralFlux from "./src/audio/spectralFlux.js";
+import spectralKurtosis from "./src/audio/spectralKurtosis.js";
+import spectralRolloff from "./src/audio/spectralRolloff.js";
+import spectralRoughness from "./src/audio/spectralRoughness.js";
+import spectralSkew from "./src/audio/spectralSkew.js";
+import spectralSpread from "./src/audio/spectralSpread.js";
+class AudioProcessor {
+  constructor() {
+    this.statCalculators = {};
+    this.previousValue = {};
+    this.analyzers = {};
+    this.statCalculators.energy = makeCalculateStats();
+    this.previousValue.energy = 0;
+    this.statCalculators.spectralCentroid = makeCalculateStats();
+    this.previousValue.spectralCentroid = 0;
+    this.statCalculators.spectralCrest = makeCalculateStats();
+    this.previousValue.spectralCrest = 0;
+    this.statCalculators.spectralEntropy = makeCalculateStats();
+    this.previousValue.spectralEntropy = 0;
+    this.statCalculators.spectralFlux = makeCalculateStats();
+    this.previousValue.spectralFlux = null;
+    this.statCalculators.spectralKurtosis = makeCalculateStats();
+    this.previousValue.spectralKurtosis = 0;
+    this.statCalculators.spectralRolloff = makeCalculateStats();
+    this.previousValue.spectralRolloff = 0;
+    this.statCalculators.spectralSkew = makeCalculateStats();
+    this.previousValue.spectralSkew = 0;
+    this.statCalculators.spectralRoughness = makeCalculateStats();
+    this.previousValue.spectralRoughness = 0;
+    this.statCalculators.spectralSpread = makeCalculateStats();
+    this.previousValue.spectralSpread = 0;
+  }
+  energy = (fft) => {
+    const { value, stats } = energy(this.previousValue.energy, this.statCalculators.energy, fft);
+    this.previousValue.energy = value;
+    return { value, stats };
+  };
+  spectralCentroid = (fft) => {
+    const { value, stats } = spectralCentroid(this.previousValue.spectralCentroid, this.statCalculators.spectralCentroid, fft);
+    this.previousValue.spectralCentroid = value;
+    return { value, stats };
+  };
+  spectralCrest = (fft) => {
+    const { value, stats } = spectralCrest(this.previousValue.spectralCrest, this.statCalculators.spectralCrest, fft);
+    this.previousValue.spectralCrest = value;
+    return { value, stats };
+  };
+  spectralEntropy = (fft) => {
+    const { value, stats } = spectralEntropy(this.previousValue.spectralEntropy, this.statCalculators.spectralEntropy, fft);
+    this.previousValue.spectralEntropy = value;
+    return { value, stats };
+  };
+  spectralFlux = (fft) => {
+    const { value, stats } = spectralFlux(this.previousValue.spectralFlux, this.statCalculators.spectralFlux, fft);
+    this.previousValue.spectralFlux = new Uint8Array(fft);
+    return { value, stats };
+  };
+  spectralKurtosis = (fft) => {
+    const { value, stats } = spectralKurtosis(this.previousValue.spectralKurtosis, this.statCalculators.spectralKurtosis, fft);
+    this.previousValue.spectralKurtosis = value;
+    return { value, stats };
+  };
+  spectralRolloff = (fft) => {
+    const { value, stats } = spectralRolloff(this.previousValue.spectralRolloff, this.statCalculators.spectralRolloff, fft);
+    this.previousValue.spectralRolloff = value;
+    return { value, stats };
+  };
+  spectralRoughness = (fft) => {
+    const { value, stats } = spectralRoughness(this.previousValue.spectralRoughness, this.statCalculators.spectralRoughness, fft);
+    this.previousValue.spectralRoughness = value;
+    return { value, stats };
+  };
+  spectralSkew = (fft) => {
+    const { value, stats } = spectralSkew(this.previousValue.spectralSkew, this.statCalculators.spectralSkew, fft);
+    this.previousValue.spectralSkew = value;
+    return { value, stats };
+  };
+  spectralSpread = (fft) => {
+    const { value, stats } = spectralSpread(this.previousValue.spectralSpread, this.statCalculators.spectralSpread, fft);
+    this.previousValue.spectralSpread = value;
+    return { value, stats };
+  };
+}
+export default AudioProcessor;
+export {energy, spectralCentroid, spectralCrest, spectralEntropy, spectralFlux, spectralKurtosis, spectralRolloff, spectralRoughness, spectralSkew, spectralSpread};

package/package.json ADDED Viewed

@@ -0,0 +1,29 @@
+{
+  "name": "hypnosound",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "A small library for analyzing audio",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "live-server ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hypnodroid/hypnosound.git"
+  },
+  "keywords": [
+    "Audio",
+    "sound",
+    "music"
+  ],
+  "author": "redaphid <iam@aaronherres.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hypnodroid/hypnosound/issues"
+  },
+  "homepage": "https://github.com/hypnodroid/hypnosound#readme",
+  "devDependencies": {
+    "live-server": "^1.2.2"
+  }
+}

package/src/audio/energy.js ADDED Viewed

@@ -0,0 +1,16 @@
+export default function energy(prevValue,statCalculator, fft) {
+    const value = calculateFFTEnergy(fft)
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function calculateFFTEnergy(currentSignal) {
+    let energy = 0
+    for (let i = 0; i < currentSignal.length; i++) {
+        let normalizedValue = currentSignal[i] / currentSignal.length
+        energy += normalizedValue * normalizedValue
+    }
+    return energy * 10
+}

package/src/audio/index.js ADDED Viewed

@@ -0,0 +1,11 @@
+export * as energy from './energy'
+export * as spectralCentroid from './spectralCentroid'
+export * as spectralCrest from './spectralCrest'
+export * as spectralEntropy from './spectralEntropy'
+export * as spectralFlux from './spectralFlux'
+export * as spectralKurtosis from './spectralKurtosis'
+export * as spectralRolloff from './spectralRolloff'
+export * as spectralRoughness from './spectralRoughness'
+export * as spectralSkew from './spectralSkew'
+export * as spectralSpread from './spectralSpread'

package/src/audio/spectralCentroid.js ADDED Viewed

@@ -0,0 +1,33 @@
+export default function spectralCentroid(prevValue,statCalculator, fft) {
+    let computed = calculateSpectralCentroid(fft) // Process FFT data
+    computed *= 1.5
+    const value = computed
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function mu(i, amplitudeSpect) {
+    let numerator = 0
+    let denominator = 0
+    for (let k = 0; k < amplitudeSpect.length; k++) {
+        numerator += Math.pow(k, i) * Math.abs(amplitudeSpect[k])
+        denominator += amplitudeSpect[k]
+    }
+    if (denominator === 0) return null // Prevent division by zero
+    return numerator / denominator
+}
+function calculateSpectralCentroid(ampSpectrum) {
+    const centroid = mu(1, ampSpectrum)
+    if (centroid === null) return null
+    // Maximum centroid occurs when all energy is at the highest frequency bin
+    const maxCentroid = mu(
+        1,
+        ampSpectrum.map((val, index) => (index === ampSpectrum.length - 1 ? 1 : 0)),
+    )
+    return centroid / maxCentroid // Normalize the centroid
+}

package/src/audio/spectralCrest.js ADDED Viewed

@@ -0,0 +1,19 @@
+export default function spectralCrest(prevValue,statCalculator, fft) {
+    let computed = calculateSpectralCrest(fft) // Process FFT data
+    const value = computed * 100
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function calculateSpectralCrest(fftData) {
+    // Find the maximum amplitude in the spectrum
+    const maxAmplitude = Math.max(...fftData)
+    // Calculate the sum of all amplitudes
+    const sumAmplitudes = fftData.reduce((sum, amplitude) => sum + amplitude, 0)
+    // Calculate the Spectral Crest
+    const spectralCrest = sumAmplitudes !== 0 ? maxAmplitude / sumAmplitudes : 0
+    return spectralCrest
+}

package/src/audio/spectralEntropy.js ADDED Viewed

@@ -0,0 +1,31 @@
+export default function spectralEntropy(prevValue,statCalculator, fft) {
+    let computed = calculateSpectralEntropy(fft) // Process FFT data
+    const value = computed
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function toPowerSpectrum(fftData) {
+    return fftData.map((amplitude) => Math.pow(amplitude, 2))
+}
+function calculateSpectralEntropy(fftData) {
+    const powerSpectrum = toPowerSpectrum(fftData)
+    // Normalize the power spectrum to create a probability distribution
+    const totalPower = powerSpectrum.reduce((sum, val) => sum + val, 0)
+    if(totalPower === 0) return 0
+    const probabilityDistribution = new Float32Array(powerSpectrum.length)
+    for (let i = 0; i < powerSpectrum.length; i++) {
+        probabilityDistribution[i] = powerSpectrum[i] / totalPower
+    }
+    const entropy = probabilityDistribution.reduce((sum, prob) => {
+        if (prob > 0) {
+            const logProb = Math.log(prob);
+            return sum - prob * logProb;
+        } else {
+            return sum;
+        }
+    }, 0);
+    return entropy / Math.log(probabilityDistribution.length)
+}

package/src/audio/spectralFlux.js ADDED Viewed

@@ -0,0 +1,19 @@
+export default function spectralFlux(prevValue, statCalculator, fft) {
+        const value = calculateSpectralFlux(fft, prevValue)
+        const stats = statCalculator(value)
+        return { value, stats }
+}
+function calculateSpectralFlux(currentSignal, previousSignal) {
+    if (!previousSignal) {
+        previousSignal = new Float32Array(currentSignal.length)
+    }
+    let sf = 0
+    for (let i = 0; i < currentSignal.length; i++) {
+        const diff = Math.abs(currentSignal[i]) - Math.abs(previousSignal[i])
+        sf += (diff + Math.abs(diff)) / 2
+    }
+    return sf / 30_000
+}

package/src/audio/spectralKurtosis.js ADDED Viewed

@@ -0,0 +1,36 @@
+export default function spectralKurtosis(prevValue,statCalculator, fft) {
+    let computed = calculateSpectralKurtosis(fft) // Process FFT data
+    const value = computed * 100
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function mu(i, amplitudeSpect) {
+    let numerator = 0
+    let denominator = 0
+    for (let k = 0; k < amplitudeSpect.length; k++) {
+        numerator += Math.pow(k, i) * Math.abs(amplitudeSpect[k])
+        denominator += amplitudeSpect[k]
+    }
+    if (denominator === 0) return null // Prevent division by zero
+    return numerator / denominator
+}
+function calculateSpectralKurtosis(fftData) {
+    const mean = mu(1, fftData)
+    const secondMoment = mu(2, fftData)
+    const variance = secondMoment - Math.pow(mean, 2)
+    let fourthMoment = 0
+    for (let i = 0; i < fftData.length; i++) {
+        fourthMoment += Math.pow(fftData[i] - mean, 4)
+    }
+    fourthMoment /= fftData.length
+    // Add a small epsilon to the denominator to prevent gigantic scores when variance is very small
+    const epsilon = 1e-7 // Adjust epsilon based on the scale of your data
+    const kurtosis = variance ? fourthMoment / Math.pow(variance + epsilon, 2) - 3 : 0
+    if (kurtosis > 3000) return 0
+    return kurtosis / 3000
+}

package/src/audio/spectralRolloff.js ADDED Viewed

@@ -0,0 +1,21 @@
+export default function spectralRolloff(prevValue, statCalculator, fft) {
+    const value = calculateSpectralRolloff(fft) // Compute Spectral Rolloff
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+// Calculate Spectral Rolloff
+function calculateSpectralRolloff(fftData, threshold = 0.85) {
+    let totalEnergy = fftData.reduce((acc, val) => acc + val, 0)
+    let energyThreshold = totalEnergy * threshold
+    let cumulativeEnergy = 0
+    for (let i = 0; i < fftData.length; i++) {
+        cumulativeEnergy += fftData[i]
+        if (cumulativeEnergy >= energyThreshold) {
+            return i / fftData.length // Normalized rolloff frequency
+        }
+    }
+    return 0 // In case the threshold is not met
+}

package/src/audio/spectralRoughness.js ADDED Viewed

@@ -0,0 +1,18 @@
+export default function spectralRoughness(prevValue, statCalculator, fft) {
+    let computed = calculateSpectralRoughness(fft) // Process FFT data
+    const value = computed/100_000
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function calculateSpectralRoughness(fftData) {
+    let roughness = 0
+    for (let i = 1; i < fftData.length; i++) {
+        // Calculate the difference in amplitude between adjacent frequency bins
+        let diff = Math.abs(fftData[i] - fftData[i - 1])
+        roughness += diff
+    }
+    return roughness
+}

package/src/audio/spectralSkew.js ADDED Viewed

@@ -0,0 +1,33 @@
+export default function spectralSkew(prevValue, statCalculator, fft) {
+    const computed = calculateSpectralSkewness(fft) || 0 // Process FFT data
+    const value = computed / 10.
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function mu(i, amplitudeSpect) {
+    let numerator = 0
+    let denominator = 0
+    for (let k = 0; k < amplitudeSpect.length; k++) {
+        numerator += Math.pow(k, i) * Math.abs(amplitudeSpect[k])
+        denominator += amplitudeSpect[k]
+    }
+    if (denominator === 0) return null // Prevent division by zero
+    return numerator / denominator
+}
+function calculateSpectralSkewness(fftData) {
+    const mean = fftData.reduce((sum, val) => sum + val, 0) / fftData.length
+    const variance = fftData.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / fftData.length
+    const standardDeviation = Math.sqrt(variance)
+    let skewness = 0
+    if (standardDeviation !== 0) {
+        skewness = fftData.reduce((sum, val) => sum + Math.pow(val - mean, 3), 0) / fftData.length
+        skewness /= Math.pow(standardDeviation, 3)
+    }
+    return skewness
+}

package/src/audio/spectralSpread.js ADDED Viewed

@@ -0,0 +1,40 @@
+export default function spectralSpread(prevValue, statCalculator, fft) {
+    let computed = calculateSpectralSpread(fft) // Process FFT data
+    const value = computed
+    const stats = statCalculator(value)
+    return { value, stats }
+}
+function mu(i, amplitudeSpect) {
+    let numerator = 0
+    let denominator = 0
+    for (let k = 0; k < amplitudeSpect.length; k++) {
+        numerator += Math.pow(k, i) * Math.abs(amplitudeSpect[k])
+        denominator += amplitudeSpect[k]
+    }
+    if (denominator === 0) return 0 // Prevent division by zero
+    return numerator / denominator
+}
+function calculateMaxSpread(fftSize) {
+    // Create a spectrum with energy at the two extremes
+    const extremeSpectrum = new Array(fftSize).fill(0)
+    extremeSpectrum[0] = 1 // Energy at the lowest frequency
+    extremeSpectrum[fftSize - 1] = 1 // Energy at the highest frequency
+    const meanFrequency = mu(1, extremeSpectrum)
+    const secondMoment = mu(2, extremeSpectrum)
+    return Math.sqrt(secondMoment - Math.pow(meanFrequency, 2))
+}
+function calculateSpectralSpread(fftData) {
+    const meanFrequency = mu(1, fftData)
+    const secondMoment = mu(2, fftData)
+    const maxSpread = calculateMaxSpread(fftData.length)
+    const spread = Math.sqrt(secondMoment - Math.pow(meanFrequency, 2))
+    // Normalize the spread
+    return spread / maxSpread
+}

package/src/utils/calculateStats.js ADDED Viewed

@@ -0,0 +1,194 @@
+export const StatTypes = ['normalized', 'mean', 'median', 'standardDeviation', 'zScore', 'min', 'max']
+export function makeCalculateStats(historySize = 500) {
+    let queue = []
+    let sum = 0
+    let sumOfSquares = 0
+    let minQueue = []
+    let maxQueue = []
+    let lowerHalf = [] // Max heap
+    let upperHalf = [] // Min heap
+    function updateMinMaxQueues(value) {
+        while (minQueue.length && minQueue[minQueue.length - 1] > value) {
+            minQueue.pop()
+        }
+        while (maxQueue.length && maxQueue[maxQueue.length - 1] < value) {
+            maxQueue.pop()
+        }
+        minQueue.push(value)
+        maxQueue.push(value)
+    }
+    function removeOldFromMinMaxQueues(oldValue) {
+        if (minQueue[0] === oldValue) {
+            minQueue.shift()
+        }
+        if (maxQueue[0] === oldValue) {
+            maxQueue.shift()
+        }
+    }
+    function addNumberToHeaps(number) {
+        if (lowerHalf.length === 0 || number < lowerHalf[0]) {
+            lowerHalf.push(number)
+            bubbleUp(lowerHalf, false)
+        } else {
+            upperHalf.push(number)
+            bubbleUp(upperHalf, true)
+        }
+        // Rebalance heaps
+        if (lowerHalf.length > upperHalf.length + 1) {
+            upperHalf.push(extractTop(lowerHalf, false))
+            bubbleUp(upperHalf, true)
+        } else if (upperHalf.length > lowerHalf.length) {
+            lowerHalf.push(extractTop(upperHalf, true))
+            bubbleUp(lowerHalf, false)
+        }
+    }
+    function removeNumberFromHeaps(number) {
+        if (lowerHalf.includes(number)) {
+            removeNumber(lowerHalf, number, false)
+        } else if (upperHalf.includes(number)) {
+            removeNumber(upperHalf, number, true)
+        }
+        // Rebalance heaps
+        if (lowerHalf.length > upperHalf.length + 1) {
+            upperHalf.push(extractTop(lowerHalf, false))
+            bubbleUp(upperHalf, true)
+        } else if (upperHalf.length > lowerHalf.length) {
+            lowerHalf.push(extractTop(upperHalf, true))
+            bubbleUp(lowerHalf, false)
+        }
+    }
+    function bubbleUp(heap, isMinHeap) {
+        let index = heap.length - 1
+        while (index > 0) {
+            let parentIdx = Math.floor((index - 1) / 2)
+            if ((isMinHeap && heap[index] < heap[parentIdx]) || (!isMinHeap && heap[index] > heap[parentIdx])) {
+                ;[heap[index], heap[parentIdx]] = [heap[parentIdx], heap[index]]
+                index = parentIdx
+            } else {
+                break
+            }
+        }
+    }
+    function extractTop(heap, isMinHeap) {
+        if (heap.length === 0) {
+            return null
+        }
+        let top = heap[0]
+        heap[0] = heap[heap.length - 1]
+        heap.pop()
+        sinkDown(heap, isMinHeap)
+        return top
+    }
+    function sinkDown(heap, isMinHeap) {
+        let index = 0
+        let length = heap.length
+        while (index < length) {
+            let leftChildIndex = 2 * index + 1
+            let rightChildIndex = 2 * index + 2
+            let swapIndex = null
+            if (leftChildIndex < length) {
+                if ((isMinHeap && heap[leftChildIndex] < heap[index]) || (!isMinHeap && heap[leftChildIndex] > heap[index])) {
+                    swapIndex = leftChildIndex
+                }
+            }
+            if (rightChildIndex < length) {
+                if (
+                    (isMinHeap && heap[rightChildIndex] < (swapIndex === null ? heap[index] : heap[leftChildIndex])) ||
+                    (!isMinHeap && heap[rightChildIndex] > (swapIndex === null ? heap[index] : heap[leftChildIndex]))
+                ) {
+                    swapIndex = rightChildIndex
+                }
+            }
+            if (swapIndex === null) {
+                break
+            }
+            ;[heap[index], heap[swapIndex]] = [heap[swapIndex], heap[index]]
+            index = swapIndex
+        }
+    }
+    function removeNumber(heap, number, isMinHeap) {
+        let index = heap.indexOf(number)
+        if (index !== -1) {
+            heap[index] = heap[heap.length - 1]
+            heap.pop()
+            sinkDown(heap, isMinHeap)
+        }
+    }
+    function calculateMedian() {
+        if (lowerHalf.length === upperHalf.length) {
+            return (lowerHalf[0] + upperHalf[0]) / 2
+        } else {
+            return lowerHalf[0]
+        }
+    }
+    function calculateMAD(median) {
+        let deviations = queue.map((value) => Math.abs(value - median))
+        let mad = medianAbsoluteDeviation(deviations)
+        return mad
+    }
+    function medianAbsoluteDeviation(values) {
+        if (values.length === 0) {
+            return 0
+        }
+        let median = calculateMedian(values)
+        let absoluteDeviations = values.map((value) => Math.abs(value - median))
+        let medianAbsoluteDeviation = calculateMedian(absoluteDeviations)
+        return medianAbsoluteDeviation
+    }
+    return function calculateStats(value) {
+        if (typeof value !== 'number') throw new Error('Input must be a number')
+        updateMinMaxQueues(value)
+        addNumberToHeaps(value)
+        queue.push(value)
+        sum += value
+        sumOfSquares += value * value
+        if (queue.length > historySize) {
+            let removed = queue.shift()
+            sum -= removed
+            sumOfSquares -= removed * removed
+            removeOldFromMinMaxQueues(removed)
+            removeNumberFromHeaps(removed)
+        }
+        let mean = sum / queue.length
+        let variance = sumOfSquares / queue.length - mean * mean
+        let min = minQueue.length ? minQueue[0] : Infinity
+        let max = maxQueue.length ? maxQueue[0] : -Infinity
+        let median = calculateMedian()
+        let mad = calculateMAD(median)
+        return {
+            current: value,
+            zScore: (variance ? (value - mean) / Math.sqrt(variance) : 0) / 6,
+            normalized: mad, // Using MAD normalization as 'normalized'
+            standardDeviation: Math.sqrt(variance),
+            median,
+            mean,
+            min,
+            max,
+        }
+    }
+}