echogarden 0.12.2 → 1.0.0

package/dist/dsp/KWeightingFilter.js

@@ -0,0 +1,40 @@
+import { BiquadFilter, createHighpassFilter, createHighshelfFilter } from './BiquadFilter.js';
+export class KWeightingFilter {
+    sampleRate;
+    useStandard44100Filters;
+    highShelfFilter;
+    highPassFilter;
+    constructor(sampleRate, useStandard44100Filters = false) {
+        this.sampleRate = sampleRate;
+        this.useStandard44100Filters = useStandard44100Filters;
+        if (useStandard44100Filters) {
+            // These parameter values are taken from ITU-R BS.1770-2
+            // and designed only for a 44100 Hz sampling rate:
+            this.highShelfFilter = new BiquadFilter({
+                b0: 1.53512485958697,
+                b1: -2.69169618940638,
+                b2: 1.19839281085285,
+                a1: -1.69065929318241,
+                a2: 0.73248077421585,
+            });
+            this.highPassFilter = new BiquadFilter({
+                b0: 1.0,
+                b1: -2.0,
+                b2: 1.0,
+                a1: -1.99004745483398,
+                a2: 0.99007225036621,
+            });
+        }
+        else {
+            this.highShelfFilter = createHighshelfFilter(sampleRate, 2000.0, 4.0);
+            this.highPassFilter = createHighpassFilter(sampleRate, 1.5, 0.01);
+        }
+    }
+    process(sample) {
+        let outputSample = sample;
+        outputSample = this.highShelfFilter.filter(outputSample);
+        outputSample = this.highPassFilter.filter(outputSample);
+        return outputSample;
+    }
+}
+//# sourceMappingURL=KWeightingFilter.js.map

package/dist/dsp/KWeightingFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KWeightingFilter.js","sourceRoot":"","sources":["../../src/dsp/KWeightingFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE9F,MAAM,OAAO,gBAAgB;IAKX;IACA;IALR,eAAe,CAAc;IAC7B,cAAc,CAAc;IAErC,YACiB,UAAkB,EAClB,0BAA0B,KAAK;QAD/B,eAAU,GAAV,UAAU,CAAQ;QAClB,4BAAuB,GAAvB,uBAAuB,CAAQ;QAE/C,IAAI,uBAAuB,EAAE,CAAC;YAC7B,wDAAwD;YACxD,kDAAkD;YAClD,IAAI,CAAC,eAAe,GAAG,IAAI,YAAY,CAAC;gBACvC,EAAE,EAAE,gBAAgB;gBACpB,EAAE,EAAE,CAAC,gBAAgB;gBACrB,EAAE,EAAE,gBAAgB;gBACpB,EAAE,EAAE,CAAC,gBAAgB;gBACrB,EAAE,EAAE,gBAAgB;aACpB,CAAC,CAAA;YAEF,IAAI,CAAC,cAAc,GAAG,IAAI,YAAY,CAAC;gBACtC,EAAE,EAAE,GAAG;gBACP,EAAE,EAAE,CAAC,GAAG;gBACR,EAAE,EAAE,GAAG;gBACP,EAAE,EAAE,CAAC,gBAAgB;gBACrB,EAAE,EAAE,gBAAgB;aACpB,CAAC,CAAA;QACH,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,eAAe,GAAG,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;YACrE,IAAI,CAAC,cAAc,GAAG,oBAAoB,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;QAClE,CAAC;IACF,CAAC;IAED,OAAO,CAAC,MAAc;QACrB,IAAI,YAAY,GAAG,MAAM,CAAA;QAEzB,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QACxD,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;QAEvD,OAAO,YAAY,CAAA;IACpB,CAAC;CACD"}

package/dist/dsp/LoudnessEstimator.d.ts

@@ -0,0 +1,21 @@
+import { SmoothEstimator } from '../utilities/SmoothEstimator.js';
+import { KWeightingFilter } from './KWeightingFilter.js';
+export declare class LoudnessEstimator {
+    readonly options: LoudnessEstimatorOptions;
+    readonly channelFilters: KWeightingFilter[];
+    readonly channelMeanSquares: SmoothEstimator[];
+    readonly minPower: number;
+    constructor(options: LoudnessEstimatorOptions);
+    process(sample: number, channel: number): void;
+    get currentLoudness(): number;
+    getCurrentRMSForChannel(channel: number): number;
+}
+export interface LoudnessEstimatorOptions {
+    sampleRate: number;
+    channelCount: number;
+    positiveAdaptationRate: number;
+    negativeAdaptationRate: number;
+    initialEstimate: number;
+    minimumLoudness: number;
+    applyKWeighting: boolean;
+}

package/dist/dsp/LoudnessEstimator.js

@@ -0,0 +1,47 @@
+import { decibelsToGainFactor, gainFactorToDecibels } from '../audio/AudioUtilities.js';
+import { SmoothEstimator } from '../utilities/SmoothEstimator.js';
+import { KWeightingFilter } from './KWeightingFilter.js';
+export class LoudnessEstimator {
+    options;
+    channelFilters = [];
+    channelMeanSquares = [];
+    minPower;
+    constructor(options) {
+        this.options = options;
+        const initialMeanSquares = decibelsToGainFactor(options.initialEstimate) ** 2;
+        const ticksPerSecond = this.options.sampleRate * this.options.channelCount;
+        for (let i = 0; i < options.channelCount; i++) {
+            const weightingFilter = new KWeightingFilter(options.sampleRate);
+            const channelMeanSquares = new SmoothEstimator(options.positiveAdaptationRate / ticksPerSecond, options.negativeAdaptationRate / ticksPerSecond, initialMeanSquares);
+            this.channelFilters.push(weightingFilter);
+            this.channelMeanSquares.push(channelMeanSquares);
+        }
+        this.minPower = decibelsToGainFactor(options.minimumLoudness) ** 2;
+    }
+    process(sample, channel) {
+        let filteredSample;
+        if (this.options.applyKWeighting) {
+            filteredSample = this.channelFilters[channel].process(sample);
+        }
+        else {
+            filteredSample = sample;
+        }
+        const filteredSampleSquared = filteredSample ** 2;
+        const channelMeanSquares = this.channelMeanSquares[channel];
+        channelMeanSquares.update(filteredSampleSquared);
+        channelMeanSquares.estimate = Math.max(channelMeanSquares.estimate, this.minPower);
+    }
+    get currentLoudness() {
+        let totalMeanSquares = 0;
+        for (let i = 0; i < this.options.channelCount; i++) {
+            totalMeanSquares += this.channelMeanSquares[i].estimate;
+        }
+        const rms = Math.sqrt(totalMeanSquares / this.options.channelCount);
+        const rmsDecibels = gainFactorToDecibels(rms);
+        return rmsDecibels;
+    }
+    getCurrentRMSForChannel(channel) {
+        return Math.sqrt(this.channelMeanSquares[channel].estimate);
+    }
+}
+//# sourceMappingURL=LoudnessEstimator.js.map

package/dist/dsp/LoudnessEstimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoudnessEstimator.js","sourceRoot":"","sources":["../../src/dsp/LoudnessEstimator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,OAAO,iBAAiB;IAMD;IALnB,cAAc,GAAuB,EAAE,CAAA;IACvC,kBAAkB,GAAsB,EAAE,CAAA;IAE1C,QAAQ,CAAQ;IAEzB,YAA4B,OAAiC;QAAjC,YAAO,GAAP,OAAO,CAA0B;QAC5D,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;QAE7E,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAA;QAE1E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,MAAM,eAAe,GACpB,IAAI,gBAAgB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;YAEzC,MAAM,kBAAkB,GACvB,IAAI,eAAe,CAAC,OAAO,CAAC,sBAAsB,GAAG,cAAc,EAAE,OAAO,CAAC,sBAAsB,GAAG,cAAc,EAAE,kBAAkB,CAAC,CAAA;YAE1I,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;YACzC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAA;QACjD,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,oBAAoB,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;IACnE,CAAC;IAED,OAAO,CAAC,MAAc,EAAE,OAAe;QACtC,IAAI,cAAsB,CAAA;QAE1B,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAC9D,CAAC;aAAM,CAAC;YACP,cAAc,GAAG,MAAM,CAAA;QACxB,CAAC;QAED,MAAM,qBAAqB,GAAG,cAAc,IAAI,CAAC,CAAA;QAEjD,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAA;QAE3D,kBAAkB,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAA;QAEhD,kBAAkB,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IACnF,CAAC;IAED,IAAI,eAAe;QAClB,IAAI,gBAAgB,GAAG,CAAC,CAAA;QAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;YACpD,gBAAgB,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAA;QACxD,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QACnE,MAAM,WAAW,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAA;QAE7C,OAAO,WAAW,CAAA;IACnB,CAAC;IAED,uBAAuB,CAAC,OAAe;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAA;IAC5D,CAAC;CACD"}

package/dist/dsp/MFCC.d.ts

@@ -1,7 +1,7 @@
-import { RawAudio } from "../audio/AudioUtilities.js";
+import { RawAudio } from '../audio/AudioUtilities.js';
 export declare function computeMFCCs(monoAudio: RawAudio, options?: MfccOptions): Promise<number[][]>;
 export declare function melSpectogramToMFCCs(melSpectogram: Float32Array[], mfccFeatureCount: number): Float32Array[];
-export declare function melSpectrumToMFCC(melSpectrum: Float32Array, mfccFeatureCount: number, dctMatrix: Float32Array[], normalization?: "none" | "orthonormal"): Float32Array;
+export declare function melSpectrumToMFCC(melSpectrum: Float32Array, mfccFeatureCount: number, dctMatrix: Float32Array[], normalization?: 'none' | 'orthonormal'): Float32Array;
 export declare function createDCTType2CoefficientMatrix(mfccFeatureCount: number, melBandCount: number): Float32Array[];
 export declare function mfccBufferToVectors(mfccBuffer: Float64Array, mfccFeatureCount: number): number[][];
 export declare function applyEmphasis(samples: Float32Array, emphasisFactor?: number, initialState?: number): Float32Array;

package/dist/dsp/MFCC.js

@@ -1,14 +1,14 @@
-import { extendDeep } from "../utilities/ObjectUtilities.js";
-import { Logger } from "../utilities/Logger.js";
-import { resampleAudioSpeex } from "./SpeexResampler.js";
-import { computeMelSpectogram } from "./MelSpectogram.js";
-import { powerToDecibels } from "../audio/AudioUtilities.js";
-import { normalizeVectors } from "../math/VectorMath.js";
+import { extendDeep } from '../utilities/ObjectUtilities.js';
+import { Logger } from '../utilities/Logger.js';
+import { resampleAudioSpeex } from './SpeexResampler.js';
+import { computeMelSpectogram } from './MelSpectogram.js';
+import { powerToDecibels } from '../audio/AudioUtilities.js';
+import { normalizeVectors } from '../math/VectorMath.js';
 export async function computeMFCCs(monoAudio, options = {}) {
     const logger = new Logger();
-    logger.start("Initialize options");
+    logger.start('Initialize options');
     if (monoAudio.audioChannels.length != 1) {
-        throw new Error("Audio must be mono");
+        throw new Error('Audio must be mono');
     }
     options = extendDefaultMfccOptions(options);
     const analysisSampleRate = options.analysisSampleRate;
@@ -28,22 +28,22 @@ export async function computeMFCCs(monoAudio, options = {}) {
     const resampledAudio = await resampleAudioSpeex(monoAudio, analysisSampleRate);
     let mfccs;
     if (emphasisFactor > 0) {
-        logger.start("Apply emphasis");
+        logger.start('Apply emphasis');
         resampledAudio.audioChannels[0] = applyEmphasis(resampledAudio.audioChannels[0], emphasisFactor);
     }
-    logger.start("Compute Mel spectogram");
+    logger.start('Compute Mel spectogram');
     const { melSpectogram } = await computeMelSpectogram(resampledAudio, fftOrder, windowSize, hopLength, filterbankCount, lowerFrequencyHz, upperFrequencyHz);
-    logger.start("Extract MFCCs from Mel spectogram");
+    logger.start('Extract MFCCs from Mel spectogram');
     const mfccsFloat32 = melSpectogramToMFCCs(melSpectogram, featureCount);
     mfccs = mfccsFloat32.map(mfcc => Array.from(mfcc));
     if (options.normalize) {
-        logger.start("Normalize MFCCs");
+        logger.start('Normalize MFCCs');
         const { normalizedVectors, mean, stdDeviation } = normalizeVectors(mfccs);
         mfccs = normalizedVectors;
         //mfccs = mfccs.map(mfcc => subtractVectors(mfcc, mean))
     }
     if (lifteringFactor > 0) {
-        logger.start("Apply liftering to MFCCs");
+        logger.start('Apply liftering to MFCCs');
         mfccs = applyLiftering(mfccs, lifteringFactor);
     }
     if (zeroFirstCoefficient) {
@@ -60,11 +60,11 @@ export function melSpectogramToMFCCs(melSpectogram, mfccFeatureCount) {
     const mfccs = melSpectogram.map(frame => melSpectrumToMFCC(frame, mfccFeatureCount, dctMatrix));
     return mfccs;
 }
-export function melSpectrumToMFCC(melSpectrum, mfccFeatureCount, dctMatrix, normalization = "orthonormal") {
+export function melSpectrumToMFCC(melSpectrum, mfccFeatureCount, dctMatrix, normalization = 'orthonormal') {
     const melBandCount = melSpectrum.length;
     let firstFeatureNormalizationFactor;
     let nonfirstFeatureNormalizationFactor;
-    if (normalization == "orthonormal") {
+    if (normalization == 'orthonormal') {
         firstFeatureNormalizationFactor = Math.sqrt(1 / (4 * mfccFeatureCount));
         nonfirstFeatureNormalizationFactor = Math.sqrt(1 / (2 * mfccFeatureCount));
     }

package/dist/dsp/MelSpectogram.d.ts

@@ -1,4 +1,4 @@
-import { RawAudio } from "../audio/AudioUtilities.js";
+import { RawAudio } from '../audio/AudioUtilities.js';
 export declare function computeMelSpectogram(rawAudio: RawAudio, fftOrder: number, windowSize: number, hopLength: number, filterbankCount: number, lowerFrequencyHz: number, upperFrequencyHz: number): Promise<{
     melSpectogram: Float32Array[];
     fftFrames: Float32Array[];

package/dist/dsp/MelSpectogram.js

@@ -1,8 +1,8 @@
-import { Logger } from "../utilities/Logger.js";
-import * as FFT from "./FFT.js";
+import { Logger } from '../utilities/Logger.js';
+import * as FFT from './FFT.js';
 export async function computeMelSpectogram(rawAudio, fftOrder, windowSize, hopLength, filterbankCount, lowerFrequencyHz, upperFrequencyHz) {
     const logger = new Logger();
-    logger.start("Compute mel filterbank");
+    logger.start('Compute mel filterbank');
     const binCount = (fftOrder / 2) + 2;
     const nyquistFrequency = rawAudio.sampleRate / 2;
     const binFrequencies = FFT.getBinFrequencies(binCount, nyquistFrequency);
@@ -15,10 +15,10 @@ export async function computeMelSpectogram(rawAudio, fftOrder, windowSize, hopLe
 }
 export async function computeMelSpectogramUsingFilterbanks(rawAudio, fftOrder, windowSize, hopLength, filterbanks) {
     const logger = new Logger();
-    logger.start("Compute short-time FFTs");
+    logger.start('Compute short-time FFTs');
     const audioSamples = rawAudio.audioChannels[0];
-    const fftFrames = await FFT.stftr(audioSamples, fftOrder, windowSize, hopLength, "hann");
-    logger.start("Convert FFT frames to a mel spectogram");
+    const fftFrames = await FFT.stftr(audioSamples, fftOrder, windowSize, hopLength, 'hann');
+    logger.start('Convert FFT frames to a mel spectogram');
     const melSpectogram = fftFramesToMelSpectogram(fftFrames, filterbanks);
     logger.end();
     return { melSpectogram, fftFrames };

package/dist/dsp/Rubberband.d.ts

@@ -1,4 +1,4 @@
-import { RawAudio } from "../audio/AudioUtilities.js";
+import { RawAudio } from '../audio/AudioUtilities.js';
 export declare function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchScale: number, options: RubberbandOptions): Promise<RawAudio>;
 export declare function getRubberbandInstance(): Promise<any>;
 export declare function rubberBandOptionsToFlags(options: RubberbandOptions): number;
@@ -39,14 +39,14 @@ export declare enum RubberBandPresetOption {
 }
 export declare const defaultRubberbandOptions: RubberbandOptions;
 export type RubberbandOptions = {
-    stretch?: "elastic" | "precise";
-    transients?: "crisp" | "mixed" | "smooth";
-    detector?: "compound" | "percussive" | "soft";
-    phase?: "laminar" | "independent";
-    window?: "standard" | "long" | "short";
-    smoothing?: "off" | "on";
-    formant?: "shited" | "preserved";
-    pitch?: "high-speed" | "high-quality" | "high-consistency";
-    channels?: "apart" | "together";
-    engine?: "faster" | "finer";
+    stretch?: 'elastic' | 'precise';
+    transients?: 'crisp' | 'mixed' | 'smooth';
+    detector?: 'compound' | 'percussive' | 'soft';
+    phase?: 'laminar' | 'independent';
+    window?: 'standard' | 'long' | 'short';
+    smoothing?: 'off' | 'on';
+    formant?: 'shited' | 'preserved';
+    pitch?: 'high-speed' | 'high-quality' | 'high-consistency';
+    channels?: 'apart' | 'together';
+    engine?: 'faster' | 'finer';
 };

package/dist/dsp/Rubberband.js

@@ -1,6 +1,6 @@
-import { extendDeep } from "../utilities/ObjectUtilities.js";
-import { concatFloat32Arrays } from "../utilities/Utilities.js";
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js";
+import { extendDeep } from '../utilities/ObjectUtilities.js';
+import { concatFloat32Arrays } from '../utilities/Utilities.js';
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js';
 let rubberbandInstance;
 export async function stretchTimePitch(rawAudio, speed, pitchScale, options) {
     options = extendDeep(defaultRubberbandOptions, options);
@@ -90,46 +90,46 @@ export async function getRubberbandInstance() {
 }
 export function rubberBandOptionsToFlags(options) {
     let flags = 0;
-    if (options.stretch == "precise") {
+    if (options.stretch == 'precise') {
         flags += RubberBandOptionFlag.StretchPrecise;
     }
-    if (options.transients == "mixed") {
+    if (options.transients == 'mixed') {
         flags += RubberBandOptionFlag.TransientsMixed;
     }
-    else if (options.transients == "smooth") {
+    else if (options.transients == 'smooth') {
         flags += RubberBandOptionFlag.TransientsSmooth;
     }
-    if (options.detector == "percussive") {
+    if (options.detector == 'percussive') {
         flags += RubberBandOptionFlag.DetectorPercussive;
     }
-    else if (options.detector == "soft") {
+    else if (options.detector == 'soft') {
         flags += RubberBandOptionFlag.DetectorSoft;
     }
-    if (options.phase == "independent") {
+    if (options.phase == 'independent') {
         flags += RubberBandOptionFlag.PhaseIndependent;
     }
-    if (options.window == "short") {
+    if (options.window == 'short') {
         flags += RubberBandOptionFlag.WindowShort;
     }
-    else if (options.window == "long") {
+    else if (options.window == 'long') {
         flags += RubberBandOptionFlag.WindowLong;
     }
-    if (options.smoothing == "on") {
+    if (options.smoothing == 'on') {
         flags += RubberBandOptionFlag.SmoothingOn;
     }
-    if (options.formant == "preserved") {
+    if (options.formant == 'preserved') {
         flags += RubberBandOptionFlag.FormantPreserved;
     }
-    if (options.pitch == "high-quality") {
+    if (options.pitch == 'high-quality') {
         flags += RubberBandOptionFlag.PitchHighQuality;
     }
-    else if (options.pitch == "high-consistency") {
+    else if (options.pitch == 'high-consistency') {
         flags += RubberBandOptionFlag.PitchHighConsistency;
     }
-    if (options.channels == "together") {
+    if (options.channels == 'together') {
         flags += RubberBandOptionFlag.ChannelsTogether;
     }
-    if (options.engine == "finer") {
+    if (options.engine == 'finer') {
         flags += RubberBandOptionFlag.EngineFiner;
     }
     return flags;
@@ -172,15 +172,15 @@ export var RubberBandPresetOption;
     RubberBandPresetOption[RubberBandPresetOption["PercussiveOptions"] = 1056768] = "PercussiveOptions";
 })(RubberBandPresetOption || (RubberBandPresetOption = {}));
 export const defaultRubberbandOptions = {
-    stretch: "elastic",
-    transients: "crisp",
-    detector: "compound",
-    phase: "laminar",
-    window: "standard",
-    smoothing: "off",
-    formant: "shited",
-    pitch: "high-speed",
-    channels: "apart",
-    engine: "faster"
+    stretch: 'elastic',
+    transients: 'crisp',
+    detector: 'compound',
+    phase: 'laminar',
+    window: 'standard',
+    smoothing: 'off',
+    formant: 'shited',
+    pitch: 'high-speed',
+    channels: 'apart',
+    engine: 'faster'
 };
 //# sourceMappingURL=Rubberband.js.map

package/dist/dsp/Sonic.d.ts

@@ -1,2 +1,2 @@
-import { RawAudio } from "../audio/AudioUtilities.js";
+import { RawAudio } from '../audio/AudioUtilities.js';
 export declare function stretchTimePitch(rawAudio: RawAudio, speed: number, pitchScale: number): Promise<RawAudio>;

package/dist/dsp/Sonic.js

@@ -1,4 +1,4 @@
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js";
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js';
 let sonicInstance;
 export async function stretchTimePitch(rawAudio, speed, pitchScale) {
     const sampleRate = rawAudio.sampleRate;
@@ -14,11 +14,11 @@ export async function stretchTimePitch(rawAudio, speed, pitchScale) {
     inputSamplesRef.view.set(inputSamples);
     const writeSuccess = m._sonicWriteFloatToStream(streamPtr, inputSamplesRef.address, inputSampleCount);
     if (writeSuccess != 1) {
-        throw new Error("Sonic error: failed write to stream");
+        throw new Error('Sonic error: failed write to stream');
     }
     const flushSuccess = m._sonicFlushStream(streamPtr);
     if (flushSuccess != 1) {
-        throw new Error("Sonic error: failed flushing stream");
+        throw new Error('Sonic error: failed flushing stream');
     }
     const samplesAvailable = m._sonicSamplesAvailable(streamPtr);
     const outputSamplesRef = wasmMemory.allocFloat32Array(samplesAvailable);

package/dist/dsp/SpeexResampler.d.ts

@@ -1,3 +1,3 @@
-import { RawAudio } from "../audio/AudioUtilities.js";
+import { RawAudio } from '../audio/AudioUtilities.js';
 export declare function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: number, quality?: number): Promise<RawAudio>;
 export declare function getSpeexResamplerInstance(): Promise<any>;

package/dist/dsp/SpeexResampler.js

@@ -1,5 +1,5 @@
-import { cloneRawAudio } from "../audio/AudioUtilities.js";
-import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js";
+import { cloneRawAudio } from '../audio/AudioUtilities.js';
+import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js';
 let speexResamplerInstance;
 export async function resampleAudioSpeex(rawAudio, outSampleRate, quality = 0) {
     const channelCount = rawAudio.audioChannels.length;

package/dist/math/VectorMath.d.ts

@@ -10,12 +10,12 @@ export declare function centerVectors(vectors: number[][], weights?: number[]):
 };
 export declare function centerVector(vector: number[]): number[];
 export declare function scaleToSumTo1(vector: number[]): number[];
-export declare function normalizeVector(vector: number[], kind?: "population" | "sample"): {
+export declare function normalizeVector(vector: number[], kind?: 'population' | 'sample'): {
     normalizedVector: number[];
     mean: number;
     stdDeviation: number;
 };
-export declare function normalizeVectors(vectors: number[][], kind?: "population" | "sample"): {
+export declare function normalizeVectors(vectors: number[][], kind?: 'population' | 'sample'): {
     normalizedVectors: number[][];
     mean: number[];
     stdDeviation: number[];
@@ -23,20 +23,20 @@ export declare function normalizeVectors(vectors: number[][], kind?: "population
 export declare function deNormalizeVectors(normalizedVectors: number[][], originalMean: number[], originalStdDeviation: number[]): number[][];
 export declare function meanOfVectors(vectors: number[][]): number[];
 export declare function weightedMeanOfVectors(vectors: number[][], weights: number[]): number[];
-export declare function stdDeviationOfVectors(vectors: number[][], kind?: "population" | "sample", mean?: number[]): number[];
-export declare function varianceOfVectors(vectors: number[][], kind?: "population" | "sample", mean?: number[]): number[];
+export declare function stdDeviationOfVectors(vectors: number[][], kind?: 'population' | 'sample', mean?: number[]): number[];
+export declare function varianceOfVectors(vectors: number[][], kind?: 'population' | 'sample', mean?: number[]): number[];
 export declare function meanOfVector(vector: number[]): number;
 export declare function medianOfVector(vector: number[]): number;
-export declare function stdDeviationOfVector(vector: number[], kind?: "population" | "sample", mean?: number): number;
-export declare function varianceOfVector(vector: number[], kind?: "population" | "sample", mean?: number): number;
+export declare function stdDeviationOfVector(vector: number[], kind?: 'population' | 'sample', mean?: number): number;
+export declare function varianceOfVector(vector: number[], kind?: 'population' | 'sample', mean?: number): number;
 export declare function logOfVector(vector: number[], minVal?: number): number[];
 export declare function expOfVector(vector: number[]): number[];
 export declare function transpose(matrix: number[][]): number[][];
 export declare function movingAverageOfWindow3(vector: number[]): number[];
 export declare function averageMeanSquaredError(actual: number[][], expected: number[][]): number;
 export declare function meanSquaredError(actual: number[], expected: number[]): number;
-export declare function eucledianDistance(vector1: number[], vector2: number[]): number;
-export declare function squaredEucledianDistance(vector1: number[], vector2: number[]): number;
+export declare function euclidianDistance(vector1: number[], vector2: number[]): number;
+export declare function squaredEuclidianDistance(vector1: number[], vector2: number[]): number;
 export declare function cosineDistance(vector1: number[], vector2: number[]): number;
 export declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
 export declare function minkowskiDistance(vector1: number[], vector2: number[], power: number): number;
@@ -68,3 +68,7 @@ export declare class IncrementalMean {
     addValueToMean(value: number): void;
 }
 export type DistanceFunction = (a: number[], b: number[]) => number;
+export interface ComplexNumber {
+    real: number;
+    imaginary: number;
+}