@viji-dev/core 0.2.20 → 0.3.1

package/dist/essentia.js-core.es-DnrJE0uR.js

@@ -0,0 +1,3174 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : new P(function(resolve2) {
+        resolve2(result.value);
+      }).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+/**
+ * @license
+ * Copyright (C) 2006-2020  Music Technology Group - Universitat Pompeu Fabra
+ *
+ * This file is part of Essentia
+ *
+ * Essentia is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation (FSF), either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the Affero GNU General Public License
+ * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
+ */
+var Essentia = (
+  /** @class */
+  function() {
+    function Essentia2(EssentiaWASM, isDebug) {
+      if (isDebug === void 0) {
+        isDebug = false;
+      }
+      this.EssentiaWASM = EssentiaWASM;
+      this.isDebug = isDebug;
+      this.algorithms = new EssentiaWASM.EssentiaJS(isDebug);
+      this.module = EssentiaWASM;
+      this.version = this.algorithms.version;
+      this.algorithmNames = this.algorithms.algorithmNames;
+    }
+    Essentia2.prototype.getAudioBufferFromURL = function(audioURL, webAudioCtx) {
+      return __awaiter(this, void 0, void 0, function() {
+        var response, arrayBuffer, audioBuffer;
+        return __generator(this, function(_a) {
+          switch (_a.label) {
+            case 0:
+              return [4, fetch(audioURL)];
+            case 1:
+              response = _a.sent();
+              return [4, response.arrayBuffer()];
+            case 2:
+              arrayBuffer = _a.sent();
+              return [4, webAudioCtx.decodeAudioData(arrayBuffer)];
+            case 3:
+              audioBuffer = _a.sent();
+              return [2, audioBuffer];
+          }
+        });
+      });
+    };
+    Essentia2.prototype.getAudioChannelDataFromURL = function(audioURL, webAudioCtx, channel) {
+      if (channel === void 0) {
+        channel = 0;
+      }
+      return __awaiter(this, void 0, void 0, function() {
+        var response, arrayBuffer, audioBuffer;
+        return __generator(this, function(_a) {
+          switch (_a.label) {
+            case 0:
+              return [4, fetch(audioURL)];
+            case 1:
+              response = _a.sent();
+              return [4, response.arrayBuffer()];
+            case 2:
+              arrayBuffer = _a.sent();
+              return [4, webAudioCtx.decodeAudioData(arrayBuffer)];
+            case 3:
+              audioBuffer = _a.sent();
+              return [2, audioBuffer.getChannelData(channel)];
+          }
+        });
+      });
+    };
+    Essentia2.prototype.audioBufferToMonoSignal = function(buffer) {
+      if (buffer.numberOfChannels === 1) {
+        return buffer.getChannelData(0);
+      }
+      if (buffer.numberOfChannels === 2) {
+        var left = this.arrayToVector(buffer.getChannelData(0));
+        var right = this.arrayToVector(buffer.getChannelData(1));
+        var monoSignal = this.MonoMixer(left, right).audio;
+        return this.vectorToArray(monoSignal);
+      }
+      throw new Error("Unexpected number of channels found in audio buffer. Only accepts mono or stereo audio buffers.");
+    };
+    Essentia2.prototype.shutdown = function() {
+      this.algorithms.shutdown();
+    };
+    Essentia2.prototype.reinstantiate = function() {
+      this.algorithms = new this.module.EssentiaJS(this.isDebug);
+    };
+    Essentia2.prototype.delete = function() {
+      this.algorithms.delete();
+    };
+    Essentia2.prototype.arrayToVector = function(inputArray) {
+      return this.module.arrayToVector(inputArray);
+    };
+    Essentia2.prototype.vectorToArray = function(inputVector) {
+      return this.module.vectorToArray(inputVector);
+    };
+    Essentia2.prototype.FrameGenerator = function(inputAudioData, frameSize, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 1024;
+      }
+      return this.algorithms.FrameGenerator(inputAudioData, frameSize, hopSize);
+    };
+    Essentia2.prototype.MonoMixer = function(leftSignal, rightSignal) {
+      return this.algorithms.MonoMixer(leftSignal, rightSignal);
+    };
+    Essentia2.prototype.LoudnessEBUR128 = function(leftSignal, rightSignal, hopSize, sampleRate, startAtZero) {
+      if (hopSize === void 0) {
+        hopSize = 0.1;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startAtZero === void 0) {
+        startAtZero = false;
+      }
+      return this.algorithms.LoudnessEBUR128(leftSignal, rightSignal, hopSize, sampleRate, startAtZero);
+    };
+    Essentia2.prototype.AfterMaxToBeforeMaxEnergyRatio = function(pitch) {
+      return this.algorithms.AfterMaxToBeforeMaxEnergyRatio(pitch);
+    };
+    Essentia2.prototype.AllPass = function(signal, bandwidth, cutoffFrequency, order, sampleRate) {
+      if (bandwidth === void 0) {
+        bandwidth = 500;
+      }
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 1500;
+      }
+      if (order === void 0) {
+        order = 1;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.AllPass(signal, bandwidth, cutoffFrequency, order, sampleRate);
+    };
+    Essentia2.prototype.AudioOnsetsMarker = function(signal, onsets, sampleRate, type) {
+      if (onsets === void 0) {
+        onsets = [];
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "beep";
+      }
+      var veconsets = new this.module.VectorFloat();
+      for (var i = 0; i < veconsets.size(); i++) {
+        veconsets.push_back(onsets[i]);
+      }
+      return this.algorithms.AudioOnsetsMarker(signal, veconsets, sampleRate, type);
+    };
+    Essentia2.prototype.AutoCorrelation = function(array, frequencyDomainCompression, generalized, normalization) {
+      if (frequencyDomainCompression === void 0) {
+        frequencyDomainCompression = 0.5;
+      }
+      if (generalized === void 0) {
+        generalized = false;
+      }
+      if (normalization === void 0) {
+        normalization = "standard";
+      }
+      return this.algorithms.AutoCorrelation(array, frequencyDomainCompression, generalized, normalization);
+    };
+    Essentia2.prototype.BFCC = function(spectrum, dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, type, weighting) {
+      if (dctType === void 0) {
+        dctType = 2;
+      }
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 11e3;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (liftering === void 0) {
+        liftering = 0;
+      }
+      if (logType === void 0) {
+        logType = "dbamp";
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 0;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (numberBands === void 0) {
+        numberBands = 40;
+      }
+      if (numberCoefficients === void 0) {
+        numberCoefficients = 13;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (weighting === void 0) {
+        weighting = "warping";
+      }
+      return this.algorithms.BFCC(spectrum, dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, type, weighting);
+    };
+    Essentia2.prototype.BPF = function(x, xPoints, yPoints) {
+      if (xPoints === void 0) {
+        xPoints = [0, 1];
+      }
+      if (yPoints === void 0) {
+        yPoints = [0, 1];
+      }
+      var vecxPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecxPoints.size(); i++) {
+        vecxPoints.push_back(xPoints[i]);
+      }
+      var vecyPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecyPoints.size(); i++) {
+        vecyPoints.push_back(yPoints[i]);
+      }
+      return this.algorithms.BPF(x, vecxPoints, vecyPoints);
+    };
+    Essentia2.prototype.BandPass = function(signal, bandwidth, cutoffFrequency, sampleRate) {
+      if (bandwidth === void 0) {
+        bandwidth = 500;
+      }
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.BandPass(signal, bandwidth, cutoffFrequency, sampleRate);
+    };
+    Essentia2.prototype.BandReject = function(signal, bandwidth, cutoffFrequency, sampleRate) {
+      if (bandwidth === void 0) {
+        bandwidth = 500;
+      }
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.BandReject(signal, bandwidth, cutoffFrequency, sampleRate);
+    };
+    Essentia2.prototype.BarkBands = function(spectrum, numberBands, sampleRate) {
+      if (numberBands === void 0) {
+        numberBands = 27;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.BarkBands(spectrum, numberBands, sampleRate);
+    };
+    Essentia2.prototype.BeatTrackerDegara = function(signal, maxTempo, minTempo) {
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      return this.algorithms.BeatTrackerDegara(signal, maxTempo, minTempo);
+    };
+    Essentia2.prototype.BeatTrackerMultiFeature = function(signal, maxTempo, minTempo) {
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      return this.algorithms.BeatTrackerMultiFeature(signal, maxTempo, minTempo);
+    };
+    Essentia2.prototype.Beatogram = function(loudness, loudnessBandRatio, size) {
+      if (size === void 0) {
+        size = 16;
+      }
+      return this.algorithms.Beatogram(loudness, loudnessBandRatio, size);
+    };
+    Essentia2.prototype.BeatsLoudness = function(signal, beatDuration, beatWindowDuration, beats, frequencyBands, sampleRate) {
+      if (beatDuration === void 0) {
+        beatDuration = 0.05;
+      }
+      if (beatWindowDuration === void 0) {
+        beatWindowDuration = 0.1;
+      }
+      if (beats === void 0) {
+        beats = [];
+      }
+      if (frequencyBands === void 0) {
+        frequencyBands = [20, 150, 400, 3200, 7e3, 22e3];
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      var vecbeats = new this.module.VectorFloat();
+      for (var i = 0; i < vecbeats.size(); i++) {
+        vecbeats.push_back(beats[i]);
+      }
+      var vecfrequencyBands = new this.module.VectorFloat();
+      for (var i = 0; i < vecfrequencyBands.size(); i++) {
+        vecfrequencyBands.push_back(frequencyBands[i]);
+      }
+      return this.algorithms.BeatsLoudness(signal, beatDuration, beatWindowDuration, vecbeats, vecfrequencyBands, sampleRate);
+    };
+    Essentia2.prototype.BinaryOperator = function(array1, array2, type) {
+      if (type === void 0) {
+        type = "add";
+      }
+      return this.algorithms.BinaryOperator(array1, array2, type);
+    };
+    Essentia2.prototype.BinaryOperatorStream = function(array1, array2, type) {
+      if (type === void 0) {
+        type = "add";
+      }
+      return this.algorithms.BinaryOperatorStream(array1, array2, type);
+    };
+    Essentia2.prototype.BpmHistogramDescriptors = function(bpmIntervals) {
+      return this.algorithms.BpmHistogramDescriptors(bpmIntervals);
+    };
+    Essentia2.prototype.BpmRubato = function(beats, longRegionsPruningTime, shortRegionsMergingTime, tolerance) {
+      if (longRegionsPruningTime === void 0) {
+        longRegionsPruningTime = 20;
+      }
+      if (shortRegionsMergingTime === void 0) {
+        shortRegionsMergingTime = 4;
+      }
+      if (tolerance === void 0) {
+        tolerance = 0.08;
+      }
+      return this.algorithms.BpmRubato(beats, longRegionsPruningTime, shortRegionsMergingTime, tolerance);
+    };
+    Essentia2.prototype.CentralMoments = function(array, mode, range) {
+      if (mode === void 0) {
+        mode = "pdf";
+      }
+      if (range === void 0) {
+        range = 1;
+      }
+      return this.algorithms.CentralMoments(array, mode, range);
+    };
+    Essentia2.prototype.Centroid = function(array, range) {
+      if (range === void 0) {
+        range = 1;
+      }
+      return this.algorithms.Centroid(array, range);
+    };
+    Essentia2.prototype.ChordsDescriptors = function(chords, key, scale) {
+      return this.algorithms.ChordsDescriptors(chords, key, scale);
+    };
+    Essentia2.prototype.ChordsDetection = function(pcp, hopSize, sampleRate, windowSize) {
+      if (hopSize === void 0) {
+        hopSize = 2048;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (windowSize === void 0) {
+        windowSize = 2;
+      }
+      return this.algorithms.ChordsDetection(pcp, hopSize, sampleRate, windowSize);
+    };
+    Essentia2.prototype.ChordsDetectionBeats = function(pcp, ticks, chromaPick, hopSize, sampleRate) {
+      if (chromaPick === void 0) {
+        chromaPick = "interbeat_median";
+      }
+      if (hopSize === void 0) {
+        hopSize = 2048;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.ChordsDetectionBeats(pcp, ticks, chromaPick, hopSize, sampleRate);
+    };
+    Essentia2.prototype.ChromaCrossSimilarity = function(queryFeature, referenceFeature, binarizePercentile, frameStackSize, frameStackStride, noti, oti, otiBinary, streaming) {
+      if (binarizePercentile === void 0) {
+        binarizePercentile = 0.095;
+      }
+      if (frameStackSize === void 0) {
+        frameStackSize = 9;
+      }
+      if (frameStackStride === void 0) {
+        frameStackStride = 1;
+      }
+      if (noti === void 0) {
+        noti = 12;
+      }
+      if (oti === void 0) {
+        oti = true;
+      }
+      if (otiBinary === void 0) {
+        otiBinary = false;
+      }
+      if (streaming === void 0) {
+        streaming = false;
+      }
+      return this.algorithms.ChromaCrossSimilarity(queryFeature, referenceFeature, binarizePercentile, frameStackSize, frameStackStride, noti, oti, otiBinary, streaming);
+    };
+    Essentia2.prototype.Chromagram = function(frame, binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase) {
+      if (binsPerOctave === void 0) {
+        binsPerOctave = 12;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 32.7;
+      }
+      if (minimumKernelSize === void 0) {
+        minimumKernelSize = 4;
+      }
+      if (normalizeType === void 0) {
+        normalizeType = "unit_max";
+      }
+      if (numberBins === void 0) {
+        numberBins = 84;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (scale === void 0) {
+        scale = 1;
+      }
+      if (threshold === void 0) {
+        threshold = 0.01;
+      }
+      if (windowType === void 0) {
+        windowType = "hann";
+      }
+      if (zeroPhase === void 0) {
+        zeroPhase = true;
+      }
+      return this.algorithms.Chromagram(frame, binsPerOctave, minFrequency, minimumKernelSize, normalizeType, numberBins, sampleRate, scale, threshold, windowType, zeroPhase);
+    };
+    Essentia2.prototype.ClickDetector = function(frame, detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold) {
+      if (detectionThreshold === void 0) {
+        detectionThreshold = 30;
+      }
+      if (frameSize === void 0) {
+        frameSize = 512;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (order === void 0) {
+        order = 12;
+      }
+      if (powerEstimationThreshold === void 0) {
+        powerEstimationThreshold = 10;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = -50;
+      }
+      return this.algorithms.ClickDetector(frame, detectionThreshold, frameSize, hopSize, order, powerEstimationThreshold, sampleRate, silenceThreshold);
+    };
+    Essentia2.prototype.Clipper = function(signal, max, min) {
+      if (max === void 0) {
+        max = 1;
+      }
+      if (min === void 0) {
+        min = -1;
+      }
+      return this.algorithms.Clipper(signal, max, min);
+    };
+    Essentia2.prototype.CoverSongSimilarity = function(inputArray, alignmentType, disExtension, disOnset, distanceType) {
+      if (alignmentType === void 0) {
+        alignmentType = "serra09";
+      }
+      if (disExtension === void 0) {
+        disExtension = 0.5;
+      }
+      if (disOnset === void 0) {
+        disOnset = 0.5;
+      }
+      if (distanceType === void 0) {
+        distanceType = "asymmetric";
+      }
+      return this.algorithms.CoverSongSimilarity(inputArray, alignmentType, disExtension, disOnset, distanceType);
+    };
+    Essentia2.prototype.Crest = function(array) {
+      return this.algorithms.Crest(array);
+    };
+    Essentia2.prototype.CrossCorrelation = function(arrayX, arrayY, maxLag, minLag) {
+      if (maxLag === void 0) {
+        maxLag = 1;
+      }
+      if (minLag === void 0) {
+        minLag = 0;
+      }
+      return this.algorithms.CrossCorrelation(arrayX, arrayY, maxLag, minLag);
+    };
+    Essentia2.prototype.CrossSimilarityMatrix = function(queryFeature, referenceFeature, binarize, binarizePercentile, frameStackSize, frameStackStride) {
+      if (binarize === void 0) {
+        binarize = false;
+      }
+      if (binarizePercentile === void 0) {
+        binarizePercentile = 0.095;
+      }
+      if (frameStackSize === void 0) {
+        frameStackSize = 1;
+      }
+      if (frameStackStride === void 0) {
+        frameStackStride = 1;
+      }
+      return this.algorithms.CrossSimilarityMatrix(queryFeature, referenceFeature, binarize, binarizePercentile, frameStackSize, frameStackStride);
+    };
+    Essentia2.prototype.CubicSpline = function(x, leftBoundaryFlag, leftBoundaryValue, rightBoundaryFlag, rightBoundaryValue, xPoints, yPoints) {
+      if (leftBoundaryFlag === void 0) {
+        leftBoundaryFlag = 0;
+      }
+      if (leftBoundaryValue === void 0) {
+        leftBoundaryValue = 0;
+      }
+      if (rightBoundaryFlag === void 0) {
+        rightBoundaryFlag = 0;
+      }
+      if (rightBoundaryValue === void 0) {
+        rightBoundaryValue = 0;
+      }
+      if (xPoints === void 0) {
+        xPoints = [0, 1];
+      }
+      if (yPoints === void 0) {
+        yPoints = [0, 1];
+      }
+      var vecxPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecxPoints.size(); i++) {
+        vecxPoints.push_back(xPoints[i]);
+      }
+      var vecyPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecyPoints.size(); i++) {
+        vecyPoints.push_back(yPoints[i]);
+      }
+      return this.algorithms.CubicSpline(x, leftBoundaryFlag, leftBoundaryValue, rightBoundaryFlag, rightBoundaryValue, vecxPoints, vecyPoints);
+    };
+    Essentia2.prototype.DCRemoval = function(signal, cutoffFrequency, sampleRate) {
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 40;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.DCRemoval(signal, cutoffFrequency, sampleRate);
+    };
+    Essentia2.prototype.DCT = function(array, dctType, inputSize, liftering, outputSize) {
+      if (dctType === void 0) {
+        dctType = 2;
+      }
+      if (inputSize === void 0) {
+        inputSize = 10;
+      }
+      if (liftering === void 0) {
+        liftering = 0;
+      }
+      if (outputSize === void 0) {
+        outputSize = 10;
+      }
+      return this.algorithms.DCT(array, dctType, inputSize, liftering, outputSize);
+    };
+    Essentia2.prototype.Danceability = function(signal, maxTau, minTau, sampleRate, tauMultiplier) {
+      if (maxTau === void 0) {
+        maxTau = 8800;
+      }
+      if (minTau === void 0) {
+        minTau = 310;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tauMultiplier === void 0) {
+        tauMultiplier = 1.1;
+      }
+      return this.algorithms.Danceability(signal, maxTau, minTau, sampleRate, tauMultiplier);
+    };
+    Essentia2.prototype.Decrease = function(array, range) {
+      if (range === void 0) {
+        range = 1;
+      }
+      return this.algorithms.Decrease(array, range);
+    };
+    Essentia2.prototype.Derivative = function(signal) {
+      return this.algorithms.Derivative(signal);
+    };
+    Essentia2.prototype.DerivativeSFX = function(envelope) {
+      return this.algorithms.DerivativeSFX(envelope);
+    };
+    Essentia2.prototype.DiscontinuityDetector = function(frame, detectionThreshold, energyThreshold, frameSize, hopSize, kernelSize, order, silenceThreshold, subFrameSize) {
+      if (detectionThreshold === void 0) {
+        detectionThreshold = 8;
+      }
+      if (energyThreshold === void 0) {
+        energyThreshold = -60;
+      }
+      if (frameSize === void 0) {
+        frameSize = 512;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (kernelSize === void 0) {
+        kernelSize = 7;
+      }
+      if (order === void 0) {
+        order = 3;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = -50;
+      }
+      if (subFrameSize === void 0) {
+        subFrameSize = 32;
+      }
+      return this.algorithms.DiscontinuityDetector(frame, detectionThreshold, energyThreshold, frameSize, hopSize, kernelSize, order, silenceThreshold, subFrameSize);
+    };
+    Essentia2.prototype.Dissonance = function(frequencies, magnitudes) {
+      return this.algorithms.Dissonance(frequencies, magnitudes);
+    };
+    Essentia2.prototype.DistributionShape = function(centralMoments) {
+      return this.algorithms.DistributionShape(centralMoments);
+    };
+    Essentia2.prototype.Duration = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.Duration(signal, sampleRate);
+    };
+    Essentia2.prototype.DynamicComplexity = function(signal, frameSize, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 0.2;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.DynamicComplexity(signal, frameSize, sampleRate);
+    };
+    Essentia2.prototype.ERBBands = function(spectrum, highFrequencyBound, inputSize, lowFrequencyBound, numberBands, sampleRate, type, width) {
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 22050;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 50;
+      }
+      if (numberBands === void 0) {
+        numberBands = 40;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (width === void 0) {
+        width = 1;
+      }
+      return this.algorithms.ERBBands(spectrum, highFrequencyBound, inputSize, lowFrequencyBound, numberBands, sampleRate, type, width);
+    };
+    Essentia2.prototype.EffectiveDuration = function(signal, sampleRate, thresholdRatio) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (thresholdRatio === void 0) {
+        thresholdRatio = 0.4;
+      }
+      return this.algorithms.EffectiveDuration(signal, sampleRate, thresholdRatio);
+    };
+    Essentia2.prototype.Energy = function(array) {
+      return this.algorithms.Energy(array);
+    };
+    Essentia2.prototype.EnergyBand = function(spectrum, sampleRate, startCutoffFrequency, stopCutoffFrequency) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startCutoffFrequency === void 0) {
+        startCutoffFrequency = 0;
+      }
+      if (stopCutoffFrequency === void 0) {
+        stopCutoffFrequency = 100;
+      }
+      return this.algorithms.EnergyBand(spectrum, sampleRate, startCutoffFrequency, stopCutoffFrequency);
+    };
+    Essentia2.prototype.EnergyBandRatio = function(spectrum, sampleRate, startFrequency, stopFrequency) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startFrequency === void 0) {
+        startFrequency = 0;
+      }
+      if (stopFrequency === void 0) {
+        stopFrequency = 100;
+      }
+      return this.algorithms.EnergyBandRatio(spectrum, sampleRate, startFrequency, stopFrequency);
+    };
+    Essentia2.prototype.Entropy = function(array) {
+      return this.algorithms.Entropy(array);
+    };
+    Essentia2.prototype.Envelope = function(signal, applyRectification, attackTime, releaseTime, sampleRate) {
+      if (applyRectification === void 0) {
+        applyRectification = true;
+      }
+      if (attackTime === void 0) {
+        attackTime = 10;
+      }
+      if (releaseTime === void 0) {
+        releaseTime = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.Envelope(signal, applyRectification, attackTime, releaseTime, sampleRate);
+    };
+    Essentia2.prototype.EqualLoudness = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.EqualLoudness(signal, sampleRate);
+    };
+    Essentia2.prototype.Flatness = function(array) {
+      return this.algorithms.Flatness(array);
+    };
+    Essentia2.prototype.FlatnessDB = function(array) {
+      return this.algorithms.FlatnessDB(array);
+    };
+    Essentia2.prototype.FlatnessSFX = function(envelope) {
+      return this.algorithms.FlatnessSFX(envelope);
+    };
+    Essentia2.prototype.Flux = function(spectrum, halfRectify, norm) {
+      if (halfRectify === void 0) {
+        halfRectify = false;
+      }
+      if (norm === void 0) {
+        norm = "L2";
+      }
+      return this.algorithms.Flux(spectrum, halfRectify, norm);
+    };
+    Essentia2.prototype.FrameCutter = function(signal, frameSize, hopSize, lastFrameToEndOfFile, startFromZero, validFrameThresholdRatio) {
+      if (frameSize === void 0) {
+        frameSize = 1024;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (lastFrameToEndOfFile === void 0) {
+        lastFrameToEndOfFile = false;
+      }
+      if (startFromZero === void 0) {
+        startFromZero = false;
+      }
+      if (validFrameThresholdRatio === void 0) {
+        validFrameThresholdRatio = 0;
+      }
+      return this.algorithms.FrameCutter(signal, frameSize, hopSize, lastFrameToEndOfFile, startFromZero, validFrameThresholdRatio);
+    };
+    Essentia2.prototype.FrameToReal = function(signal, frameSize, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      return this.algorithms.FrameToReal(signal, frameSize, hopSize);
+    };
+    Essentia2.prototype.FrequencyBands = function(spectrum, frequencyBands, sampleRate) {
+      if (frequencyBands === void 0) {
+        frequencyBands = [0, 50, 100, 150, 200, 300, 400, 510, 630, 770, 920, 1080, 1270, 1480, 1720, 2e3, 2320, 2700, 3150, 3700, 4400, 5300, 6400, 7700, 9500, 12e3, 15500, 20500, 27e3];
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      var vecfrequencyBands = new this.module.VectorFloat();
+      for (var i = 0; i < vecfrequencyBands.size(); i++) {
+        vecfrequencyBands.push_back(frequencyBands[i]);
+      }
+      return this.algorithms.FrequencyBands(spectrum, vecfrequencyBands, sampleRate);
+    };
+    Essentia2.prototype.GFCC = function(spectrum, dctType, highFrequencyBound, inputSize, logType, lowFrequencyBound, numberBands, numberCoefficients, sampleRate, silenceThreshold, type) {
+      if (dctType === void 0) {
+        dctType = 2;
+      }
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 22050;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (logType === void 0) {
+        logType = "dbamp";
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 40;
+      }
+      if (numberBands === void 0) {
+        numberBands = 40;
+      }
+      if (numberCoefficients === void 0) {
+        numberCoefficients = 13;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = 1e-10;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      return this.algorithms.GFCC(spectrum, dctType, highFrequencyBound, inputSize, logType, lowFrequencyBound, numberBands, numberCoefficients, sampleRate, silenceThreshold, type);
+    };
+    Essentia2.prototype.GapsDetector = function(frame, attackTime, frameSize, hopSize, kernelSize, maximumTime, minimumTime, postpowerTime, prepowerThreshold, prepowerTime, releaseTime, sampleRate, silenceThreshold) {
+      if (attackTime === void 0) {
+        attackTime = 0.05;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 1024;
+      }
+      if (kernelSize === void 0) {
+        kernelSize = 11;
+      }
+      if (maximumTime === void 0) {
+        maximumTime = 3500;
+      }
+      if (minimumTime === void 0) {
+        minimumTime = 10;
+      }
+      if (postpowerTime === void 0) {
+        postpowerTime = 40;
+      }
+      if (prepowerThreshold === void 0) {
+        prepowerThreshold = -30;
+      }
+      if (prepowerTime === void 0) {
+        prepowerTime = 40;
+      }
+      if (releaseTime === void 0) {
+        releaseTime = 0.05;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = -50;
+      }
+      return this.algorithms.GapsDetector(frame, attackTime, frameSize, hopSize, kernelSize, maximumTime, minimumTime, postpowerTime, prepowerThreshold, prepowerTime, releaseTime, sampleRate, silenceThreshold);
+    };
+    Essentia2.prototype.GeometricMean = function(array) {
+      return this.algorithms.GeometricMean(array);
+    };
+    Essentia2.prototype.HFC = function(spectrum, sampleRate, type) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "Masri";
+      }
+      return this.algorithms.HFC(spectrum, sampleRate, type);
+    };
+    Essentia2.prototype.HPCP = function(frequencies, magnitudes, bandPreset, bandSplitFrequency, harmonics, maxFrequency, maxShifted, minFrequency, nonLinear, normalized, referenceFrequency, sampleRate, size, weightType, windowSize) {
+      if (bandPreset === void 0) {
+        bandPreset = true;
+      }
+      if (bandSplitFrequency === void 0) {
+        bandSplitFrequency = 500;
+      }
+      if (harmonics === void 0) {
+        harmonics = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxShifted === void 0) {
+        maxShifted = false;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 40;
+      }
+      if (nonLinear === void 0) {
+        nonLinear = false;
+      }
+      if (normalized === void 0) {
+        normalized = "unitMax";
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 440;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (size === void 0) {
+        size = 12;
+      }
+      if (weightType === void 0) {
+        weightType = "squaredCosine";
+      }
+      if (windowSize === void 0) {
+        windowSize = 1;
+      }
+      return this.algorithms.HPCP(frequencies, magnitudes, bandPreset, bandSplitFrequency, harmonics, maxFrequency, maxShifted, minFrequency, nonLinear, normalized, referenceFrequency, sampleRate, size, weightType, windowSize);
+    };
+    Essentia2.prototype.HarmonicBpm = function(bpms, bpm, threshold, tolerance) {
+      if (bpm === void 0) {
+        bpm = 60;
+      }
+      if (threshold === void 0) {
+        threshold = 20;
+      }
+      if (tolerance === void 0) {
+        tolerance = 5;
+      }
+      return this.algorithms.HarmonicBpm(bpms, bpm, threshold, tolerance);
+    };
+    Essentia2.prototype.HarmonicPeaks = function(frequencies, magnitudes, pitch, maxHarmonics, tolerance) {
+      if (maxHarmonics === void 0) {
+        maxHarmonics = 20;
+      }
+      if (tolerance === void 0) {
+        tolerance = 0.2;
+      }
+      return this.algorithms.HarmonicPeaks(frequencies, magnitudes, pitch, maxHarmonics, tolerance);
+    };
+    Essentia2.prototype.HighPass = function(signal, cutoffFrequency, sampleRate) {
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.HighPass(signal, cutoffFrequency, sampleRate);
+    };
+    Essentia2.prototype.HighResolutionFeatures = function(hpcp, maxPeaks) {
+      if (maxPeaks === void 0) {
+        maxPeaks = 24;
+      }
+      return this.algorithms.HighResolutionFeatures(hpcp, maxPeaks);
+    };
+    Essentia2.prototype.Histogram = function(array, maxValue, minValue, normalize, numberBins) {
+      if (maxValue === void 0) {
+        maxValue = 1;
+      }
+      if (minValue === void 0) {
+        minValue = 0;
+      }
+      if (normalize === void 0) {
+        normalize = "none";
+      }
+      if (numberBins === void 0) {
+        numberBins = 10;
+      }
+      return this.algorithms.Histogram(array, maxValue, minValue, normalize, numberBins);
+    };
+    Essentia2.prototype.HprModelAnal = function(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (freqDevOffset === void 0) {
+        freqDevOffset = 20;
+      }
+      if (freqDevSlope === void 0) {
+        freqDevSlope = 0.01;
+      }
+      if (harmDevSlope === void 0) {
+        harmDevSlope = 0.01;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (maxnSines === void 0) {
+        maxnSines = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 20;
+      }
+      if (nHarmonics === void 0) {
+        nHarmonics = 100;
+      }
+      if (orderBy === void 0) {
+        orderBy = "frequency";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.HprModelAnal(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf);
+    };
+    Essentia2.prototype.HpsModelAnal = function(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (freqDevOffset === void 0) {
+        freqDevOffset = 20;
+      }
+      if (freqDevSlope === void 0) {
+        freqDevSlope = 0.01;
+      }
+      if (harmDevSlope === void 0) {
+        harmDevSlope = 0.01;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (maxnSines === void 0) {
+        maxnSines = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 20;
+      }
+      if (nHarmonics === void 0) {
+        nHarmonics = 100;
+      }
+      if (orderBy === void 0) {
+        orderBy = "frequency";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.HpsModelAnal(frame, pitch, fftSize, freqDevOffset, freqDevSlope, harmDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, nHarmonics, orderBy, sampleRate, stocf);
+    };
+    Essentia2.prototype.IDCT = function(dct, dctType, inputSize, liftering, outputSize) {
+      if (dctType === void 0) {
+        dctType = 2;
+      }
+      if (inputSize === void 0) {
+        inputSize = 10;
+      }
+      if (liftering === void 0) {
+        liftering = 0;
+      }
+      if (outputSize === void 0) {
+        outputSize = 10;
+      }
+      return this.algorithms.IDCT(dct, dctType, inputSize, liftering, outputSize);
+    };
+    Essentia2.prototype.IIR = function(signal, denominator, numerator) {
+      if (denominator === void 0) {
+        denominator = [1];
+      }
+      if (numerator === void 0) {
+        numerator = [1];
+      }
+      var vecdenominator = new this.module.VectorFloat();
+      for (var i = 0; i < vecdenominator.size(); i++) {
+        vecdenominator.push_back(denominator[i]);
+      }
+      var vecnumerator = new this.module.VectorFloat();
+      for (var i = 0; i < vecnumerator.size(); i++) {
+        vecnumerator.push_back(numerator[i]);
+      }
+      return this.algorithms.IIR(signal, vecdenominator, vecnumerator);
+    };
+    Essentia2.prototype.Inharmonicity = function(frequencies, magnitudes) {
+      return this.algorithms.Inharmonicity(frequencies, magnitudes);
+    };
+    Essentia2.prototype.InstantPower = function(array) {
+      return this.algorithms.InstantPower(array);
+    };
+    Essentia2.prototype.Intensity = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.Intensity(signal, sampleRate);
+    };
+    Essentia2.prototype.Key = function(pcp, numHarmonics, pcpSize, profileType, slope, useMajMin, usePolyphony, useThreeChords) {
+      if (numHarmonics === void 0) {
+        numHarmonics = 4;
+      }
+      if (pcpSize === void 0) {
+        pcpSize = 36;
+      }
+      if (profileType === void 0) {
+        profileType = "bgate";
+      }
+      if (slope === void 0) {
+        slope = 0.6;
+      }
+      if (useMajMin === void 0) {
+        useMajMin = false;
+      }
+      if (usePolyphony === void 0) {
+        usePolyphony = true;
+      }
+      if (useThreeChords === void 0) {
+        useThreeChords = true;
+      }
+      return this.algorithms.Key(pcp, numHarmonics, pcpSize, profileType, slope, useMajMin, usePolyphony, useThreeChords);
+    };
+    Essentia2.prototype.KeyExtractor = function(audio, averageDetuningCorrection, frameSize, hopSize, hpcpSize, maxFrequency, maximumSpectralPeaks, minFrequency, pcpThreshold, profileType, sampleRate, spectralPeaksThreshold, tuningFrequency, weightType, windowType) {
+      if (averageDetuningCorrection === void 0) {
+        averageDetuningCorrection = true;
+      }
+      if (frameSize === void 0) {
+        frameSize = 4096;
+      }
+      if (hopSize === void 0) {
+        hopSize = 4096;
+      }
+      if (hpcpSize === void 0) {
+        hpcpSize = 12;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 3500;
+      }
+      if (maximumSpectralPeaks === void 0) {
+        maximumSpectralPeaks = 60;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 25;
+      }
+      if (pcpThreshold === void 0) {
+        pcpThreshold = 0.2;
+      }
+      if (profileType === void 0) {
+        profileType = "bgate";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (spectralPeaksThreshold === void 0) {
+        spectralPeaksThreshold = 1e-4;
+      }
+      if (tuningFrequency === void 0) {
+        tuningFrequency = 440;
+      }
+      if (weightType === void 0) {
+        weightType = "cosine";
+      }
+      if (windowType === void 0) {
+        windowType = "hann";
+      }
+      return this.algorithms.KeyExtractor(audio, averageDetuningCorrection, frameSize, hopSize, hpcpSize, maxFrequency, maximumSpectralPeaks, minFrequency, pcpThreshold, profileType, sampleRate, spectralPeaksThreshold, tuningFrequency, weightType, windowType);
+    };
+    Essentia2.prototype.LPC = function(frame, order, sampleRate, type) {
+      if (order === void 0) {
+        order = 10;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "regular";
+      }
+      return this.algorithms.LPC(frame, order, sampleRate, type);
+    };
+    Essentia2.prototype.Larm = function(signal, attackTime, power, releaseTime, sampleRate) {
+      if (attackTime === void 0) {
+        attackTime = 10;
+      }
+      if (power === void 0) {
+        power = 1.5;
+      }
+      if (releaseTime === void 0) {
+        releaseTime = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.Larm(signal, attackTime, power, releaseTime, sampleRate);
+    };
+    Essentia2.prototype.Leq = function(signal) {
+      return this.algorithms.Leq(signal);
+    };
+    Essentia2.prototype.LevelExtractor = function(signal, frameSize, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 88200;
+      }
+      if (hopSize === void 0) {
+        hopSize = 44100;
+      }
+      return this.algorithms.LevelExtractor(signal, frameSize, hopSize);
+    };
+    Essentia2.prototype.LogAttackTime = function(signal, sampleRate, startAttackThreshold, stopAttackThreshold) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startAttackThreshold === void 0) {
+        startAttackThreshold = 0.2;
+      }
+      if (stopAttackThreshold === void 0) {
+        stopAttackThreshold = 0.9;
+      }
+      return this.algorithms.LogAttackTime(signal, sampleRate, startAttackThreshold, stopAttackThreshold);
+    };
+    Essentia2.prototype.LogSpectrum = function(spectrum, binsPerSemitone, frameSize, rollOn, sampleRate) {
+      if (binsPerSemitone === void 0) {
+        binsPerSemitone = 3;
+      }
+      if (frameSize === void 0) {
+        frameSize = 1025;
+      }
+      if (rollOn === void 0) {
+        rollOn = 0;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LogSpectrum(spectrum, binsPerSemitone, frameSize, rollOn, sampleRate);
+    };
+    Essentia2.prototype.LoopBpmConfidence = function(signal, bpmEstimate, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LoopBpmConfidence(signal, bpmEstimate, sampleRate);
+    };
+    Essentia2.prototype.LoopBpmEstimator = function(signal, confidenceThreshold) {
+      if (confidenceThreshold === void 0) {
+        confidenceThreshold = 0.95;
+      }
+      return this.algorithms.LoopBpmEstimator(signal, confidenceThreshold);
+    };
+    Essentia2.prototype.Loudness = function(signal) {
+      return this.algorithms.Loudness(signal);
+    };
+    Essentia2.prototype.LoudnessVickers = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LoudnessVickers(signal, sampleRate);
+    };
+    Essentia2.prototype.LowLevelSpectralEqloudExtractor = function(signal, frameSize, hopSize, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 1024;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LowLevelSpectralEqloudExtractor(signal, frameSize, hopSize, sampleRate);
+    };
+    Essentia2.prototype.LowLevelSpectralExtractor = function(signal, frameSize, hopSize, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 1024;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LowLevelSpectralExtractor(signal, frameSize, hopSize, sampleRate);
+    };
+    Essentia2.prototype.LowPass = function(signal, cutoffFrequency, sampleRate) {
+      if (cutoffFrequency === void 0) {
+        cutoffFrequency = 1500;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.LowPass(signal, cutoffFrequency, sampleRate);
+    };
+    Essentia2.prototype.MFCC = function(spectrum, dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, silenceThreshold, type, warpingFormula, weighting) {
+      if (dctType === void 0) {
+        dctType = 2;
+      }
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 11e3;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (liftering === void 0) {
+        liftering = 0;
+      }
+      if (logType === void 0) {
+        logType = "dbamp";
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 0;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (numberBands === void 0) {
+        numberBands = 40;
+      }
+      if (numberCoefficients === void 0) {
+        numberCoefficients = 13;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = 1e-10;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (warpingFormula === void 0) {
+        warpingFormula = "htkMel";
+      }
+      if (weighting === void 0) {
+        weighting = "warping";
+      }
+      return this.algorithms.MFCC(spectrum, dctType, highFrequencyBound, inputSize, liftering, logType, lowFrequencyBound, normalize, numberBands, numberCoefficients, sampleRate, silenceThreshold, type, warpingFormula, weighting);
+    };
+    Essentia2.prototype.MaxFilter = function(signal, causal, width) {
+      if (causal === void 0) {
+        causal = true;
+      }
+      if (width === void 0) {
+        width = 3;
+      }
+      return this.algorithms.MaxFilter(signal, causal, width);
+    };
+    Essentia2.prototype.MaxMagFreq = function(spectrum, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.MaxMagFreq(spectrum, sampleRate);
+    };
+    Essentia2.prototype.MaxToTotal = function(envelope) {
+      return this.algorithms.MaxToTotal(envelope);
+    };
+    Essentia2.prototype.Mean = function(array) {
+      return this.algorithms.Mean(array);
+    };
+    Essentia2.prototype.Median = function(array) {
+      return this.algorithms.Median(array);
+    };
+    Essentia2.prototype.MedianFilter = function(array, kernelSize) {
+      if (kernelSize === void 0) {
+        kernelSize = 11;
+      }
+      return this.algorithms.MedianFilter(array, kernelSize);
+    };
+    Essentia2.prototype.MelBands = function(spectrum, highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, warpingFormula, weighting) {
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 22050;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (log === void 0) {
+        log = false;
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 0;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (numberBands === void 0) {
+        numberBands = 24;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (warpingFormula === void 0) {
+        warpingFormula = "htkMel";
+      }
+      if (weighting === void 0) {
+        weighting = "warping";
+      }
+      return this.algorithms.MelBands(spectrum, highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, warpingFormula, weighting);
+    };
+    Essentia2.prototype.Meter = function(beatogram) {
+      return this.algorithms.Meter(beatogram);
+    };
+    Essentia2.prototype.MinMax = function(array, type) {
+      if (type === void 0) {
+        type = "min";
+      }
+      return this.algorithms.MinMax(array, type);
+    };
+    Essentia2.prototype.MinToTotal = function(envelope) {
+      return this.algorithms.MinToTotal(envelope);
+    };
+    Essentia2.prototype.MovingAverage = function(signal, size) {
+      if (size === void 0) {
+        size = 6;
+      }
+      return this.algorithms.MovingAverage(signal, size);
+    };
+    Essentia2.prototype.MultiPitchKlapuri = function(signal, binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minFrequency, numberHarmonics, referenceFrequency, sampleRate) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.8;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 1760;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 80;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 10;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.MultiPitchKlapuri(signal, binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minFrequency, numberHarmonics, referenceFrequency, sampleRate);
+    };
+    Essentia2.prototype.MultiPitchMelodia = function(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.8;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minDuration === void 0) {
+        minDuration = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 40;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 20;
+      }
+      if (peakDistributionThreshold === void 0) {
+        peakDistributionThreshold = 0.9;
+      }
+      if (peakFrameThreshold === void 0) {
+        peakFrameThreshold = 0.9;
+      }
+      if (pitchContinuity === void 0) {
+        pitchContinuity = 27.5625;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (timeContinuity === void 0) {
+        timeContinuity = 100;
+      }
+      return this.algorithms.MultiPitchMelodia(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity);
+    };
+    Essentia2.prototype.Multiplexer = function(numberRealInputs, numberVectorRealInputs) {
+      if (numberRealInputs === void 0) {
+        numberRealInputs = 0;
+      }
+      if (numberVectorRealInputs === void 0) {
+        numberVectorRealInputs = 0;
+      }
+      return this.algorithms.Multiplexer(numberRealInputs, numberVectorRealInputs);
+    };
+    Essentia2.prototype.NNLSChroma = function(logSpectrogram, meanTuning, localTuning, chromaNormalization, frameSize, sampleRate, spectralShape, spectralWhitening, tuningMode, useNNLS) {
+      if (chromaNormalization === void 0) {
+        chromaNormalization = "none";
+      }
+      if (frameSize === void 0) {
+        frameSize = 1025;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (spectralShape === void 0) {
+        spectralShape = 0.7;
+      }
+      if (spectralWhitening === void 0) {
+        spectralWhitening = 1;
+      }
+      if (tuningMode === void 0) {
+        tuningMode = "global";
+      }
+      if (useNNLS === void 0) {
+        useNNLS = true;
+      }
+      return this.algorithms.NNLSChroma(logSpectrogram, meanTuning, localTuning, chromaNormalization, frameSize, sampleRate, spectralShape, spectralWhitening, tuningMode, useNNLS);
+    };
+    Essentia2.prototype.NoiseAdder = function(signal, fixSeed, level) {
+      if (fixSeed === void 0) {
+        fixSeed = false;
+      }
+      if (level === void 0) {
+        level = -100;
+      }
+      return this.algorithms.NoiseAdder(signal, fixSeed, level);
+    };
+    Essentia2.prototype.NoiseBurstDetector = function(frame, alpha, silenceThreshold, threshold) {
+      if (alpha === void 0) {
+        alpha = 0.9;
+      }
+      if (silenceThreshold === void 0) {
+        silenceThreshold = -50;
+      }
+      if (threshold === void 0) {
+        threshold = 8;
+      }
+      return this.algorithms.NoiseBurstDetector(frame, alpha, silenceThreshold, threshold);
+    };
+    Essentia2.prototype.NoveltyCurve = function(frequencyBands, frameRate, normalize, weightCurve, weightCurveType) {
+      if (frameRate === void 0) {
+        frameRate = 344.531;
+      }
+      if (normalize === void 0) {
+        normalize = false;
+      }
+      if (weightCurve === void 0) {
+        weightCurve = [];
+      }
+      if (weightCurveType === void 0) {
+        weightCurveType = "hybrid";
+      }
+      var vecweightCurve = new this.module.VectorFloat();
+      for (var i = 0; i < vecweightCurve.size(); i++) {
+        vecweightCurve.push_back(weightCurve[i]);
+      }
+      return this.algorithms.NoveltyCurve(frequencyBands, frameRate, normalize, vecweightCurve, weightCurveType);
+    };
+    Essentia2.prototype.NoveltyCurveFixedBpmEstimator = function(novelty, hopSize, maxBpm, minBpm, sampleRate, tolerance) {
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (maxBpm === void 0) {
+        maxBpm = 560;
+      }
+      if (minBpm === void 0) {
+        minBpm = 30;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tolerance === void 0) {
+        tolerance = 3;
+      }
+      return this.algorithms.NoveltyCurveFixedBpmEstimator(novelty, hopSize, maxBpm, minBpm, sampleRate, tolerance);
+    };
+    Essentia2.prototype.OddToEvenHarmonicEnergyRatio = function(frequencies, magnitudes) {
+      return this.algorithms.OddToEvenHarmonicEnergyRatio(frequencies, magnitudes);
+    };
+    Essentia2.prototype.OnsetDetection = function(spectrum, phase, method, sampleRate) {
+      if (method === void 0) {
+        method = "hfc";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.OnsetDetection(spectrum, phase, method, sampleRate);
+    };
+    Essentia2.prototype.OnsetDetectionGlobal = function(signal, frameSize, hopSize, method, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (method === void 0) {
+        method = "infogain";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.OnsetDetectionGlobal(signal, frameSize, hopSize, method, sampleRate);
+    };
+    Essentia2.prototype.OnsetRate = function(signal) {
+      return this.algorithms.OnsetRate(signal);
+    };
+    Essentia2.prototype.OverlapAdd = function(signal, frameSize, gain, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (gain === void 0) {
+        gain = 1;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      return this.algorithms.OverlapAdd(signal, frameSize, gain, hopSize);
+    };
+    Essentia2.prototype.PeakDetection = function(array, interpolate, maxPeaks, maxPosition, minPeakDistance, minPosition, orderBy, range, threshold) {
+      if (interpolate === void 0) {
+        interpolate = true;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (maxPosition === void 0) {
+        maxPosition = 1;
+      }
+      if (minPeakDistance === void 0) {
+        minPeakDistance = 0;
+      }
+      if (minPosition === void 0) {
+        minPosition = 0;
+      }
+      if (orderBy === void 0) {
+        orderBy = "position";
+      }
+      if (range === void 0) {
+        range = 1;
+      }
+      if (threshold === void 0) {
+        threshold = -1e6;
+      }
+      return this.algorithms.PeakDetection(array, interpolate, maxPeaks, maxPosition, minPeakDistance, minPosition, orderBy, range, threshold);
+    };
+    Essentia2.prototype.PercivalBpmEstimator = function(signal, frameSize, frameSizeOSS, hopSize, hopSizeOSS, maxBPM, minBPM, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 1024;
+      }
+      if (frameSizeOSS === void 0) {
+        frameSizeOSS = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (hopSizeOSS === void 0) {
+        hopSizeOSS = 128;
+      }
+      if (maxBPM === void 0) {
+        maxBPM = 210;
+      }
+      if (minBPM === void 0) {
+        minBPM = 50;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PercivalBpmEstimator(signal, frameSize, frameSizeOSS, hopSize, hopSizeOSS, maxBPM, minBPM, sampleRate);
+    };
+    Essentia2.prototype.PercivalEnhanceHarmonics = function(array) {
+      return this.algorithms.PercivalEnhanceHarmonics(array);
+    };
+    Essentia2.prototype.PercivalEvaluatePulseTrains = function(oss, positions) {
+      return this.algorithms.PercivalEvaluatePulseTrains(oss, positions);
+    };
+    Essentia2.prototype.PitchContourSegmentation = function(pitch, signal, hopSize, minDuration, pitchDistanceThreshold, rmsThreshold, sampleRate, tuningFrequency) {
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (minDuration === void 0) {
+        minDuration = 0.1;
+      }
+      if (pitchDistanceThreshold === void 0) {
+        pitchDistanceThreshold = 60;
+      }
+      if (rmsThreshold === void 0) {
+        rmsThreshold = -2;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tuningFrequency === void 0) {
+        tuningFrequency = 440;
+      }
+      return this.algorithms.PitchContourSegmentation(pitch, signal, hopSize, minDuration, pitchDistanceThreshold, rmsThreshold, sampleRate, tuningFrequency);
+    };
+    Essentia2.prototype.PitchContours = function(peakBins, peakSaliences, binResolution, hopSize, minDuration, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, sampleRate, timeContinuity) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (minDuration === void 0) {
+        minDuration = 100;
+      }
+      if (peakDistributionThreshold === void 0) {
+        peakDistributionThreshold = 0.9;
+      }
+      if (peakFrameThreshold === void 0) {
+        peakFrameThreshold = 0.9;
+      }
+      if (pitchContinuity === void 0) {
+        pitchContinuity = 27.5625;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (timeContinuity === void 0) {
+        timeContinuity = 100;
+      }
+      return this.algorithms.PitchContours(peakBins, peakSaliences, binResolution, hopSize, minDuration, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, sampleRate, timeContinuity);
+    };
+    Essentia2.prototype.PitchContoursMelody = function(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate, voiceVibrato, voicingTolerance) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 80;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (voiceVibrato === void 0) {
+        voiceVibrato = false;
+      }
+      if (voicingTolerance === void 0) {
+        voicingTolerance = 0.2;
+      }
+      return this.algorithms.PitchContoursMelody(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate, voiceVibrato, voicingTolerance);
+    };
+    Essentia2.prototype.PitchContoursMonoMelody = function(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 80;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PitchContoursMonoMelody(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate);
+    };
+    Essentia2.prototype.PitchContoursMultiMelody = function(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 80;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PitchContoursMultiMelody(contoursBins, contoursSaliences, contoursStartTimes, duration, binResolution, filterIterations, guessUnvoiced, hopSize, maxFrequency, minFrequency, referenceFrequency, sampleRate);
+    };
+    Essentia2.prototype.PitchFilter = function(pitch, pitchConfidence, confidenceThreshold, minChunkSize, useAbsolutePitchConfidence) {
+      if (confidenceThreshold === void 0) {
+        confidenceThreshold = 36;
+      }
+      if (minChunkSize === void 0) {
+        minChunkSize = 30;
+      }
+      if (useAbsolutePitchConfidence === void 0) {
+        useAbsolutePitchConfidence = false;
+      }
+      return this.algorithms.PitchFilter(pitch, pitchConfidence, confidenceThreshold, minChunkSize, useAbsolutePitchConfidence);
+    };
+    Essentia2.prototype.PitchMelodia = function(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.8;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minDuration === void 0) {
+        minDuration = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 40;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 20;
+      }
+      if (peakDistributionThreshold === void 0) {
+        peakDistributionThreshold = 0.9;
+      }
+      if (peakFrameThreshold === void 0) {
+        peakFrameThreshold = 0.9;
+      }
+      if (pitchContinuity === void 0) {
+        pitchContinuity = 27.5625;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (timeContinuity === void 0) {
+        timeContinuity = 100;
+      }
+      return this.algorithms.PitchMelodia(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity);
+    };
+    Essentia2.prototype.PitchSalience = function(spectrum, highBoundary, lowBoundary, sampleRate) {
+      if (highBoundary === void 0) {
+        highBoundary = 5e3;
+      }
+      if (lowBoundary === void 0) {
+        lowBoundary = 100;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PitchSalience(spectrum, highBoundary, lowBoundary, sampleRate);
+    };
+    Essentia2.prototype.PitchSalienceFunction = function(frequencies, magnitudes, binResolution, harmonicWeight, magnitudeCompression, magnitudeThreshold, numberHarmonics, referenceFrequency) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.8;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 20;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      return this.algorithms.PitchSalienceFunction(frequencies, magnitudes, binResolution, harmonicWeight, magnitudeCompression, magnitudeThreshold, numberHarmonics, referenceFrequency);
+    };
+    Essentia2.prototype.PitchSalienceFunctionPeaks = function(salienceFunction, binResolution, maxFrequency, minFrequency, referenceFrequency) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 1760;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 55;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      return this.algorithms.PitchSalienceFunctionPeaks(salienceFunction, binResolution, maxFrequency, minFrequency, referenceFrequency);
+    };
+    Essentia2.prototype.PitchYin = function(signal, frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (interpolate === void 0) {
+        interpolate = true;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 22050;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 20;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tolerance === void 0) {
+        tolerance = 0.15;
+      }
+      return this.algorithms.PitchYin(signal, frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance);
+    };
+    Essentia2.prototype.PitchYinFFT = function(spectrum, frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (interpolate === void 0) {
+        interpolate = true;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 22050;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 20;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tolerance === void 0) {
+        tolerance = 1;
+      }
+      return this.algorithms.PitchYinFFT(spectrum, frameSize, interpolate, maxFrequency, minFrequency, sampleRate, tolerance);
+    };
+    Essentia2.prototype.PitchYinProbabilistic = function(signal, frameSize, hopSize, lowRMSThreshold, outputUnvoiced, preciseTime, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (lowRMSThreshold === void 0) {
+        lowRMSThreshold = 0.1;
+      }
+      if (outputUnvoiced === void 0) {
+        outputUnvoiced = "negative";
+      }
+      if (preciseTime === void 0) {
+        preciseTime = false;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PitchYinProbabilistic(signal, frameSize, hopSize, lowRMSThreshold, outputUnvoiced, preciseTime, sampleRate);
+    };
+    Essentia2.prototype.PitchYinProbabilities = function(signal, frameSize, lowAmp, preciseTime, sampleRate) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (lowAmp === void 0) {
+        lowAmp = 0.1;
+      }
+      if (preciseTime === void 0) {
+        preciseTime = false;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.PitchYinProbabilities(signal, frameSize, lowAmp, preciseTime, sampleRate);
+    };
+    Essentia2.prototype.PitchYinProbabilitiesHMM = function(pitchCandidates, probabilities, minFrequency, numberBinsPerSemitone, selfTransition, yinTrust) {
+      if (minFrequency === void 0) {
+        minFrequency = 61.735;
+      }
+      if (numberBinsPerSemitone === void 0) {
+        numberBinsPerSemitone = 5;
+      }
+      if (selfTransition === void 0) {
+        selfTransition = 0.99;
+      }
+      if (yinTrust === void 0) {
+        yinTrust = 0.5;
+      }
+      return this.algorithms.PitchYinProbabilitiesHMM(pitchCandidates, probabilities, minFrequency, numberBinsPerSemitone, selfTransition, yinTrust);
+    };
+    Essentia2.prototype.PowerMean = function(array, power) {
+      if (power === void 0) {
+        power = 1;
+      }
+      return this.algorithms.PowerMean(array, power);
+    };
+    Essentia2.prototype.PowerSpectrum = function(signal, size) {
+      if (size === void 0) {
+        size = 2048;
+      }
+      return this.algorithms.PowerSpectrum(signal, size);
+    };
+    Essentia2.prototype.PredominantPitchMelodia = function(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity, voiceVibrato, voicingTolerance) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (filterIterations === void 0) {
+        filterIterations = 3;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (guessUnvoiced === void 0) {
+        guessUnvoiced = false;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.8;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 2e4;
+      }
+      if (minDuration === void 0) {
+        minDuration = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 80;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 20;
+      }
+      if (peakDistributionThreshold === void 0) {
+        peakDistributionThreshold = 0.9;
+      }
+      if (peakFrameThreshold === void 0) {
+        peakFrameThreshold = 0.9;
+      }
+      if (pitchContinuity === void 0) {
+        pitchContinuity = 27.5625;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (timeContinuity === void 0) {
+        timeContinuity = 100;
+      }
+      if (voiceVibrato === void 0) {
+        voiceVibrato = false;
+      }
+      if (voicingTolerance === void 0) {
+        voicingTolerance = 0.2;
+      }
+      return this.algorithms.PredominantPitchMelodia(signal, binResolution, filterIterations, frameSize, guessUnvoiced, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxFrequency, minDuration, minFrequency, numberHarmonics, peakDistributionThreshold, peakFrameThreshold, pitchContinuity, referenceFrequency, sampleRate, timeContinuity, voiceVibrato, voicingTolerance);
+    };
+    Essentia2.prototype.RMS = function(array) {
+      return this.algorithms.RMS(array);
+    };
+    Essentia2.prototype.RawMoments = function(array, range) {
+      if (range === void 0) {
+        range = 22050;
+      }
+      return this.algorithms.RawMoments(array, range);
+    };
+    Essentia2.prototype.ReplayGain = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.ReplayGain(signal, sampleRate);
+    };
+    Essentia2.prototype.Resample = function(signal, inputSampleRate, outputSampleRate, quality) {
+      if (inputSampleRate === void 0) {
+        inputSampleRate = 44100;
+      }
+      if (outputSampleRate === void 0) {
+        outputSampleRate = 44100;
+      }
+      if (quality === void 0) {
+        quality = 1;
+      }
+      return this.algorithms.Resample(signal, inputSampleRate, outputSampleRate, quality);
+    };
+    Essentia2.prototype.ResampleFFT = function(input, inSize, outSize) {
+      if (inSize === void 0) {
+        inSize = 128;
+      }
+      if (outSize === void 0) {
+        outSize = 128;
+      }
+      return this.algorithms.ResampleFFT(input, inSize, outSize);
+    };
+    Essentia2.prototype.RhythmDescriptors = function(signal) {
+      return this.algorithms.RhythmDescriptors(signal);
+    };
+    Essentia2.prototype.RhythmExtractor = function(signal, frameHop, frameSize, hopSize, lastBeatInterval, maxTempo, minTempo, numberFrames, sampleRate, tempoHints, tolerance, useBands, useOnset) {
+      if (frameHop === void 0) {
+        frameHop = 1024;
+      }
+      if (frameSize === void 0) {
+        frameSize = 1024;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (lastBeatInterval === void 0) {
+        lastBeatInterval = 0.1;
+      }
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      if (numberFrames === void 0) {
+        numberFrames = 1024;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tempoHints === void 0) {
+        tempoHints = [];
+      }
+      if (tolerance === void 0) {
+        tolerance = 0.24;
+      }
+      if (useBands === void 0) {
+        useBands = true;
+      }
+      if (useOnset === void 0) {
+        useOnset = true;
+      }
+      var vectempoHints = new this.module.VectorFloat();
+      for (var i = 0; i < vectempoHints.size(); i++) {
+        vectempoHints.push_back(tempoHints[i]);
+      }
+      return this.algorithms.RhythmExtractor(signal, frameHop, frameSize, hopSize, lastBeatInterval, maxTempo, minTempo, numberFrames, sampleRate, vectempoHints, tolerance, useBands, useOnset);
+    };
+    Essentia2.prototype.RhythmExtractor2013 = function(signal, maxTempo, method, minTempo) {
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (method === void 0) {
+        method = "multifeature";
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      return this.algorithms.RhythmExtractor2013(signal, maxTempo, method, minTempo);
+    };
+    Essentia2.prototype.RhythmTransform = function(melBands, frameSize, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 256;
+      }
+      if (hopSize === void 0) {
+        hopSize = 32;
+      }
+      return this.algorithms.RhythmTransform(melBands, frameSize, hopSize);
+    };
+    Essentia2.prototype.RollOff = function(spectrum, cutoff, sampleRate) {
+      if (cutoff === void 0) {
+        cutoff = 0.85;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.RollOff(spectrum, cutoff, sampleRate);
+    };
+    Essentia2.prototype.SNR = function(frame, MAAlpha, MMSEAlpha, NoiseAlpha, frameSize, noiseThreshold, sampleRate, useBroadbadNoiseCorrection) {
+      if (MAAlpha === void 0) {
+        MAAlpha = 0.95;
+      }
+      if (MMSEAlpha === void 0) {
+        MMSEAlpha = 0.98;
+      }
+      if (NoiseAlpha === void 0) {
+        NoiseAlpha = 0.9;
+      }
+      if (frameSize === void 0) {
+        frameSize = 512;
+      }
+      if (noiseThreshold === void 0) {
+        noiseThreshold = -40;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (useBroadbadNoiseCorrection === void 0) {
+        useBroadbadNoiseCorrection = true;
+      }
+      return this.algorithms.SNR(frame, MAAlpha, MMSEAlpha, NoiseAlpha, frameSize, noiseThreshold, sampleRate, useBroadbadNoiseCorrection);
+    };
+    Essentia2.prototype.SaturationDetector = function(frame, differentialThreshold, energyThreshold, frameSize, hopSize, minimumDuration, sampleRate) {
+      if (differentialThreshold === void 0) {
+        differentialThreshold = 1e-3;
+      }
+      if (energyThreshold === void 0) {
+        energyThreshold = -1;
+      }
+      if (frameSize === void 0) {
+        frameSize = 512;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (minimumDuration === void 0) {
+        minimumDuration = 5e-3;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SaturationDetector(frame, differentialThreshold, energyThreshold, frameSize, hopSize, minimumDuration, sampleRate);
+    };
+    Essentia2.prototype.Scale = function(signal, clipping, factor, maxAbsValue) {
+      if (clipping === void 0) {
+        clipping = true;
+      }
+      if (factor === void 0) {
+        factor = 10;
+      }
+      if (maxAbsValue === void 0) {
+        maxAbsValue = 1;
+      }
+      return this.algorithms.Scale(signal, clipping, factor, maxAbsValue);
+    };
+    Essentia2.prototype.SineSubtraction = function(frame, magnitudes, frequencies, phases, fftSize, hopSize, sampleRate) {
+      if (fftSize === void 0) {
+        fftSize = 512;
+      }
+      if (hopSize === void 0) {
+        hopSize = 128;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SineSubtraction(frame, magnitudes, frequencies, phases, fftSize, hopSize, sampleRate);
+    };
+    Essentia2.prototype.SingleBeatLoudness = function(beat, beatDuration, beatWindowDuration, frequencyBands, onsetStart, sampleRate) {
+      if (beatDuration === void 0) {
+        beatDuration = 0.05;
+      }
+      if (beatWindowDuration === void 0) {
+        beatWindowDuration = 0.1;
+      }
+      if (frequencyBands === void 0) {
+        frequencyBands = [0, 200, 400, 800, 1600, 3200, 22e3];
+      }
+      if (onsetStart === void 0) {
+        onsetStart = "sumEnergy";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      var vecfrequencyBands = new this.module.VectorFloat();
+      for (var i = 0; i < vecfrequencyBands.size(); i++) {
+        vecfrequencyBands.push_back(frequencyBands[i]);
+      }
+      return this.algorithms.SingleBeatLoudness(beat, beatDuration, beatWindowDuration, vecfrequencyBands, onsetStart, sampleRate);
+    };
+    Essentia2.prototype.Slicer = function(audio, endTimes, sampleRate, startTimes, timeUnits) {
+      if (endTimes === void 0) {
+        endTimes = [];
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startTimes === void 0) {
+        startTimes = [];
+      }
+      if (timeUnits === void 0) {
+        timeUnits = "seconds";
+      }
+      var vecendTimes = new this.module.VectorFloat();
+      for (var i = 0; i < vecendTimes.size(); i++) {
+        vecendTimes.push_back(endTimes[i]);
+      }
+      var vecstartTimes = new this.module.VectorFloat();
+      for (var i = 0; i < vecstartTimes.size(); i++) {
+        vecstartTimes.push_back(startTimes[i]);
+      }
+      return this.algorithms.Slicer(audio, vecendTimes, sampleRate, vecstartTimes, timeUnits);
+    };
+    Essentia2.prototype.SpectralCentroidTime = function(array, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SpectralCentroidTime(array, sampleRate);
+    };
+    Essentia2.prototype.SpectralComplexity = function(spectrum, magnitudeThreshold, sampleRate) {
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 5e-3;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SpectralComplexity(spectrum, magnitudeThreshold, sampleRate);
+    };
+    Essentia2.prototype.SpectralContrast = function(spectrum, frameSize, highFrequencyBound, lowFrequencyBound, neighbourRatio, numberBands, sampleRate, staticDistribution) {
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 11e3;
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 20;
+      }
+      if (neighbourRatio === void 0) {
+        neighbourRatio = 0.4;
+      }
+      if (numberBands === void 0) {
+        numberBands = 6;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 22050;
+      }
+      if (staticDistribution === void 0) {
+        staticDistribution = 0.15;
+      }
+      return this.algorithms.SpectralContrast(spectrum, frameSize, highFrequencyBound, lowFrequencyBound, neighbourRatio, numberBands, sampleRate, staticDistribution);
+    };
+    Essentia2.prototype.SpectralPeaks = function(spectrum, magnitudeThreshold, maxFrequency, maxPeaks, minFrequency, orderBy, sampleRate) {
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 0;
+      }
+      if (orderBy === void 0) {
+        orderBy = "frequency";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SpectralPeaks(spectrum, magnitudeThreshold, maxFrequency, maxPeaks, minFrequency, orderBy, sampleRate);
+    };
+    Essentia2.prototype.SpectralWhitening = function(spectrum, frequencies, magnitudes, maxFrequency, sampleRate) {
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SpectralWhitening(spectrum, frequencies, magnitudes, maxFrequency, sampleRate);
+    };
+    Essentia2.prototype.Spectrum = function(frame, size) {
+      if (size === void 0) {
+        size = 2048;
+      }
+      return this.algorithms.Spectrum(frame, size);
+    };
+    Essentia2.prototype.SpectrumCQ = function(frame, binsPerOctave, minFrequency, minimumKernelSize, numberBins, sampleRate, scale, threshold, windowType, zeroPhase) {
+      if (binsPerOctave === void 0) {
+        binsPerOctave = 12;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 32.7;
+      }
+      if (minimumKernelSize === void 0) {
+        minimumKernelSize = 4;
+      }
+      if (numberBins === void 0) {
+        numberBins = 84;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (scale === void 0) {
+        scale = 1;
+      }
+      if (threshold === void 0) {
+        threshold = 0.01;
+      }
+      if (windowType === void 0) {
+        windowType = "hann";
+      }
+      if (zeroPhase === void 0) {
+        zeroPhase = true;
+      }
+      return this.algorithms.SpectrumCQ(frame, binsPerOctave, minFrequency, minimumKernelSize, numberBins, sampleRate, scale, threshold, windowType, zeroPhase);
+    };
+    Essentia2.prototype.SpectrumToCent = function(spectrum, bands, centBinResolution, inputSize, log, minimumFrequency, normalize, sampleRate, type) {
+      if (bands === void 0) {
+        bands = 720;
+      }
+      if (centBinResolution === void 0) {
+        centBinResolution = 10;
+      }
+      if (inputSize === void 0) {
+        inputSize = 32768;
+      }
+      if (log === void 0) {
+        log = true;
+      }
+      if (minimumFrequency === void 0) {
+        minimumFrequency = 164;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      return this.algorithms.SpectrumToCent(spectrum, bands, centBinResolution, inputSize, log, minimumFrequency, normalize, sampleRate, type);
+    };
+    Essentia2.prototype.Spline = function(x, beta1, beta2, type, xPoints, yPoints) {
+      if (beta1 === void 0) {
+        beta1 = 1;
+      }
+      if (beta2 === void 0) {
+        beta2 = 0;
+      }
+      if (type === void 0) {
+        type = "b";
+      }
+      if (xPoints === void 0) {
+        xPoints = [0, 1];
+      }
+      if (yPoints === void 0) {
+        yPoints = [0, 1];
+      }
+      var vecxPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecxPoints.size(); i++) {
+        vecxPoints.push_back(xPoints[i]);
+      }
+      var vecyPoints = new this.module.VectorFloat();
+      for (var i = 0; i < vecyPoints.size(); i++) {
+        vecyPoints.push_back(yPoints[i]);
+      }
+      return this.algorithms.Spline(x, beta1, beta2, type, vecxPoints, vecyPoints);
+    };
+    Essentia2.prototype.SprModelAnal = function(frame, fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (freqDevOffset === void 0) {
+        freqDevOffset = 20;
+      }
+      if (freqDevSlope === void 0) {
+        freqDevSlope = 0.01;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (maxnSines === void 0) {
+        maxnSines = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 0;
+      }
+      if (orderBy === void 0) {
+        orderBy = "frequency";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SprModelAnal(frame, fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate);
+    };
+    Essentia2.prototype.SprModelSynth = function(magnitudes, frequencies, phases, res, fftSize, hopSize, sampleRate) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.SprModelSynth(magnitudes, frequencies, phases, res, fftSize, hopSize, sampleRate);
+    };
+    Essentia2.prototype.SpsModelAnal = function(frame, fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (freqDevOffset === void 0) {
+        freqDevOffset = 20;
+      }
+      if (freqDevSlope === void 0) {
+        freqDevSlope = 0.01;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 0;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 5e3;
+      }
+      if (maxPeaks === void 0) {
+        maxPeaks = 100;
+      }
+      if (maxnSines === void 0) {
+        maxnSines = 100;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 0;
+      }
+      if (orderBy === void 0) {
+        orderBy = "frequency";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.SpsModelAnal(frame, fftSize, freqDevOffset, freqDevSlope, hopSize, magnitudeThreshold, maxFrequency, maxPeaks, maxnSines, minFrequency, orderBy, sampleRate, stocf);
+    };
+    Essentia2.prototype.SpsModelSynth = function(magnitudes, frequencies, phases, stocenv, fftSize, hopSize, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.SpsModelSynth(magnitudes, frequencies, phases, stocenv, fftSize, hopSize, sampleRate, stocf);
+    };
+    Essentia2.prototype.StartStopCut = function(audio, frameSize, hopSize, maximumStartTime, maximumStopTime, sampleRate, threshold) {
+      if (frameSize === void 0) {
+        frameSize = 256;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (maximumStartTime === void 0) {
+        maximumStartTime = 10;
+      }
+      if (maximumStopTime === void 0) {
+        maximumStopTime = 10;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (threshold === void 0) {
+        threshold = -60;
+      }
+      return this.algorithms.StartStopCut(audio, frameSize, hopSize, maximumStartTime, maximumStopTime, sampleRate, threshold);
+    };
+    Essentia2.prototype.StartStopSilence = function(frame, threshold) {
+      if (threshold === void 0) {
+        threshold = -60;
+      }
+      return this.algorithms.StartStopSilence(frame, threshold);
+    };
+    Essentia2.prototype.StochasticModelAnal = function(frame, fftSize, hopSize, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.StochasticModelAnal(frame, fftSize, hopSize, sampleRate, stocf);
+    };
+    Essentia2.prototype.StochasticModelSynth = function(stocenv, fftSize, hopSize, sampleRate, stocf) {
+      if (fftSize === void 0) {
+        fftSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (stocf === void 0) {
+        stocf = 0.2;
+      }
+      return this.algorithms.StochasticModelSynth(stocenv, fftSize, hopSize, sampleRate, stocf);
+    };
+    Essentia2.prototype.StrongDecay = function(signal, sampleRate) {
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.StrongDecay(signal, sampleRate);
+    };
+    Essentia2.prototype.StrongPeak = function(spectrum) {
+      return this.algorithms.StrongPeak(spectrum);
+    };
+    Essentia2.prototype.SuperFluxExtractor = function(signal, combine, frameSize, hopSize, ratioThreshold, sampleRate, threshold) {
+      if (combine === void 0) {
+        combine = 20;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (ratioThreshold === void 0) {
+        ratioThreshold = 16;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (threshold === void 0) {
+        threshold = 0.05;
+      }
+      return this.algorithms.SuperFluxExtractor(signal, combine, frameSize, hopSize, ratioThreshold, sampleRate, threshold);
+    };
+    Essentia2.prototype.SuperFluxNovelty = function(bands, binWidth, frameWidth) {
+      if (binWidth === void 0) {
+        binWidth = 3;
+      }
+      if (frameWidth === void 0) {
+        frameWidth = 2;
+      }
+      return this.algorithms.SuperFluxNovelty(bands, binWidth, frameWidth);
+    };
+    Essentia2.prototype.SuperFluxPeaks = function(novelty, combine, frameRate, pre_avg, pre_max, ratioThreshold, threshold) {
+      if (combine === void 0) {
+        combine = 30;
+      }
+      if (frameRate === void 0) {
+        frameRate = 172;
+      }
+      if (pre_avg === void 0) {
+        pre_avg = 100;
+      }
+      if (pre_max === void 0) {
+        pre_max = 30;
+      }
+      if (ratioThreshold === void 0) {
+        ratioThreshold = 16;
+      }
+      if (threshold === void 0) {
+        threshold = 0.05;
+      }
+      return this.algorithms.SuperFluxPeaks(novelty, combine, frameRate, pre_avg, pre_max, ratioThreshold, threshold);
+    };
+    Essentia2.prototype.TCToTotal = function(envelope) {
+      return this.algorithms.TCToTotal(envelope);
+    };
+    Essentia2.prototype.TempoScaleBands = function(bands, bandsGain, frameTime) {
+      if (bandsGain === void 0) {
+        bandsGain = [2, 3, 2, 1, 1.20000004768, 2, 3, 2.5];
+      }
+      if (frameTime === void 0) {
+        frameTime = 512;
+      }
+      var vecbandsGain = new this.module.VectorFloat();
+      for (var i = 0; i < vecbandsGain.size(); i++) {
+        vecbandsGain.push_back(bandsGain[i]);
+      }
+      return this.algorithms.TempoScaleBands(bands, vecbandsGain, frameTime);
+    };
+    Essentia2.prototype.TempoTap = function(featuresFrame, frameHop, frameSize, maxTempo, minTempo, numberFrames, sampleRate, tempoHints) {
+      if (frameHop === void 0) {
+        frameHop = 1024;
+      }
+      if (frameSize === void 0) {
+        frameSize = 256;
+      }
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      if (numberFrames === void 0) {
+        numberFrames = 1024;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (tempoHints === void 0) {
+        tempoHints = [];
+      }
+      var vectempoHints = new this.module.VectorFloat();
+      for (var i = 0; i < vectempoHints.size(); i++) {
+        vectempoHints.push_back(tempoHints[i]);
+      }
+      return this.algorithms.TempoTap(featuresFrame, frameHop, frameSize, maxTempo, minTempo, numberFrames, sampleRate, vectempoHints);
+    };
+    Essentia2.prototype.TempoTapDegara = function(onsetDetections, maxTempo, minTempo, resample, sampleRateODF) {
+      if (maxTempo === void 0) {
+        maxTempo = 208;
+      }
+      if (minTempo === void 0) {
+        minTempo = 40;
+      }
+      if (resample === void 0) {
+        resample = "none";
+      }
+      if (sampleRateODF === void 0) {
+        sampleRateODF = 86.1328;
+      }
+      return this.algorithms.TempoTapDegara(onsetDetections, maxTempo, minTempo, resample, sampleRateODF);
+    };
+    Essentia2.prototype.TempoTapMaxAgreement = function(tickCandidates) {
+      return this.algorithms.TempoTapMaxAgreement(tickCandidates);
+    };
+    Essentia2.prototype.TempoTapTicks = function(periods, phases, frameHop, hopSize, sampleRate) {
+      if (frameHop === void 0) {
+        frameHop = 512;
+      }
+      if (hopSize === void 0) {
+        hopSize = 256;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.TempoTapTicks(periods, phases, frameHop, hopSize, sampleRate);
+    };
+    Essentia2.prototype.TensorflowInputMusiCNN = function(frame) {
+      return this.algorithms.TensorflowInputMusiCNN(frame);
+    };
+    Essentia2.prototype.TensorflowInputVGGish = function(frame) {
+      return this.algorithms.TensorflowInputVGGish(frame);
+    };
+    Essentia2.prototype.TonalExtractor = function(signal, frameSize, hopSize, tuningFrequency) {
+      if (frameSize === void 0) {
+        frameSize = 4096;
+      }
+      if (hopSize === void 0) {
+        hopSize = 2048;
+      }
+      if (tuningFrequency === void 0) {
+        tuningFrequency = 440;
+      }
+      return this.algorithms.TonalExtractor(signal, frameSize, hopSize, tuningFrequency);
+    };
+    Essentia2.prototype.TonicIndianArtMusic = function(signal, binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxTonicFrequency, minTonicFrequency, numberHarmonics, numberSaliencePeaks, referenceFrequency, sampleRate) {
+      if (binResolution === void 0) {
+        binResolution = 10;
+      }
+      if (frameSize === void 0) {
+        frameSize = 2048;
+      }
+      if (harmonicWeight === void 0) {
+        harmonicWeight = 0.85;
+      }
+      if (hopSize === void 0) {
+        hopSize = 512;
+      }
+      if (magnitudeCompression === void 0) {
+        magnitudeCompression = 1;
+      }
+      if (magnitudeThreshold === void 0) {
+        magnitudeThreshold = 40;
+      }
+      if (maxTonicFrequency === void 0) {
+        maxTonicFrequency = 375;
+      }
+      if (minTonicFrequency === void 0) {
+        minTonicFrequency = 100;
+      }
+      if (numberHarmonics === void 0) {
+        numberHarmonics = 20;
+      }
+      if (numberSaliencePeaks === void 0) {
+        numberSaliencePeaks = 5;
+      }
+      if (referenceFrequency === void 0) {
+        referenceFrequency = 55;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.TonicIndianArtMusic(signal, binResolution, frameSize, harmonicWeight, hopSize, magnitudeCompression, magnitudeThreshold, maxTonicFrequency, minTonicFrequency, numberHarmonics, numberSaliencePeaks, referenceFrequency, sampleRate);
+    };
+    Essentia2.prototype.TriangularBands = function(spectrum, frequencyBands, inputSize, log, normalize, sampleRate, type, weighting) {
+      if (frequencyBands === void 0) {
+        frequencyBands = [21.533203125, 43.06640625, 64.599609375, 86.1328125, 107.666015625, 129.19921875, 150.732421875, 172.265625, 193.798828125, 215.33203125, 236.865234375, 258.3984375, 279.931640625, 301.46484375, 322.998046875, 344.53125, 366.064453125, 387.59765625, 409.130859375, 430.6640625, 452.197265625, 473.73046875, 495.263671875, 516.796875, 538.330078125, 559.86328125, 581.396484375, 602.9296875, 624.462890625, 645.99609375, 667.529296875, 689.0625, 710.595703125, 732.12890625, 753.662109375, 775.1953125, 796.728515625, 839.794921875, 861.328125, 882.861328125, 904.39453125, 925.927734375, 968.994140625, 990.52734375, 1012.06054688, 1055.12695312, 1076.66015625, 1098.19335938, 1141.25976562, 1184.32617188, 1205.859375, 1248.92578125, 1270.45898438, 1313.52539062, 1356.59179688, 1399.65820312, 1442.72460938, 1485.79101562, 1528.85742188, 1571.92382812, 1614.99023438, 1658.05664062, 1701.12304688, 1765.72265625, 1808.7890625, 1873.38867188, 1916.45507812, 1981.0546875, 2024.12109375, 2088.72070312, 2153.3203125, 2217.91992188, 2282.51953125, 2347.11914062, 2411.71875, 2497.8515625, 2562.45117188, 2627.05078125, 2713.18359375, 2799.31640625, 2885.44921875, 2950.04882812, 3036.18164062, 3143.84765625, 3229.98046875, 3316.11328125, 3423.77929688, 3509.91210938, 3617.578125, 3725.24414062, 3832.91015625, 3940.57617188, 4069.77539062, 4177.44140625, 4306.640625, 4435.83984375, 4565.0390625, 4694.23828125, 4844.97070312, 4974.16992188, 5124.90234375, 5275.63476562, 5426.3671875, 5577.09960938, 5749.36523438, 5921.63085938, 6093.89648438, 6266.16210938, 6459.9609375, 6653.75976562, 6847.55859375, 7041.35742188, 7256.68945312, 7450.48828125, 7687.35351562, 7902.68554688, 8139.55078125, 8376.41601562, 8613.28125, 8871.6796875, 9130.078125, 9388.4765625, 9668.40820312, 9948.33984375, 10249.8046875, 10551.2695312, 10852.734375, 11175.7324219, 11498.7304688, 11843.2617188, 12187.7929688, 12553.8574219, 12919.921875, 13285.9863281, 13673.5839844, 14082.7148438, 14491.8457031, 14922.5097656, 15353.1738281, 15805.3710938, 16257.5683594];
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (log === void 0) {
+        log = true;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (weighting === void 0) {
+        weighting = "linear";
+      }
+      var vecfrequencyBands = new this.module.VectorFloat();
+      for (var i = 0; i < vecfrequencyBands.size(); i++) {
+        vecfrequencyBands.push_back(frequencyBands[i]);
+      }
+      return this.algorithms.TriangularBands(spectrum, vecfrequencyBands, inputSize, log, normalize, sampleRate, type, weighting);
+    };
+    Essentia2.prototype.TriangularBarkBands = function(spectrum, highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, weighting) {
+      if (highFrequencyBound === void 0) {
+        highFrequencyBound = 22050;
+      }
+      if (inputSize === void 0) {
+        inputSize = 1025;
+      }
+      if (log === void 0) {
+        log = false;
+      }
+      if (lowFrequencyBound === void 0) {
+        lowFrequencyBound = 0;
+      }
+      if (normalize === void 0) {
+        normalize = "unit_sum";
+      }
+      if (numberBands === void 0) {
+        numberBands = 24;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (type === void 0) {
+        type = "power";
+      }
+      if (weighting === void 0) {
+        weighting = "warping";
+      }
+      return this.algorithms.TriangularBarkBands(spectrum, highFrequencyBound, inputSize, log, lowFrequencyBound, normalize, numberBands, sampleRate, type, weighting);
+    };
+    Essentia2.prototype.Trimmer = function(signal, checkRange, endTime, sampleRate, startTime) {
+      if (checkRange === void 0) {
+        checkRange = false;
+      }
+      if (endTime === void 0) {
+        endTime = 1e6;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (startTime === void 0) {
+        startTime = 0;
+      }
+      return this.algorithms.Trimmer(signal, checkRange, endTime, sampleRate, startTime);
+    };
+    Essentia2.prototype.Tristimulus = function(frequencies, magnitudes) {
+      return this.algorithms.Tristimulus(frequencies, magnitudes);
+    };
+    Essentia2.prototype.TruePeakDetector = function(signal, blockDC, emphasise, oversamplingFactor, quality, sampleRate, threshold, version) {
+      if (blockDC === void 0) {
+        blockDC = false;
+      }
+      if (emphasise === void 0) {
+        emphasise = false;
+      }
+      if (oversamplingFactor === void 0) {
+        oversamplingFactor = 4;
+      }
+      if (quality === void 0) {
+        quality = 1;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (threshold === void 0) {
+        threshold = -2e-4;
+      }
+      if (version === void 0) {
+        version = 4;
+      }
+      return this.algorithms.TruePeakDetector(signal, blockDC, emphasise, oversamplingFactor, quality, sampleRate, threshold, version);
+    };
+    Essentia2.prototype.TuningFrequency = function(frequencies, magnitudes, resolution) {
+      if (resolution === void 0) {
+        resolution = 1;
+      }
+      return this.algorithms.TuningFrequency(frequencies, magnitudes, resolution);
+    };
+    Essentia2.prototype.TuningFrequencyExtractor = function(signal, frameSize, hopSize) {
+      if (frameSize === void 0) {
+        frameSize = 4096;
+      }
+      if (hopSize === void 0) {
+        hopSize = 2048;
+      }
+      return this.algorithms.TuningFrequencyExtractor(signal, frameSize, hopSize);
+    };
+    Essentia2.prototype.UnaryOperator = function(array, scale, shift, type) {
+      if (scale === void 0) {
+        scale = 1;
+      }
+      if (shift === void 0) {
+        shift = 0;
+      }
+      if (type === void 0) {
+        type = "identity";
+      }
+      return this.algorithms.UnaryOperator(array, scale, shift, type);
+    };
+    Essentia2.prototype.UnaryOperatorStream = function(array, scale, shift, type) {
+      if (scale === void 0) {
+        scale = 1;
+      }
+      if (shift === void 0) {
+        shift = 0;
+      }
+      if (type === void 0) {
+        type = "identity";
+      }
+      return this.algorithms.UnaryOperatorStream(array, scale, shift, type);
+    };
+    Essentia2.prototype.Variance = function(array) {
+      return this.algorithms.Variance(array);
+    };
+    Essentia2.prototype.Vibrato = function(pitch, maxExtend, maxFrequency, minExtend, minFrequency, sampleRate) {
+      if (maxExtend === void 0) {
+        maxExtend = 250;
+      }
+      if (maxFrequency === void 0) {
+        maxFrequency = 8;
+      }
+      if (minExtend === void 0) {
+        minExtend = 50;
+      }
+      if (minFrequency === void 0) {
+        minFrequency = 4;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 344.531;
+      }
+      return this.algorithms.Vibrato(pitch, maxExtend, maxFrequency, minExtend, minFrequency, sampleRate);
+    };
+    Essentia2.prototype.WarpedAutoCorrelation = function(array, maxLag, sampleRate) {
+      if (maxLag === void 0) {
+        maxLag = 1;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      return this.algorithms.WarpedAutoCorrelation(array, maxLag, sampleRate);
+    };
+    Essentia2.prototype.Welch = function(frame, averagingFrames, fftSize, frameSize, sampleRate, scaling, windowType) {
+      if (averagingFrames === void 0) {
+        averagingFrames = 10;
+      }
+      if (fftSize === void 0) {
+        fftSize = 1024;
+      }
+      if (frameSize === void 0) {
+        frameSize = 512;
+      }
+      if (sampleRate === void 0) {
+        sampleRate = 44100;
+      }
+      if (scaling === void 0) {
+        scaling = "density";
+      }
+      if (windowType === void 0) {
+        windowType = "hann";
+      }
+      return this.algorithms.Welch(frame, averagingFrames, fftSize, frameSize, sampleRate, scaling, windowType);
+    };
+    Essentia2.prototype.Windowing = function(frame, normalized, size, type, zeroPadding, zeroPhase) {
+      if (normalized === void 0) {
+        normalized = true;
+      }
+      if (size === void 0) {
+        size = 1024;
+      }
+      if (type === void 0) {
+        type = "hann";
+      }
+      if (zeroPadding === void 0) {
+        zeroPadding = 0;
+      }
+      if (zeroPhase === void 0) {
+        zeroPhase = true;
+      }
+      return this.algorithms.Windowing(frame, normalized, size, type, zeroPadding, zeroPhase);
+    };
+    Essentia2.prototype.ZeroCrossingRate = function(signal, threshold) {
+      if (threshold === void 0) {
+        threshold = 0;
+      }
+      return this.algorithms.ZeroCrossingRate(signal, threshold);
+    };
+    return Essentia2;
+  }()
+);
+export {
+  Essentia as default
+};
+//# sourceMappingURL=essentia.js-core.es-DnrJE0uR.js.map