{"version":3,"sources":["webpack://Meyda/webpack/universalModuleDefinition","webpack://Meyda/webpack/bootstrap","webpack://Meyda/./node_modules/assert/assert.js","webpack://Meyda/./node_modules/dct/index.js","webpack://Meyda/./node_modules/dct/src/dct.js","webpack://Meyda/./node_modules/fftjs/dist/fft.js","webpack://Meyda/./node_modules/fftjs/dist/utils.js","webpack://Meyda/./node_modules/inherits/inherits_browser.js","webpack://Meyda/./node_modules/process/browser.js","webpack://Meyda/./node_modules/util/support/isBufferBrowser.js","webpack://Meyda/./node_modules/util/util.js","webpack://Meyda/(webpack)/buildin/global.js","webpack://Meyda/./src/extractors/chroma.js","webpack://Meyda/./src/extractors/energy.js","webpack://Meyda/./src/extractors/extractorUtilities.js","webpack://Meyda/./src/extractors/loudness.js","webpack://Meyda/./src/extractors/mfcc.js","webpack://Meyda/./src/extractors/perceptualSharpness.js","webpack://Meyda/./src/extractors/perceptualSpread.js","webpack://Meyda/./src/extractors/powerSpectrum.js","webpack://Meyda/./src/extractors/rms.js","webpack://Meyda/./src/extractors/spectralCentroid.js","webpack://Meyda/./src/extractors/spectralFlatness.js","webpack://Meyda/./src/extractors/spectralFlux.js","webpack://Meyda/./src/extractors/spectralKurtosis.js","webpack://Meyda/./src/extractors/spectralRolloff.js","webpack://Meyda/./src/extractors/spectralSkewness.js","webpack://Meyda/./src/extractors/spectralSlope.js","webpack://Meyda/./src/extractors/spectralSpread.js","webpack://Meyda/./src/extractors/zcr.js","webpack://Meyda/./src/featureExtractors.js","webpack://Meyda/./src/index.js","webpack://Meyda/./src/main.js","webpack://Meyda/./src/meyda-wa.js","webpack://Meyda/./src/utilities.js","webpack://Meyda/./src/windowing.js"],"names":["args","ampSpectrum","TypeError","chromaFilterBank","chromagram","map","row","i","reduce","acc","v","j","maxVal","Math","max","arguments","signal","energy","length","pow","abs","mu","amplitudeSpect","numerator","denominator","k","barkScale","NUM_BARK_BANDS","specific","Float32Array","total","normalisedSpectrum","bbLimits","Int32Array","currentBandEnd","currentBand","sum","dct","melFilterBank","numberOfMFCCCoefficients","min","powSpec","numFilters","filtered","Array","Error","loggedMelBands","bufferSize","log","loggedMelBandsArray","prototype","slice","call","mfccs","loudnessValue","spec","output","exp","spread","powerSpectrum","rms","sqrt","previousSignal","sf","x","ampspec","mu1","mu2","mu3","mu4","nyqBin","sampleRate","ec","threshold","n","ampSum","freqSum","freqs","powFreqSum","ampFreqSum","curFreq","zcr","buffer","complexSpectrum","amplitudeSpectrum","module","exports","default","Meyda","audioContext","spn","melBands","chromaBands","callback","windowingFunction","featureExtractors","EXTRACTION_STARTED","_featuresToExtract","windowing","_errors","notPow2","featureUndef","invalidFeatureFmt","invalidInput","noAC","noSource","createMeydaAnalyzer","options","extract","feature","preparedSignal","prepareSignalWithSpectrum","windowedSignal","previousComplexSpectrum","previousAmpSpectrum","el","Object","assign","real","imag","window","MeydaAnalyzer","_this","_m","errors","source","hopSize","startImmediately","createScriptProcessor","connect","destination","inputData","previousInputData","frame","previousFrame","setSource","onaudioprocess","e","inputBuffer","getChannelData","set","frames","forEach","f","features","windows","isPowerOfTwo","num","error","message","pointwiseBufferMult","a","b","c","applyWindow","windowname","createBarkScale","atan","typedToArray","t","arrayToTyped","from","_normalize","range","normalize","normalizeToOne","apply","mean","prev","cur","_melToFreq","melValue","freqValue","_freqToMel","melToFreq","mV","freqToMel","fV","createMelFilterBank","melValues","melValuesInFreq","lowerLimitFreq","upperLimitFreq","lowerLimitMel","upperLimitMel","valueToAdd","fftBinsOfFreq","floor","filterBank","Number","valueOf","hzToOctaves","freq","A440","log2","normalizeByColumn","emptyRow","colDenominators","cell","createChromaFilterBank","centerOctave","octaveWidth","baseC","numOutputBins","frequencyBins","fill","_","binWidthBins","concat","halfNumFilters","round","filterPeaks","frq","weights","octaveWeights","frameLength","hopLength","numFrames","blackman","size","blackmanBuffer","coeff1","PI","coeff2","cos","sine","coeff","sineBuffer","sin","hanning","hanningBuffer","hamming","hammingBuffer"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;;AClFA,8CAAa;;AAEb;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,WAAW,mBAAO,CAAC,0CAAO;AAC1B;AACA;AACA;AACA,0BAA0B;AAC1B,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,8BAA8B;AAC9B;AACA,mDAAmD;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,gDAAgD;;AAEhD;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH,sBAAsB;;AAEtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA;AACA;AACA,yBAAyB,QAAQ;AACjC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;;AAEA,yBAAyB;AACzB;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,gCAAgC,oBAAoB;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACzeA,iBAAiB,mBAAO,CAAC,mDAAc;;;;;;;;;;;;ACAvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,iBAAiB,OAAO;AACxB,mBAAmB,OAAO;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,6CAA6C,UAAU;;AAEvD;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;;AAEA;;;;;;;;;;;;;ACzCa;;AAEb,YAAY,mBAAO,CAAC,mDAAS;;AAE7B;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,iBAAiB,OAAO;AACxB;AACA;AACA;;AAEA,kBAAkB,QAAQ;AAC1B;AACA;AACA;AACA;AACA,iBAAiB,WAAW;AAC5B;;AAEA;AACA,mBAAmB,eAAe;AAClC;;AAEA;AACA,qBAAqB,eAAe;AACpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA,E;;;;;;;;;;;;AC5Ha;;AAEb;;AAEA,kCAAkC,0BAA0B,0CAA0C,gBAAgB,OAAO,kBAAkB,EAAE,aAAa,EAAE,OAAO,wBAAwB,EAAE;;AAEjM;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,qDAAqD;AACrD,qDAAqD;AACrD;AACA,mBAAmB,OAAO;AAC1B,qCAAqC;;AAErC;AACA;;AAEA,gFAAgF;AAChF,4CAA4C;AAC5C;AACA,mCAAmC;AACnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;;;;;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACtBA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;ACvLtC;AACA;AACA;AACA;AACA;AACA,C;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,sBAAsB;AACzC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,uBAAuB,SAAS;AAChC;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA,GAAG;;AAEH;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4CAA4C,KAAK;;AAEjD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;;AAEA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;AACA,mCAAmC,OAAO;AAC1C;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;;AAGA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,SAAS;AACT;AACA;AACA,WAAW;AACX;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,mBAAmB,mBAAO,CAAC,0EAAoB;;AAE/C;AACA;AACA;;;AAGA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB;AACA,WAAW,SAAS;AACpB;AACA,mBAAmB,mBAAO,CAAC,6DAAU;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;;;ACzkBA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;ACnBe,yEAASA,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAAhC,EAA0C;AACxC,UAAM,IAAIC,SAAJ,CAAc,kDAAd,CAAN;AACD;;AACD,MAAI,QAAOF,IAAI,CAACG,gBAAZ,MAAiC,QAArC,EAA+C;AAC7C,UAAM,IAAID,SAAJ,CAAc,uDAAd,CAAN;AACD;;AAED,MAAIE,UAAU,GAAGJ,IAAI,CAACG,gBAAL,CAAsBE,GAAtB,CAA0B,UAACC,GAAD,EAAMC,CAAN;AAAA,WACzCP,IAAI,CAACC,WAAL,CAAiBO,MAAjB,CAAwB,UAACC,GAAD,EAAMC,CAAN,EAASC,CAAT;AAAA,aAAeF,GAAG,GAAGC,CAAC,GAAGJ,GAAG,CAACK,CAAD,CAA5B;AAAA,KAAxB,EAAyD,CAAzD,CADyC;AAAA,GAA1B,CAAjB;AAGA,MAAIC,MAAM,GAAGC,IAAI,CAACC,GAAL,OAAAD,IAAI,qBAAQT,UAAR,EAAjB;AAGA,SAAOQ,MAAM,GACTR,UAAU,CAACC,GAAX,CAAe,UAAAK,CAAC;AAAA,WAAIA,CAAC,GAAGE,MAAR;AAAA,GAAhB,CADS,GAETR,UAFJ;AAGD,C;;;;;;;;;;;;;;;;;ACjBD;AAEe,2EAAW;AACxB,MAAI,QAAOW,SAAS,CAAC,CAAD,CAAT,CAAaC,MAApB,MAA+B,QAAnC,EAA6C;AAC3C,UAAM,IAAId,SAAJ,EAAN;AACD;;AAED,MAAIe,MAAM,GAAG,CAAb;;AACA,OAAK,IAAIV,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBE,MAAxC,EAAgDX,CAAC,EAAjD,EAAqD;AACnDU,UAAM,IAAIJ,IAAI,CAACM,GAAL,CAASN,IAAI,CAACO,GAAL,CAASL,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBT,CAApB,CAAT,CAAT,EAA2C,CAA3C,CAAV;AACD;;AAED,SAAOU,MAAP;AACD,C;;;;;;;;;;;;ACbD;AAAA;AAAO,SAASI,EAAT,CAAYd,CAAZ,EAAee,cAAf,EAA+B;AACpC,MAAIC,SAAS,GAAG,CAAhB;AACA,MAAIC,WAAW,GAAG,CAAlB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,cAAc,CAACJ,MAAnC,EAA2CO,CAAC,EAA5C,EAAgD;AAC9CF,aAAS,IAAIV,IAAI,CAACM,GAAL,CAASM,CAAT,EAAYlB,CAAZ,IAAiBM,IAAI,CAACO,GAAL,CAASE,cAAc,CAACG,CAAD,CAAvB,CAA9B;AACAD,eAAW,IAAIF,cAAc,CAACG,CAAD,CAA7B;AACD;;AAED,SAAOF,SAAS,GAAGC,WAAnB;AACD,C;;;;;;;;;;;;;;;ACTc,yEAASxB,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAA5B,IACG,QAAOD,IAAI,CAAC0B,SAAZ,MAA0B,QADjC,EAC2C;AACzC,UAAM,IAAIxB,SAAJ,EAAN;AACD;;AAED,MAAIyB,cAAc,GAAG,EAArB;AACA,MAAIC,QAAQ,GAAG,IAAIC,YAAJ,CAAiBF,cAAjB,CAAf;AACA,MAAIG,KAAK,GAAG,CAAZ;AACA,MAAIC,kBAAkB,GAAG/B,IAAI,CAACC,WAA9B;AACA,MAAI+B,QAAQ,GAAG,IAAIC,UAAJ,CAAeN,cAAc,GAAG,CAAhC,CAAf;AAEAK,UAAQ,CAAC,CAAD,CAAR,GAAc,CAAd;AACA,MAAIE,cAAc,GAAGlC,IAAI,CAAC0B,SAAL,CAAeK,kBAAkB,CAACb,MAAnB,GAA4B,CAA3C,IACfS,cADN;AAEA,MAAIQ,WAAW,GAAG,CAAlB;;AACA,OAAK,IAAI5B,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGwB,kBAAkB,CAACb,MAAvC,EAA+CX,CAAC,EAAhD,EAAoD;AAClD,WAAOP,IAAI,CAAC0B,SAAL,CAAenB,CAAf,IAAoB2B,cAA3B,EAA2C;AACzCF,cAAQ,CAACG,WAAW,EAAZ,CAAR,GAA0B5B,CAA1B;AACA2B,oBAAc,GAAGC,WAAW,GAC1BnC,IAAI,CAAC0B,SAAL,CAAeK,kBAAkB,CAACb,MAAnB,GAA4B,CAA3C,CADe,GAEPS,cAFV;AAGD;AACF;;AAEDK,UAAQ,CAACL,cAAD,CAAR,GAA2BI,kBAAkB,CAACb,MAAnB,GAA4B,CAAvD,CAzB4B,CA2B5B;;AAEA,OAAK,IAAIX,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGoB,cAApB,EAAoCpB,EAAC,EAArC,EAAyC;AACvC,QAAI6B,GAAG,GAAG,CAAV;;AACA,SAAK,IAAIzB,CAAC,GAAGqB,QAAQ,CAACzB,EAAD,CAArB,EAA0BI,CAAC,GAAGqB,QAAQ,CAACzB,EAAC,GAAG,CAAL,CAAtC,EAA+CI,CAAC,EAAhD,EAAoD;AAElDyB,SAAG,IAAIL,kBAAkB,CAACpB,CAAD,CAAzB;AACD;;AAEDiB,YAAQ,CAACrB,EAAD,CAAR,GAAcM,IAAI,CAACM,GAAL,CAASiB,GAAT,EAAc,IAAd,CAAd;AACD,GArC2B,CAuC5B;;;AACA,OAAK,IAAI7B,GAAC,GAAG,CAAb,EAAgBA,GAAC,GAAGqB,QAAQ,CAACV,MAA7B,EAAqCX,GAAC,EAAtC,EAA0C;AACxCuB,SAAK,IAAIF,QAAQ,CAACrB,GAAD,CAAjB;AACD;;AAED,SAAO;AACLqB,YAAQ,EAAEA,QADL;AAELE,SAAK,EAAEA;AAFF,GAAP;AAID,C;;;;;;;;;;;;;;;;;AChDD;AACA;AACA;;AAEA,IAAIO,GAAG,GAAG,mBAAO,CAAC,wCAAD,CAAjB;;AAEe,yEAASrC,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAAhC,EAA0C;AACxC,UAAM,IAAIC,SAAJ,CAAc,gDAAd,CAAN;AACD;;AACD,MAAI,QAAOF,IAAI,CAACsC,aAAZ,MAA8B,QAAlC,EAA4C;AAC1C,UAAM,IAAIpC,SAAJ,CAAc,kDAAd,CAAN;AACD;;AAED,MAAIqC,wBAAwB,GAAG1B,IAAI,CAAC2B,GAAL,CAAS,EAAT,EAAa3B,IAAI,CAACC,GAAL,CAAS,CAAT,EAAYd,IAAI,CAACuC,wBAAL,IAAiC,EAA7C,CAAb,CAA/B,CAR4B,CAU5B;AACA;AACA;;AACA,MAAIE,OAAO,GAAG,8DAAa,CAACzC,IAAD,CAA3B;AACA,MAAI0C,UAAU,GAAG1C,IAAI,CAACsC,aAAL,CAAmBpB,MAApC;AACA,MAAIyB,QAAQ,GAAGC,KAAK,CAACF,UAAD,CAApB;;AAEA,MAAIA,UAAU,GAAGH,wBAAjB,EAA2C;AACzC,UAAM,IAAIM,KAAJ,CAAU,+DAAV,CAAN;AACD;;AAED,MAAIC,cAAc,GAAG,IAAIjB,YAAJ,CAAiBa,UAAjB,CAArB;;AAEA,OAAK,IAAInC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGuC,cAAc,CAAC5B,MAAnC,EAA2CX,CAAC,EAA5C,EAAgD;AAC9CoC,YAAQ,CAACpC,CAAD,CAAR,GAAc,IAAIsB,YAAJ,CAAiB7B,IAAI,CAAC+C,UAAL,GAAkB,CAAnC,CAAd;AACAD,kBAAc,CAACvC,CAAD,CAAd,GAAoB,CAApB;;AACA,SAAK,IAAII,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAIX,IAAI,CAAC+C,UAAL,GAAkB,CAAvC,EAA2CpC,CAAC,EAA5C,EAAgD;AAC9C;AACAgC,cAAQ,CAACpC,CAAD,CAAR,CAAYI,CAAZ,IAAiBX,IAAI,CAACsC,aAAL,CAAmB/B,CAAnB,EAAsBI,CAAtB,IAA2B8B,OAAO,CAAC9B,CAAD,CAAnD,CAF8C,CAI9C;;AACAmC,oBAAc,CAACvC,CAAD,CAAd,IAAqBoC,QAAQ,CAACpC,CAAD,CAAR,CAAYI,CAAZ,CAArB;AACD,KAT6C,CAW9C;;;AACAmC,kBAAc,CAACvC,CAAD,CAAd,GAAoBM,IAAI,CAACmC,GAAL,CAASF,cAAc,CAACvC,CAAD,CAAd,GAAoB,CAA7B,CAApB;AACD,GApC2B,CAsC5B;;;AACA,MAAI0C,mBAAmB,GAAGL,KAAK,CAACM,SAAN,CAAgBC,KAAhB,CAAsBC,IAAtB,CAA2BN,cAA3B,CAA1B;AACA,MAAIO,KAAK,GAAGhB,GAAG,CAACY,mBAAD,CAAH,CAAyBE,KAAzB,CAA+B,CAA/B,EAAkCZ,wBAAlC,CAAZ;AAEA,SAAOc,KAAP;AACD,C;;;;;;;;;;;;;;;;ACjDD;AAEe,2EAAW;AACxB,MAAI,QAAOtC,SAAS,CAAC,CAAD,CAAT,CAAaC,MAApB,MAA+B,QAAnC,EAA6C;AAC3C,UAAM,IAAId,SAAJ,EAAN;AACD;;AAED,MAAIoD,aAAa,GAAG,yDAAQ,CAACvC,SAAS,CAAC,CAAD,CAAV,CAA5B;AACA,MAAIwC,IAAI,GAAGD,aAAa,CAAC1B,QAAzB;AACA,MAAI4B,MAAM,GAAG,CAAb;;AAEA,OAAK,IAAIjD,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGgD,IAAI,CAACrC,MAAzB,EAAiCX,CAAC,EAAlC,EAAsC;AACpC,QAAIA,CAAC,GAAG,EAAR,EAAY;AACViD,YAAM,IAAI,CAACjD,CAAC,GAAG,CAAL,IAAUgD,IAAI,CAAChD,CAAC,GAAG,CAAL,CAAxB;AACD,KAFD,MAEO;AACLiD,YAAM,IAAI,QAAQ3C,IAAI,CAAC4C,GAAL,CAAS,SAASlD,CAAC,GAAG,CAAb,CAAT,CAAlB;AACD;AACF;;AAEDiD,QAAM,IAAI,OAAOF,aAAa,CAACxB,KAA/B;AAEA,SAAO0B,MAAP;AACD,C;;;;;;;;;;;;;;;;ACtBD;AAEe,2EAAW;AACxB,MAAI,QAAOzC,SAAS,CAAC,CAAD,CAAT,CAAaC,MAApB,MAA+B,QAAnC,EAA6C;AAC3C,UAAM,IAAId,SAAJ,EAAN;AACD;;AAED,MAAIoD,aAAa,GAAG,yDAAQ,CAACvC,SAAS,CAAC,CAAD,CAAV,CAA5B;AAEA,MAAID,GAAG,GAAG,CAAV;;AACA,OAAK,IAAIP,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG+C,aAAa,CAAC1B,QAAd,CAAuBV,MAA3C,EAAmDX,CAAC,EAApD,EAAwD;AACtD,QAAI+C,aAAa,CAAC1B,QAAd,CAAuBrB,CAAvB,IAA4BO,GAAhC,EAAqC;AACnCA,SAAG,GAAGwC,aAAa,CAAC1B,QAAd,CAAuBrB,CAAvB,CAAN;AACD;AACF;;AAED,MAAImD,MAAM,GAAG7C,IAAI,CAACM,GAAL,CAAS,CAACmC,aAAa,CAACxB,KAAd,GAAsBhB,GAAvB,IAA8BwC,aAAa,CAACxB,KAArD,EAA4D,CAA5D,CAAb;AAEA,SAAO4B,MAAP;AACD,C;;;;;;;;;;;;;;;ACnBc,2EAAW;AACxB,MAAI,QAAO3C,SAAS,CAAC,CAAD,CAAT,CAAad,WAApB,MAAoC,QAAxC,EAAkD;AAChD,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,MAAIyD,aAAa,GAAG,IAAI9B,YAAJ,CAAiBd,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBiB,MAA1C,CAApB;;AACA,OAAK,IAAIX,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoD,aAAa,CAACzC,MAAlC,EAA0CX,CAAC,EAA3C,EAA+C;AAC7CoD,iBAAa,CAACpD,CAAD,CAAb,GAAoBM,IAAI,CAACM,GAAL,CAASJ,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBM,CAAzB,CAAT,EAAsC,CAAtC,CAApB;AACD;;AAED,SAAOoD,aAAP;AACD,C;;;;;;;;;;;;;;;ACXc,yEAAS3D,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACgB,MAAZ,MAAuB,QAA3B,EAAqC;AACnC,UAAM,IAAId,SAAJ,EAAN;AACD;;AAED,MAAI0D,GAAG,GAAG,CAAV;;AACA,OAAK,IAAIrD,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,IAAI,CAACgB,MAAL,CAAYE,MAAhC,EAAwCX,CAAC,EAAzC,EAA6C;AAC3CqD,OAAG,IAAI/C,IAAI,CAACM,GAAL,CAASnB,IAAI,CAACgB,MAAL,CAAYT,CAAZ,CAAT,EAAyB,CAAzB,CAAP;AACD;;AAEDqD,KAAG,GAAGA,GAAG,GAAG5D,IAAI,CAACgB,MAAL,CAAYE,MAAxB;AACA0C,KAAG,GAAG/C,IAAI,CAACgD,IAAL,CAAUD,GAAV,CAAN;AAEA,SAAOA,GAAP;AACD,C;;;;;;;;;;;;;;;;ACdD;AAEe,2EAAW;AACxB,MAAI,QAAO7C,SAAS,CAAC,CAAD,CAAT,CAAad,WAApB,MAAoC,QAAxC,EAAkD;AAChD,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,SAAO,8DAAE,CAAC,CAAD,EAAIa,SAAS,CAAC,CAAD,CAAT,CAAad,WAAjB,CAAT;AACD,C;;;;;;;;;;;;;;;ACRc,2EAAW;AACxB,MAAI,QAAOc,SAAS,CAAC,CAAD,CAAT,CAAad,WAApB,MAAoC,QAAxC,EAAkD;AAChD,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,MAAIqB,SAAS,GAAG,CAAhB;AACA,MAAIC,WAAW,GAAG,CAAlB;;AACA,OAAK,IAAIjB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGQ,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBiB,MAA7C,EAAqDX,CAAC,EAAtD,EAA0D;AACxDgB,aAAS,IAAIV,IAAI,CAACmC,GAAL,CAASjC,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBM,CAAzB,CAAT,CAAb;AACAiB,eAAW,IAAIT,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBM,CAAzB,CAAf;AACD;;AAED,SAAOM,IAAI,CAAC4C,GAAL,CAASlC,SAAS,GAAGR,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBiB,MAA9C,IACHH,SAAS,CAAC,CAAD,CAAT,CAAad,WAAb,CAAyBiB,MADtB,GAC+BM,WADtC;AAED,C;;;;;;;;;;;;;;;ACdc,yEAASxB,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACgB,MAAZ,MAAuB,QAAvB,IACJ,QAAOhB,IAAI,CAAC8D,cAAZ,KAA8B,QAD9B,EAEE;AACA,UAAM,IAAI5D,SAAJ,EAAN;AACD;;AAED,MAAI6D,EAAE,GAAG,CAAT;;AACA,OAAK,IAAIxD,CAAC,GAAG,EAAEP,IAAI,CAAC+C,UAAL,GAAkB,CAApB,CAAb,EAAqCxC,CAAC,GAAGS,MAAM,CAACE,MAAP,GAAgB,CAAhB,GAAoB,CAA7D,EAAgEX,CAAC,EAAjE,EAAqE;AACnEyD,KAAC,GAAGnD,IAAI,CAACO,GAAL,CAASpB,IAAI,CAACgB,MAAL,CAAYT,CAAZ,CAAT,IAA2BM,IAAI,CAACO,GAAL,CAASpB,IAAI,CAAC8D,cAAL,CAAoBvD,CAApB,CAAT,CAA/B;AACAwD,MAAE,IAAI,CAACC,CAAC,GAAGnD,IAAI,CAACO,GAAL,CAAS4C,CAAT,CAAL,IAAoB,CAA1B;AACD;;AAED,SAAOD,EAAP;AACD,C;;;;;;;;;;;;;;;;ACdD;AAEe,2EAAW;AACxB,MAAI,QAAOhD,SAAS,CAAC,CAAD,CAAT,CAAad,WAApB,MAAoC,QAAxC,EAAkD;AAChD,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,MAAI+D,OAAO,GAAGlD,SAAS,CAAC,CAAD,CAAT,CAAad,WAA3B;AACA,MAAIiE,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAID,OAAJ,CAAZ;AACA,MAAIE,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAIF,OAAJ,CAAZ;AACA,MAAIG,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAIH,OAAJ,CAAZ;AACA,MAAII,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAIJ,OAAJ,CAAZ;AACA,MAAI1C,SAAS,GAAG,CAAC,CAAD,GAAKV,IAAI,CAACM,GAAL,CAAS+C,GAAT,EAAc,CAAd,CAAL,GAAwB,IAAIA,GAAJ,GAAUC,GAAlC,GAAwC,IAAID,GAAJ,GAAUE,GAAlD,GAAwDC,GAAxE;AACA,MAAI7C,WAAW,GAAGX,IAAI,CAACM,GAAL,CAASN,IAAI,CAACgD,IAAL,CAAUM,GAAG,GAAGtD,IAAI,CAACM,GAAL,CAAS+C,GAAT,EAAc,CAAd,CAAhB,CAAT,EAA4C,CAA5C,CAAlB;AACA,SAAO3C,SAAS,GAAGC,WAAnB;AACD,C;;;;;;;;;;;;;;;ACfc,2EAAW;AACxB,MAAI,QAAOT,SAAS,CAAC,CAAD,CAAT,CAAad,WAApB,MAAoC,QAAxC,EAAkD;AAChD,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,MAAI+D,OAAO,GAAGlD,SAAS,CAAC,CAAD,CAAT,CAAad,WAA3B,CALwB,CAOxB;;AACA,MAAIqE,MAAM,GAAGvD,SAAS,CAAC,CAAD,CAAT,CAAawD,UAAb,IAA2B,KAAKN,OAAO,CAAC/C,MAAR,GAAiB,CAAtB,CAA3B,CAAb;AACA,MAAIsD,EAAE,GAAG,CAAT;;AACA,OAAK,IAAIjE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG0D,OAAO,CAAC/C,MAA5B,EAAoCX,CAAC,EAArC,EAAyC;AACvCiE,MAAE,IAAIP,OAAO,CAAC1D,CAAD,CAAb;AACD;;AAED,MAAIkE,SAAS,GAAG,OAAOD,EAAvB;AACA,MAAIE,CAAC,GAAGT,OAAO,CAAC/C,MAAR,GAAiB,CAAzB;;AACA,SAAOsD,EAAE,GAAGC,SAAL,IAAkBC,CAAC,IAAI,CAA9B,EAAiC;AAC/BF,MAAE,IAAIP,OAAO,CAACS,CAAD,CAAb;AACA,MAAEA,CAAF;AACD;;AAED,SAAO,CAACA,CAAC,GAAG,CAAL,IAAUJ,MAAjB;AACD,C;;;;;;;;;;;;;;;;ACtBD;AAEe,yEAAStE,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAAhC,EAA0C;AACxC,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,MAAIgE,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAIlE,IAAI,CAACC,WAAT,CAAZ;AACA,MAAIkE,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAInE,IAAI,CAACC,WAAT,CAAZ;AACA,MAAImE,GAAG,GAAG,8DAAE,CAAC,CAAD,EAAIpE,IAAI,CAACC,WAAT,CAAZ;AACA,MAAIsB,SAAS,GAAG,IAAIV,IAAI,CAACM,GAAL,CAAS+C,GAAT,EAAc,CAAd,CAAJ,GAAuB,IAAIA,GAAJ,GAAUC,GAAjC,GAAuCC,GAAvD;AACA,MAAI5C,WAAW,GAAGX,IAAI,CAACM,GAAL,CAASN,IAAI,CAACgD,IAAL,CAAUM,GAAG,GAAGtD,IAAI,CAACM,GAAL,CAAS+C,GAAT,EAAc,CAAd,CAAhB,CAAT,EAA4C,CAA5C,CAAlB;AACA,SAAO3C,SAAS,GAAGC,WAAnB;AACD,C;;;;;;;;;;;;;;;ACbc,yEAASxB,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAAhC,EAA0C;AACxC,UAAM,IAAIC,SAAJ,EAAN;AACD,GAH2B,CAK5B;;;AACA,MAAIyE,MAAM,GAAG,CAAb;AACA,MAAIC,OAAO,GAAG,CAAd;AACA,MAAIC,KAAK,GAAG,IAAIhD,YAAJ,CAAiB7B,IAAI,CAACC,WAAL,CAAiBiB,MAAlC,CAAZ;AACA,MAAI4D,UAAU,GAAG,CAAjB;AACA,MAAIC,UAAU,GAAG,CAAjB;;AAEA,OAAK,IAAIxE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,IAAI,CAACC,WAAL,CAAiBiB,MAArC,EAA6CX,CAAC,EAA9C,EAAkD;AAChDoE,UAAM,IAAI3E,IAAI,CAACC,WAAL,CAAiBM,CAAjB,CAAV;AACA,QAAIyE,OAAO,GAAGzE,CAAC,GAAGP,IAAI,CAACuE,UAAT,GAAsBvE,IAAI,CAAC+C,UAAzC;AACA8B,SAAK,CAACtE,CAAD,CAAL,GAAWyE,OAAX;AACAF,cAAU,IAAIE,OAAO,GAAGA,OAAxB;AACAJ,WAAO,IAAII,OAAX;AACAD,cAAU,IAAIC,OAAO,GAAGhF,IAAI,CAACC,WAAL,CAAiBM,CAAjB,CAAxB;AACD;;AAED,SAAO,CAACP,IAAI,CAACC,WAAL,CAAiBiB,MAAjB,GAA0B6D,UAA1B,GAAuCH,OAAO,GAAGD,MAAlD,KAA6DA,MAAM,IACpEG,UAAU,GAAGjE,IAAI,CAACM,GAAL,CAASyD,OAAT,EAAkB,CAAlB,CADuD,CAAnE,CAAP;AAED,C;;;;;;;;;;;;;;;;ACvBD;AAEe,yEAAS5E,IAAT,EAAe;AAC5B,MAAI,QAAOA,IAAI,CAACC,WAAZ,MAA4B,QAAhC,EAA0C;AACxC,UAAM,IAAIC,SAAJ,EAAN;AACD;;AAED,SAAOW,IAAI,CAACgD,IAAL,CAAU,8DAAE,CAAC,CAAD,EAAI7D,IAAI,CAACC,WAAT,CAAF,GACVY,IAAI,CAACM,GAAL,CAAS,8DAAE,CAAC,CAAD,EAAInB,IAAI,CAACC,WAAT,CAAX,EAAkC,CAAlC,CADA,CAAP;AAED,C;;;;;;;;;;;;;;;ACTc,2EAAW;AACxB,MAAI,QAAOc,SAAS,CAAC,CAAD,CAAT,CAAaC,MAApB,MAA+B,QAAnC,EAA6C;AAC3C,UAAM,IAAId,SAAJ,EAAN;AACD;;AAED,MAAI+E,GAAG,GAAG,CAAV;;AACA,OAAK,IAAI1E,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBE,MAAxC,EAAgDX,CAAC,EAAjD,EAAqD;AACnD,QAAKQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBT,CAApB,KAA0B,CAA1B,IAA+BQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBT,CAAC,GAAG,CAAxB,IAA6B,CAA7D,IACEQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBT,CAApB,IAAyB,CAAzB,IAA8BQ,SAAS,CAAC,CAAD,CAAT,CAAaC,MAAb,CAAoBT,CAAC,GAAG,CAAxB,KAA8B,CADlE,EACsE;AACpE0E,SAAG;AACJ;AACF;;AAED,SAAOA,GAAP;AACD,C;;;;;;;;;;;;ACdD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAIC,MAAM,GAAG,SAATA,MAAS,CAASlF,IAAT,EAAe;AAC1B,SAAOA,IAAI,CAACgB,MAAZ;AACD,CAFD;;AAIA,IAAImE,eAAe,GAAG,SAAlBA,eAAkB,CAAUnF,IAAV,EAAgB;AACpC,SAAOA,IAAI,CAACmF,eAAZ;AACD,CAFD;;AAIA,IAAIC,iBAAiB,GAAG,SAApBA,iBAAoB,CAAUpF,IAAV,EAAgB;AACtC,SAAOA,IAAI,CAACC,WAAZ;AACD,CAFD;;;;;;;;;;;;;AC1BAoF,MAAM,CAACC,OAAP,GAAiB,mBAAO,CAAC,6BAAD,CAAP,CAAkBC,OAAnC,C;;;;;;;;;;;;;;;;;;;;;;ACAA;AACA;AACA;AACA;AAEA;;;;;AAKA;;;;;;;;;;;;;;AAcC;;;;;;;AAOD;;;;;;AAMA;;;;;;AAMA;;;;;;;;;AAQA,IAAIC,KAAK,GAAG;AACV;;;;;;AAMAC,cAAY,EAAE,IAPJ;;AAQV;;;;;;AAMAC,KAAG,EAAE,IAdK;;AAeV;;;;;;;;;;;;;AAaA3C,YAAU,EAAE,GA5BF;;AA6BV;;;;;;;AAOAwB,YAAU,EAAE,KApCF;;AAqCV;;;;;;AAMAoB,UAAQ,EAAE,EA3CA;;AA4CV;;;;;;;;AAQAC,aAAW,EAAE,EApDH;;AAqDV;;;;;;AAMAC,UAAQ,EAAE,IA3DA;;AA4DV;;;;;;AAMAC,mBAAiB,EAAE,SAlET;;AAmEV;;;AAGAC,mBAAiB,EAAE,+CAtET;AAuEVC,oBAAkB,EAAE,KAvEV;AAwEVzD,0BAAwB,EAAE,EAxEhB;AAyEV0D,oBAAkB,EAAE,EAzEV;AA0EVC,WAAS,EAAE,sDA1ED;AA2EVC,SAAO,EAAE;AACPC,WAAO,EAAE,IAAIvD,KAAJ,CACL,yDADK,CADF;AAGPwD,gBAAY,EAAE,IAAIxD,KAAJ,CAAU,6BAAV,CAHP;AAIPyD,qBAAiB,EAAE,IAAIzD,KAAJ,CAAU,+BAAV,CAJZ;AAKP0D,gBAAY,EAAE,IAAI1D,KAAJ,CAAU,uBAAV,CALP;AAMP2D,QAAI,EAAE,IAAI3D,KAAJ,CAAU,mCAAV,CANC;AAOP4D,YAAQ,EAAE,IAAI5D,KAAJ,CAAU,kCAAV;AAPH,GA3EC;;AAqFV;;;;;;;;;;;;;;;;;;;;;;AAsBA6D,qBAAmB,EAAE,6BAAUC,OAAV,EAAmB;AACtC,WAAO,IAAI,uDAAJ,CAAkBA,OAAlB,EAA2BnB,KAA3B,CAAP;AACD,GA7GS;;AA+GV;;;;;;;;;;;;;AAaAoB,SAAO,EAAE,iBAAUC,OAAV,EAAmB7F,MAAnB,EAA2B8C,cAA3B,EAA2C;AAAA;;AAClD,QAAI,CAAC9C,MAAL,EACI,MAAM,KAAKmF,OAAL,CAAaI,YAAnB,CADJ,KAEK,IAAI,QAAOvF,MAAP,KAAiB,QAArB,EACD,MAAM,KAAKmF,OAAL,CAAaI,YAAnB,CADC,KAEA,IAAI,CAACM,OAAL,EACD,MAAM,KAAKV,OAAL,CAAaE,YAAnB,CADC,KAEA,IAAI,CAAC,wDAAuBrF,MAAM,CAACE,MAA9B,CAAL,EACD,MAAM,KAAKiF,OAAL,CAAaC,OAAnB;;AAEJ,QAAI,OAAO,KAAK1E,SAAZ,IAAyB,WAAzB,IACI,KAAKA,SAAL,CAAeR,MAAf,IAAyB,KAAK6B,UADtC,EACkD;AAChD,WAAKrB,SAAL,GAAiB,2DACb,KAAKqB,UADQ,EAEb,KAAKwB,UAFQ,EAGb,KAAKxB,UAHQ,CAAjB;AAKD,KAjBiD,CAmBlD;;;AACA,QAAI,OAAO,KAAKT,aAAZ,IAA6B,WAA7B,IACI,KAAKZ,SAAL,CAAeR,MAAf,IAAyB,KAAK6B,UADlC,IAEI,KAAKT,aAAL,CAAmBpB,MAAnB,IAA6B,KAAKyE,QAF1C,EAEoD;AAClD,WAAKrD,aAAL,GAAqB,+DACjBzB,IAAI,CAACC,GAAL,CAAS,KAAK6E,QAAd,EAAwB,KAAKpD,wBAA7B,CADiB,EAEjB,KAAKgC,UAFY,EAGjB,KAAKxB,UAHY,CAArB;AAID,KA3BiD,CA6BlD;;;AACA,QAAI,OAAO,KAAK5C,gBAAZ,IAAgC,WAAhC,IACI,KAAKA,gBAAL,CAAsBe,MAAtB,IAAgC,KAAK0E,WAD7C,EAC0D;AACxD,WAAKzF,gBAAL,GAAwB,kEACpB,KAAKyF,WADe,EAEpB,KAAKrB,UAFe,EAGpB,KAAKxB,UAHe,CAAxB;AAID;;AAED,QAAI,OAAO/B,MAAM,CAACkE,MAAd,IAAwB,WAA5B,EAAyC;AACvC;AACA,WAAKlE,MAAL,GAAc,wDAAuBA,MAAvB,CAAd;AACD,KAHD,MAGO;AACL,WAAKA,MAAL,GAAcA,MAAd;AACD;;AAED,QAAI8F,cAAc,GAAGC,yBAAyB,CACtC/F,MADsC,EAEtC,KAAK8E,iBAFiC,EAGtC,KAAK/C,UAHiC,CAA9C;AAKA,SAAK/B,MAAL,GAAc8F,cAAc,CAACE,cAA7B;AACA,SAAK7B,eAAL,GAAuB2B,cAAc,CAAC3B,eAAtC;AACA,SAAKlF,WAAL,GAAmB6G,cAAc,CAAC7G,WAAlC;;AAEA,QAAI6D,cAAJ,EAAoB;AAClB,UAAIgD,eAAc,GAAGC,yBAAyB,CAACjD,cAAD,EACtC,KAAKgC,iBADiC,EAEtC,KAAK/C,UAFiC,CAA9C;;AAIA,WAAKe,cAAL,GAAsBgD,eAAc,CAACE,cAArC;AACA,WAAKC,uBAAL,GAA+BH,eAAc,CAAC3B,eAA9C;AACA,WAAK+B,mBAAL,GAA2BJ,eAAc,CAAC7G,WAA1C;AACD;;AAED,QAAM2G,OAAO,GAAG,SAAVA,OAAU,CAACC,OAAD,EAAa;AAC3B,aAAO,KAAI,CAACd,iBAAL,CAAuBc,OAAvB,EAAgC;AACrC5G,mBAAW,EAAC,KAAI,CAACA,WADoB;AAErCE,wBAAgB,EAAE,KAAI,CAACA,gBAFc;AAGrCgF,uBAAe,EAAC,KAAI,CAACA,eAHgB;AAIrCnE,cAAM,EAAC,KAAI,CAACA,MAJyB;AAKrC+B,kBAAU,EAAC,KAAI,CAACA,UALqB;AAMrCwB,kBAAU,EAAC,KAAI,CAACA,UANqB;AAOrC7C,iBAAS,EAAC,KAAI,CAACA,SAPsB;AAQrCY,qBAAa,EAAC,KAAI,CAACA,aARkB;AASrCwB,sBAAc,EAAC,KAAI,CAACA,cATiB;AAUrCoD,2BAAmB,EAAC,KAAI,CAACA,mBAVY;AAWrCD,+BAAuB,EAAC,KAAI,CAACA,uBAXQ;AAYrC1E,gCAAwB,EAAC,KAAI,CAACA;AAZO,OAAhC,CAAP;AAcD,KAfD;;AAiBA,QAAI,QAAOsE,OAAP,MAAmB,QAAvB,EAAiC;AAC/B,aAAOA,OAAO,CAACrG,MAAR,CAAe,UAACC,GAAD,EAAM0G,EAAN;AAAA,eACpBC,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkB5G,GAAlB,sBACG0G,EADH,EACQP,OAAO,CAACO,EAAD,CADf,EADoB;AAAA,OAAf,EAGD,EAHC,CAAP;AAID,KALD,MAKO,IAAI,OAAON,OAAP,KAAmB,QAAvB,EAAiC;AACtC,aAAOD,OAAO,CAACC,OAAD,CAAd;AACD,KAFM,MAEA;AACL,YAAM,KAAKV,OAAL,CAAaG,iBAAnB;AACD;AACF;AAvNS,CAAZ;;AA0NA,IAAIS,yBAAyB,GAAG,SAA5BA,yBAA4B,CAAU/F,MAAV,EAC9B8E,iBAD8B,EAE9B/C,UAF8B,EAElB;AACZ,MAAI+D,cAAc,GAAG,EAArB;;AAEA,MAAI,OAAO9F,MAAM,CAACkE,MAAd,IAAwB,WAA5B,EAAyC;AACvC;AACA4B,kBAAc,CAAC9F,MAAf,GAAwB,wDAAuBA,MAAvB,CAAxB;AACD,GAHD,MAGQ;AACN8F,kBAAc,CAAC9F,MAAf,GAAwBA,MAAxB;AACD;;AAED8F,gBAAc,CAACE,cAAf,GAAgC,uDAC9BF,cAAc,CAAC9F,MADe,EAE9B8E,iBAF8B,CAAhC;AAIAgB,gBAAc,CAAC3B,eAAf,GAAiC,iDAAG,CAAC2B,cAAc,CAACE,cAAhB,CAApC;AACAF,gBAAc,CAAC7G,WAAf,GAA6B,IAAI4B,YAAJ,CAAiBkB,UAAU,GAAG,CAA9B,CAA7B;;AACA,OAAK,IAAIxC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGwC,UAAU,GAAG,CAAjC,EAAoCxC,CAAC,EAArC,EAAyC;AACvCuG,kBAAc,CAAC7G,WAAf,CAA2BM,CAA3B,IAAgCM,IAAI,CAACgD,IAAL,CAC9BhD,IAAI,CAACM,GAAL,CAAS2F,cAAc,CAAC3B,eAAf,CAA+BmC,IAA/B,CAAoC/G,CAApC,CAAT,EAAiD,CAAjD,IACAM,IAAI,CAACM,GAAL,CAAS2F,cAAc,CAAC3B,eAAf,CAA+BoC,IAA/B,CAAoChH,CAApC,CAAT,EAAiD,CAAjD,CAF8B,CAAhC;AAGD;;AAED,SAAOuG,cAAP;AACD,CAzBD;AA2BA;;;;;;AAIe,+DAAAtB,KAAf;AAEA,IAAI,OAAOgC,MAAP,KAAkB,WAAtB,EAAmCA,MAAM,CAAChC,KAAP,GAAeA,KAAf,C;;;;;;;;;;;;;;;;;;;;;;AC9SnC;AACA;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAwBO,IAAMiC,aAAb;AAAA;AAAA;AACE,yBAAYd,OAAZ,EAAqBe,KAArB,EAA4B;AAAA;;AAAA;;AAC1B,SAAKC,EAAL,GAAUD,KAAV;;AACA,QAAI,CAACf,OAAO,CAAClB,YAAb,EAA2B;AACzB,YAAM,KAAKkC,EAAL,CAAQC,MAAR,CAAepB,IAArB;AACD,KAFD,MAGK,IAAIG,OAAO,CAAC5D,UAAR,IACP,CAAC,wDAAuB4D,OAAO,CAAC5D,UAA/B,CADE,EAC0C;AAC7C,YAAM,KAAK4E,EAAL,CAAQxB,OAAR,CAAgBC,OAAtB;AACD,KAHI,MAIA,IAAI,CAACO,OAAO,CAACkB,MAAb,EAAqB;AACxB,YAAM,KAAKF,EAAL,CAAQxB,OAAR,CAAgBM,QAAtB;AACD;;AAED,SAAKkB,EAAL,CAAQlC,YAAR,GAAuBkB,OAAO,CAAClB,YAA/B,CAb0B,CAe1B;;AACA,SAAKkC,EAAL,CAAQ5E,UAAR,GAAqB4D,OAAO,CAAC5D,UAAR,IAAsB,KAAK4E,EAAL,CAAQ5E,UAA9B,IAA4C,GAAjE;AACA,SAAK4E,EAAL,CAAQG,OAAR,GAAkBnB,OAAO,CAACmB,OAAR,IAAmB,KAAKH,EAAL,CAAQG,OAA3B,IAAsC,KAAKH,EAAL,CAAQ5E,UAAhE;AACA,SAAK4E,EAAL,CAAQpD,UAAR,GAAqBoC,OAAO,CAACpC,UAAR,IAChB,KAAKoD,EAAL,CAAQlC,YAAR,CAAqBlB,UADL,IACmB,KADxC;AAEA,SAAKoD,EAAL,CAAQ9B,QAAR,GAAmBc,OAAO,CAACd,QAA3B;AACA,SAAK8B,EAAL,CAAQ7B,iBAAR,GAA4Ba,OAAO,CAACb,iBAAR,IAA6B,SAAzD;AACA,SAAK6B,EAAL,CAAQ5B,iBAAR,GAA4B,+CAA5B;AACA,SAAK4B,EAAL,CAAQ3B,kBAAR,GAA6BW,OAAO,CAACoB,gBAAR,IAA4B,KAAzD,CAvB0B,CAyB1B;;AACA,SAAKJ,EAAL,CAAQjC,GAAR,GAAc,KAAKiC,EAAL,CAAQlC,YAAR,CAAqBuC,qBAArB,CACZ,KAAKL,EAAL,CAAQ5E,UADI,EACQ,CADR,EACW,CADX,CAAd;;AAEA,SAAK4E,EAAL,CAAQjC,GAAR,CAAYuC,OAAZ,CAAoB,KAAKN,EAAL,CAAQlC,YAAR,CAAqByC,WAAzC;;AAEA,SAAKP,EAAL,CAAQ1B,kBAAR,GAA6BU,OAAO,CAACZ,iBAAR,IAA6B,EAA1D,CA9B0B,CAgC1B;;AACA,SAAK4B,EAAL,CAAQjG,SAAR,GAAoB,2DAClB,KAAKiG,EAAL,CAAQ5E,UADU,EAElB,KAAK4E,EAAL,CAAQpD,UAFU,EAGlB,KAAKoD,EAAL,CAAQ5E,UAHU,CAApB;AAIA,SAAK4E,EAAL,CAAQrF,aAAR,GAAwB,+DACtB,KAAKqF,EAAL,CAAQhC,QADc,EAEtB,KAAKgC,EAAL,CAAQpD,UAFc,EAGtB,KAAKoD,EAAL,CAAQ5E,UAHc,CAAxB;AAKA,SAAK4E,EAAL,CAAQQ,SAAR,GAAoB,IAApB;AACA,SAAKR,EAAL,CAAQS,iBAAR,GAA4B,IAA5B;AAEA,SAAKT,EAAL,CAAQU,KAAR,GAAgB,IAAhB;AACA,SAAKV,EAAL,CAAQW,aAAR,GAAwB,IAAxB;AAEA,SAAKC,SAAL,CAAe5B,OAAO,CAACkB,MAAvB;;AAEA,SAAKF,EAAL,CAAQjC,GAAR,CAAY8C,cAAZ,GAA6B,UAACC,CAAD,EAAM;AACjC,UAAI,MAAI,CAACd,EAAL,CAAQQ,SAAR,KAAsB,IAA1B,EAAgC;AAC9B,cAAI,CAACR,EAAL,CAAQS,iBAAR,GAA4B,MAAI,CAACT,EAAL,CAAQQ,SAApC;AACD;;AAED,YAAI,CAACR,EAAL,CAAQQ,SAAR,GAAoBM,CAAC,CAACC,WAAF,CAAcC,cAAd,CAA6B,CAA7B,CAApB;;AAEA,UAAI,CAAC,MAAI,CAAChB,EAAL,CAAQS,iBAAb,EAAgC;AAC9B,YAAIlD,MAAM,GAAG,MAAI,CAACyC,EAAL,CAAQQ,SAArB;AACD,OAFD,MAEQ;AACN,YAAIjD,MAAM,GAAG,IAAIrD,YAAJ,CAAiB,MAAI,CAAC8F,EAAL,CAAQS,iBAAR,CAA0BlH,MAA1B,GAAmC,MAAI,CAACyG,EAAL,CAAQQ,SAAR,CAAkBjH,MAArD,GAA8D,MAAI,CAACyG,EAAL,CAAQG,OAAvF,CAAb;AACA5C,cAAM,CAAC0D,GAAP,CAAW,MAAI,CAACjB,EAAL,CAAQS,iBAAR,CAA0BjF,KAA1B,CAAgC,MAAI,CAACwE,EAAL,CAAQG,OAAxC,CAAX;AACA5C,cAAM,CAAC0D,GAAP,CAAW,MAAI,CAACjB,EAAL,CAAQQ,SAAnB,EAA8B,MAAI,CAACR,EAAL,CAAQS,iBAAR,CAA0BlH,MAA1B,GAAmC,MAAI,CAACyG,EAAL,CAAQG,OAAzE;AACD;;AAAA;AAED,UAAIe,MAAM,GAAG,iDAAgB3D,MAAhB,EAAwB,MAAI,CAACyC,EAAL,CAAQ5E,UAAhC,EAA4C,MAAI,CAAC4E,EAAL,CAAQG,OAApD,CAAb;AAEAe,YAAM,CAACC,OAAP,CAAe,UAAAC,CAAC,EAAI;AAClB,cAAI,CAACpB,EAAL,CAAQU,KAAR,GAAgBU,CAAhB;;AAEA,YAAIC,QAAQ,GAAG,MAAI,CAACrB,EAAL,CAAQf,OAAR,CACb,MAAI,CAACe,EAAL,CAAQ1B,kBADK,EAEb,MAAI,CAAC0B,EAAL,CAAQU,KAFK,EAGb,MAAI,CAACV,EAAL,CAAQW,aAHK,CAAf,CAHkB,CAQlB;;;AACA,YAAI,OAAO,MAAI,CAACX,EAAL,CAAQ9B,QAAf,KAA4B,UAA5B,IAA0C,MAAI,CAAC8B,EAAL,CAAQ3B,kBAAtD,EAA0E;AACxE,gBAAI,CAAC2B,EAAL,CAAQ9B,QAAR,CAAiBmD,QAAjB;AACD;;AAED,cAAI,CAACrB,EAAL,CAAQW,aAAR,GAAwB,MAAI,CAACX,EAAL,CAAQU,KAAhC;AACD,OAdD;AAeD,KAhCD;AAiCD;AAED;;;;;;;;;;;;;AAtFF;AAAA;AAAA,0BAiGQW,QAjGR,EAiGkB;AACd,WAAKrB,EAAL,CAAQ1B,kBAAR,GAA6B+C,QAAQ,IAAI,KAAKrB,EAAL,CAAQ1B,kBAAjD;AACA,WAAK0B,EAAL,CAAQ3B,kBAAR,GAA6B,IAA7B;AACD;AAED;;;;;;AAtGF;AAAA;AAAA,2BA2GS;AACL,WAAK2B,EAAL,CAAQ3B,kBAAR,GAA6B,KAA7B;AACD;AAED;;;;;;;AA/GF;AAAA;AAAA,8BAqHY6B,MArHZ,EAqHoB;AAChBA,YAAM,CAACI,OAAP,CAAe,KAAKN,EAAL,CAAQjC,GAAvB;AACD;AAED;;;;;;;;AAzHF;AAAA;AAAA,wBAgIMsD,QAhIN,EAgIgB;AACZ,UAAI,KAAKrB,EAAL,CAAQQ,SAAZ,EAAuB;AACrB,eAAO,KAAKR,EAAL,CAAQf,OAAR,CACEoC,QAAQ,IAAI,KAAKrB,EAAL,CAAQ1B,kBADtB,EAEC,KAAK0B,EAAL,CAAQQ,SAFT,EAGC,KAAKR,EAAL,CAAQS,iBAHT,CAAP;AAID,OALD,MAKO;AACL,eAAO,IAAP;AACD;AACF;AAzIH;;AAAA;AAAA,I;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3BA;AAEA,IAAIa,OAAO,GAAG,EAAd;AAEO,SAASC,YAAT,CAAsBC,GAAtB,EAA2B;AAChC,SAASA,GAAG,GAAG,CAAP,KAAc,CAAf,IAAqBA,GAAG,GAAG,CAAlC,EAAqC;AACnCA,OAAG,IAAI,CAAP;AACD;;AAED,SAAQA,GAAG,KAAK,CAAhB;AACD;AAEM,SAASC,KAAT,CAAeC,OAAf,EAAwB;AAC7B,QAAM,IAAIxG,KAAJ,CAAU,YAAYwG,OAAtB,CAAN;AACD;AAEM,SAASC,mBAAT,CAA6BC,CAA7B,EAAgCC,CAAhC,EAAmC;AACxC,MAAIC,CAAC,GAAG,EAAR;;AACA,OAAK,IAAIlJ,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGM,IAAI,CAAC2B,GAAL,CAAS+G,CAAC,CAACrI,MAAX,EAAmBsI,CAAC,CAACtI,MAArB,CAApB,EAAkDX,CAAC,EAAnD,EAAuD;AACrDkJ,KAAC,CAAClJ,CAAD,CAAD,GAAOgJ,CAAC,CAAChJ,CAAD,CAAD,GAAOiJ,CAAC,CAACjJ,CAAD,CAAf;AACD;;AAED,SAAOkJ,CAAP;AACD;AAEM,SAASC,WAAT,CAAqB1I,MAArB,EAA6B2I,UAA7B,EAAyC;AAC9C,MAAIA,UAAU,KAAK,MAAnB,EAA2B;AACzB,QAAIA,UAAU,KAAK,EAAf,IAAqB,CAACA,UAA1B,EAAsCA,UAAU,GAAG,SAAb;AACtC,QAAI,CAACV,OAAO,CAACU,UAAD,CAAZ,EAA0BV,OAAO,CAACU,UAAD,CAAP,GAAsB,EAAtB;;AAE1B,QAAI,CAACV,OAAO,CAACU,UAAD,CAAP,CAAoB3I,MAAM,CAACE,MAA3B,CAAL,EAAyC;AACvC,UAAI;AACF+H,eAAO,CAACU,UAAD,CAAP,CAAoB3I,MAAM,CAACE,MAA3B,IAAqC,uCAAS,CAACyI,UAAD,CAAT,CACzB3I,MAAM,CAACE,MADkB,CAArC;AAGD,OAJD,CAKA,OAAOuH,CAAP,EAAU;AACR,cAAM,IAAI5F,KAAJ,CAAU,4BAAV,CAAN;AACD;AACF;;AAED7B,UAAM,GAAGsI,mBAAmB,CAACtI,MAAD,EAASiI,OAAO,CAACU,UAAD,CAAP,CAAoB3I,MAAM,CAACE,MAA3B,CAAT,CAA5B;AACD;;AAED,SAAOF,MAAP;AACD;AAEM,SAAS4I,eAAT,CAAyB1I,MAAzB,EAAiCqD,UAAjC,EAA6CxB,UAA7C,EAAyD;AAC9D,MAAIrB,SAAS,GAAG,IAAIG,YAAJ,CAAiBX,MAAjB,CAAhB;;AAEA,OAAK,IAAIX,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGmB,SAAS,CAACR,MAA9B,EAAsCX,CAAC,EAAvC,EAA2C;AACzCmB,aAAS,CAACnB,CAAD,CAAT,GAAeA,CAAC,GAAGgE,UAAJ,GAAkBxB,UAAjC;AACArB,aAAS,CAACnB,CAAD,CAAT,GAAe,KAAKM,IAAI,CAACgJ,IAAL,CAAUnI,SAAS,CAACnB,CAAD,CAAT,GAAe,MAAzB,CAAL,GACP,MAAMM,IAAI,CAACgJ,IAAL,CAAUhJ,IAAI,CAACM,GAAL,CAAUO,SAAS,CAACnB,CAAD,CAAT,GAAe,IAAzB,EAAgC,CAAhC,CAAV,CADd;AAED;;AAED,SAAOmB,SAAP;AACD;AAEM,SAASoI,YAAT,CAAsBC,CAAtB,EAAyB;AAC9B;AACA,SAAOnH,KAAK,CAACM,SAAN,CAAgBC,KAAhB,CAAsBC,IAAtB,CAA2B2G,CAA3B,CAAP;AACD;AAEM,SAASC,YAAT,CAAsBD,CAAtB,EAAyB;AAC9B;AACA,SAAOlI,YAAY,CAACoI,IAAb,CAAkBF,CAAlB,CAAP;AACD;AAEM,SAASG,UAAT,CAAoBf,GAApB,EAAyBgB,KAAzB,EAAgC;AACrC,SAAOhB,GAAG,GAAGgB,KAAb;AACD;AAEM,SAASC,SAAT,CAAmBb,CAAnB,EAAsBY,KAAtB,EAA6B;AAClC,SAAOZ,CAAC,CAAClJ,GAAF,CAAM,UAAUqE,CAAV,EAAa;AAAE,WAAOwF,UAAU,CAACxF,CAAD,EAAIyF,KAAJ,CAAjB;AAA8B,GAAnD,CAAP;AACD;AAEM,SAASE,cAAT,CAAwBd,CAAxB,EAA2B;AAChC,MAAIzI,GAAG,GAAGD,IAAI,CAACC,GAAL,CAASwJ,KAAT,CAAe,IAAf,EAAqBf,CAArB,CAAV;AAEA,SAAOA,CAAC,CAAClJ,GAAF,CAAM,UAAUqE,CAAV,EAAa;AACxB,WAAOA,CAAC,GAAG5D,GAAX;AACD,GAFM,CAAP;AAGD;AAEM,SAASyJ,IAAT,CAAchB,CAAd,EAAiB;AACtB,SAAOA,CAAC,CAAC/I,MAAF,CAAS,UAAUgK,IAAV,EAAgBC,GAAhB,EAAqB;AAAG,WAAOD,IAAI,GAAGC,GAAd;AAAqB,GAAtD,IAA0DlB,CAAC,CAACrI,MAAnE;AACD;;AAED,SAASwJ,UAAT,CAAoBC,QAApB,EAA8B;AAC5B,MAAIC,SAAS,GAAG,OAAO/J,IAAI,CAAC4C,GAAL,CAASkH,QAAQ,GAAG,IAApB,IAA4B,CAAnC,CAAhB;AACA,SAAOC,SAAP;AACD;;AAED,SAASC,UAAT,CAAoBD,SAApB,EAA+B;AAC7B,MAAID,QAAQ,GAAG,OAAO9J,IAAI,CAACmC,GAAL,CAAS,IAAK4H,SAAS,GAAG,GAA1B,CAAtB;AACA,SAAOD,QAAP;AACD;;AAEM,SAASG,SAAT,CAAmBC,EAAnB,EAAuB;AAAE,SAAOL,UAAU,CAACK,EAAD,CAAjB;AAAwB;AAEjD,SAASC,SAAT,CAAmBC,EAAnB,EAAuB;AAAE,SAAOJ,UAAU,CAACI,EAAD,CAAjB;AAAwB;AAEjD,SAASC,mBAAT,CAA6BxI,UAA7B,EAAyC6B,UAAzC,EAAqDxB,UAArD,EAAiE;AACtE;AACA,MAAIoI,SAAS,GAAG,IAAItJ,YAAJ,CAAiBa,UAAU,GAAG,CAA9B,CAAhB;AACA,MAAI0I,eAAe,GAAG,IAAIvJ,YAAJ,CAAiBa,UAAU,GAAG,CAA9B,CAAtB,CAHsE,CAKtE;;AACA,MAAI2I,cAAc,GAAG,CAArB;AACA,MAAIC,cAAc,GAAG/G,UAAU,GAAG,CAAlC,CAPsE,CAStE;;AACA,MAAIgH,aAAa,GAAGV,UAAU,CAACQ,cAAD,CAA9B;;AACA,MAAIG,aAAa,GAAGX,UAAU,CAACS,cAAD,CAA9B,CAXsE,CAatE;;;AACA,MAAInB,KAAK,GAAGqB,aAAa,GAAGD,aAA5B,CAdsE,CAgBtE;;AACA,MAAIE,UAAU,GAAGtB,KAAK,IAAIzH,UAAU,GAAG,CAAjB,CAAtB;AAEA,MAAIgJ,aAAa,GAAG9I,KAAK,CAACF,UAAU,GAAG,CAAd,CAAzB;;AAEA,OAAK,IAAInC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAG4K,SAAS,CAACjK,MAA9B,EAAsCX,CAAC,EAAvC,EAA2C;AACzC;AACA;AACA4K,aAAS,CAAC5K,CAAD,CAAT,GAAeA,CAAC,GAAGkL,UAAnB,CAHyC,CAKzC;;AACAL,mBAAe,CAAC7K,CAAD,CAAf,GAAqBmK,UAAU,CAACS,SAAS,CAAC5K,CAAD,CAAV,CAA/B,CANyC,CAQzC;;AACAmL,iBAAa,CAACnL,CAAD,CAAb,GAAmBM,IAAI,CAAC8K,KAAL,CAAW,CAAC5I,UAAU,GAAG,CAAd,IACPqI,eAAe,CAAC7K,CAAD,CADR,GACcgE,UADzB,CAAnB;AAED;;AAED,MAAIqH,UAAU,GAAGhJ,KAAK,CAACF,UAAD,CAAtB;;AACA,OAAK,IAAI/B,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGiL,UAAU,CAAC1K,MAA/B,EAAuCP,CAAC,EAAxC,EAA4C;AAC1C;AACA;AACAiL,cAAU,CAACjL,CAAD,CAAV,GAAgBiC,KAAK,CAAC0H,KAAN,CACR,IADQ,EAER,IAAI1H,KAAJ,CAAWG,UAAU,GAAG,CAAd,GAAmB,CAA7B,CAFQ,EAEyB1C,GAFzB,CAE6BwL,MAAM,CAAC3I,SAAP,CAAiB4I,OAF9C,EAEuD,CAFvD,CAAhB,CAH0C,CAO1C;;AACA,SAAK,IAAIvL,EAAC,GAAGmL,aAAa,CAAC/K,CAAD,CAA1B,EAA+BJ,EAAC,GAAGmL,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAAhD,EAAyDJ,EAAC,EAA1D,EAA8D;AAC5DqL,gBAAU,CAACjL,CAAD,CAAV,CAAcJ,EAAd,IAAmB,CAACA,EAAC,GAAGmL,aAAa,CAAC/K,CAAD,CAAlB,KACR+K,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAAb,GAAuB+K,aAAa,CAAC/K,CAAD,CAD5B,CAAnB;AAED;;AAED,SAAK,IAAIJ,GAAC,GAAGmL,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAA1B,EAAmCJ,GAAC,GAAGmL,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAApD,EAA6DJ,GAAC,EAA9D,EAAkE;AAChEqL,gBAAU,CAACjL,CAAD,CAAV,CAAcJ,GAAd,IAAmB,CAACmL,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAAb,GAAuBJ,GAAxB,KACRmL,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAAb,GAAuB+K,aAAa,CAAC/K,CAAC,GAAG,CAAL,CAD5B,CAAnB;AAED;AACF;;AAED,SAAOiL,UAAP;AACD;AAEM,SAASG,WAAT,CAAqBC,IAArB,EAA2BC,IAA3B,EAAiC;AACtC,SAAOpL,IAAI,CAACqL,IAAL,CAAU,KAAKF,IAAL,GAAYC,IAAtB,CAAP;AACD;AAEM,SAASE,iBAAT,CAA4B5C,CAA5B,EAA+B;AACpC,MAAI6C,QAAQ,GAAG7C,CAAC,CAAC,CAAD,CAAD,CAAKlJ,GAAL,CAAS;AAAA,WAAM,CAAN;AAAA,GAAT,CAAf;AACA,MAAIgM,eAAe,GAAG9C,CAAC,CAAC/I,MAAF,CAAS,UAACC,GAAD,EAAMH,GAAN,EAAc;AAC3CA,OAAG,CAACwI,OAAJ,CAAY,UAACwD,IAAD,EAAO3L,CAAP,EAAa;AACvBF,SAAG,CAACE,CAAD,CAAH,IAAUE,IAAI,CAACM,GAAL,CAASmL,IAAT,EAAe,CAAf,CAAV;AACD,KAFD;AAGA,WAAO7L,GAAP;AACD,GALqB,EAKnB2L,QALmB,EAKT/L,GALS,CAKLQ,IAAI,CAACgD,IALA,CAAtB;AAMA,SAAO0F,CAAC,CAAClJ,GAAF,CAAM,UAACC,GAAD,EAAMC,CAAN;AAAA,WAAYD,GAAG,CAACD,GAAJ,CAAQ,UAACK,CAAD,EAAIC,CAAJ;AAAA,aAAUD,CAAC,IAAI2L,eAAe,CAAC1L,CAAD,CAAf,IAAsB,CAA1B,CAAX;AAAA,KAAR,CAAZ;AAAA,GAAN,CAAP;AACD;AAAA;AAEM,SAAS4L,sBAAT,CAAgC7J,UAAhC,EAA4C6B,UAA5C,EAAwDxB,UAAxD,EAAyH;AAAA,MAArDyJ,YAAqD,uEAAxC,CAAwC;AAAA,MAArCC,WAAqC,uEAAzB,CAAyB;AAAA,MAAtBC,KAAsB,uEAAhB,IAAgB;AAAA,MAAVT,IAAU,uEAAL,GAAK;AAC9H,MAAIU,aAAa,GAAG9L,IAAI,CAAC8K,KAAL,CAAW5I,UAAU,GAAG,CAAxB,IAA6B,CAAjD;AAGA,MAAI6J,aAAa,GAAG,IAAIhK,KAAJ,CAAUG,UAAV,EAAsB8J,IAAtB,CAA2B,CAA3B,EACjBxM,GADiB,CACb,UAACyM,CAAD,EAAIvM,CAAJ;AAAA,WAAUmC,UAAU,GAAGqJ,WAAW,CAACxH,UAAU,GAAGhE,CAAb,GAAiBwC,UAAlB,EAA8BkJ,IAA9B,CAAlC;AAAA,GADa,CAApB,CAJ8H,CAO9H;AACA;;AACAW,eAAa,CAAC,CAAD,CAAb,GAAmBA,aAAa,CAAC,CAAD,CAAb,GAAmB,MAAMlK,UAA5C;AAEA,MAAIqK,YAAY,GAAGH,aAAa,CAC7BzJ,KADgB,CACV,CADU,EAEhB9C,GAFgB,CAEZ,UAACK,CAAD,EAAIH,CAAJ;AAAA,WAAUM,IAAI,CAACC,GAAL,CAASJ,CAAC,GAAGkM,aAAa,CAACrM,CAAD,CAA1B,CAAV;AAAA,GAFY,EAE8B,CAF9B,EAGhByM,MAHgB,CAGT,CAAC,CAAD,CAHS,CAAnB;AAKA,MAAIC,cAAc,GAAGpM,IAAI,CAACqM,KAAL,CAAWxK,UAAU,GAAG,CAAxB,CAArB;AAEA,MAAIyK,WAAW,GAAG,IAAIvK,KAAJ,CAAUF,UAAV,EAAsBmK,IAAtB,CAA2B,CAA3B,EACfxM,GADe,CACX,UAACyM,CAAD,EAAIvM,CAAJ;AAAA,WAAUqM,aAAa,CAACvM,GAAd,CAAkB,UAAA+M,GAAG;AAAA,aACjC,CAAC,KAAK1K,UAAL,GAAkBuK,cAAlB,GAAmCG,GAAnC,GAAyC7M,CAA1C,IAA+CmC,UAAhD,GAA8DuK,cAD5B;AAAA,KAArB,CAAV;AAAA,GADW,CAAlB;AAKA,MAAII,OAAO,GAAGF,WAAW,CAAC9M,GAAZ,CAAgB,UAACC,GAAD,EAAMC,CAAN;AAAA,WAAYD,GAAG,CAACD,GAAJ,CAAQ,UAACyM,CAAD,EAAInM,CAAJ;AAAA,aAChDE,IAAI,CAAC4C,GAAL,CAAS,CAAC,GAAD,GAAO5C,IAAI,CAACM,GAAL,CAAS,IAAIgM,WAAW,CAAC5M,CAAD,CAAX,CAAeI,CAAf,CAAJ,GAAwBoM,YAAY,CAACpM,CAAD,CAA7C,EAAkD,CAAlD,CAAhB,CADgD;AAAA,KAAR,CAAZ;AAAA,GAAhB,CAAd;AAIA0M,SAAO,GAAGlB,iBAAiB,CAACkB,OAAD,CAA3B;;AAEA,MAAIZ,WAAJ,EAAiB;AACf,QAAIa,aAAa,GAAGV,aAAa,CAACvM,GAAd,CAAkB,UAAAK,CAAC;AAAA,aACrCG,IAAI,CAAC4C,GAAL,CAAS,CAAC,GAAD,GAAO5C,IAAI,CAACM,GAAL,CAAS,CAACT,CAAC,GAAGgC,UAAJ,GAAiB8J,YAAlB,IAAkCC,WAA3C,EAAwD,CAAxD,CAAhB,CADqC;AAAA,KAAnB,CAApB;AAGAY,WAAO,GAAGA,OAAO,CAAChN,GAAR,CAAY,UAAAC,GAAG;AAAA,aAAIA,GAAG,CAACD,GAAJ,CAAQ,UAACiM,IAAD,EAAO3L,CAAP;AAAA,eAAa2L,IAAI,GAAGgB,aAAa,CAAC3M,CAAD,CAAjC;AAAA,OAAR,CAAJ;AAAA,KAAf,CAAV;AACD;;AAED,MAAI+L,KAAJ,EAAW;AACTW,WAAO,sBAAOA,OAAO,CAAClK,KAAR,CAAc,CAAd,CAAP,4BAA4BkK,OAAO,CAAClK,KAAR,CAAc,CAAd,EAAiB,CAAjB,CAA5B,EAAP;AACD;;AAED,SAAOkK,OAAO,CAAChN,GAAR,CAAY,UAAAC,GAAG;AAAA,WAAIA,GAAG,CAAC6C,KAAJ,CAAU,CAAV,EAAawJ,aAAb,CAAJ;AAAA,GAAf,CAAP;AACD;AAEM,SAAStE,KAAT,CAAenD,MAAf,EAAuBqI,WAAvB,EAAoCC,SAApC,EAA+C;AACpD,MAAItI,MAAM,CAAChE,MAAP,GAAgBqM,WAApB,EAAiC;AAC/B,UAAM,IAAI1K,KAAJ,CAAU,sCAAV,CAAN;AACD;;AACD,MAAI2K,SAAS,GAAG,CAAhB,EAAmB;AACjB,UAAM,IAAI3K,KAAJ,CAAU,kCAAV,CAAN;AACD;;AACD,MAAI0K,WAAW,GAAG,CAAlB,EAAqB;AACnB,UAAM,IAAI1K,KAAJ,CAAU,oCAAV,CAAN;AACD;;AAED,MAAM4K,SAAS,GAAG,IAAI5M,IAAI,CAAC8K,KAAL,CAAW,CAACzG,MAAM,CAAChE,MAAP,GAAgBqM,WAAjB,IAAgCC,SAA3C,CAAtB;AAEA,SAAO,IAAI5K,KAAJ,CAAU6K,SAAV,EAAqBZ,IAArB,CAA0B,CAA1B,EAA6BxM,GAA7B,CAAiC,UAACyM,CAAD,EAAIvM,CAAJ;AAAA,WACtC2E,MAAM,CAAC/B,KAAP,CAAa5C,CAAC,GAAGiN,SAAjB,EAA6BjN,CAAC,GAAGiN,SAAL,GAAkBD,WAA9C,CADsC;AAAA,GAAjC,CAAP;AAED,C;;;;;;;;;;;;ACzOD;AAAA;AAAA;AAAA;AAAA;AAAO,SAASG,QAAT,CAAkBC,IAAlB,EAAwB;AAC7B,MAAIC,cAAc,GAAG,IAAI/L,YAAJ,CAAiB8L,IAAjB,CAArB;AACA,MAAIE,MAAM,GAAG,IAAIhN,IAAI,CAACiN,EAAT,IAAeH,IAAI,GAAG,CAAtB,CAAb;AACA,MAAII,MAAM,GAAG,IAAIF,MAAjB,CAH6B,CAK7B;AACA;;AACA,OAAK,IAAItN,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoN,IAAI,GAAG,CAA3B,EAA8BpN,CAAC,EAA/B,EAAmC;AACjCqN,kBAAc,CAACrN,CAAD,CAAd,GAAoB,OAAO,MAAMM,IAAI,CAACmN,GAAL,CAASzN,CAAC,GAAGsN,MAAb,CAAb,GACZ,OAAOhN,IAAI,CAACmN,GAAL,CAASzN,CAAC,GAAGwN,MAAb,CADf;AAED,GAV4B,CAY7B;;;AACA,OAAK,IAAIxN,EAAC,GAAGoN,IAAI,GAAG,CAApB,EAAuBpN,EAAC,GAAG,CAA3B,EAA8BA,EAAC,EAA/B,EAAmC;AACjCqN,kBAAc,CAACD,IAAI,GAAGpN,EAAR,CAAd,GAA2BqN,cAAc,CAACrN,EAAC,GAAG,CAAL,CAAzC;AACD;;AAED,SAAOqN,cAAP;AACD;AAEM,SAASK,IAAT,CAAcN,IAAd,EAAoB;AACzB,MAAIO,KAAK,GAAGrN,IAAI,CAACiN,EAAL,IAAWH,IAAI,GAAG,CAAlB,CAAZ;AACA,MAAIQ,UAAU,GAAG,IAAItM,YAAJ,CAAiB8L,IAAjB,CAAjB;;AAEA,OAAK,IAAIpN,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoN,IAApB,EAA0BpN,CAAC,EAA3B,EAA+B;AAC7B4N,cAAU,CAAC5N,CAAD,CAAV,GAAgBM,IAAI,CAACuN,GAAL,CAASF,KAAK,GAAG3N,CAAjB,CAAhB;AACD;;AAED,SAAO4N,UAAP;AACD;AAEM,SAASE,OAAT,CAAiBV,IAAjB,EAAuB;AAC5B,MAAIW,aAAa,GAAG,IAAIzM,YAAJ,CAAiB8L,IAAjB,CAApB;;AACA,OAAK,IAAIpN,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoN,IAApB,EAA0BpN,CAAC,EAA3B,EAA+B;AAC7B;AACA;AACA+N,iBAAa,CAAC/N,CAAD,CAAb,GAAmB,MAAM,MAAMM,IAAI,CAACmN,GAAL,CAAS,IAAInN,IAAI,CAACiN,EAAT,GAAcvN,CAAd,IAAmBoN,IAAI,GAAG,CAA1B,CAAT,CAA/B;AACD;;AAED,SAAOW,aAAP;AACD;AAEM,SAASC,OAAT,CAAiBZ,IAAjB,EAAuB;AAC5B,MAAIa,aAAa,GAAG,IAAI3M,YAAJ,CAAiB8L,IAAjB,CAApB;;AACA,OAAK,IAAIpN,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGoN,IAApB,EAA0BpN,CAAC,EAA3B,EAA+B;AAC7B;AACAiO,iBAAa,CAACjO,CAAD,CAAb,GAAmB,OAAO,OAAOM,IAAI,CAACmN,GAAL,CAAS,IAAInN,IAAI,CAACiN,EAAT,IAAevN,CAAC,GAAGoN,IAAJ,GAAW,CAA1B,CAAT,CAAjC;AACD;;AAED,SAAOa,aAAP;AACD,C","file":"meyda.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Meyda\"] = factory();\n\telse\n\t\troot[\"Meyda\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/index.js\");\n","'use strict';\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","module.exports = require('./src/dct.js');\n","/*===========================================================================*\\\n * Discrete Cosine Transform\n *\n * (c) Vail Systems. Joshua Jung and Ben Bryan. 2015\n *\n * This code is not designed to be highly optimized but as an educational\n * tool to understand the Mel-scale and its related coefficients used in\n * human speech analysis.\n\\*===========================================================================*/\ncosMap = null;\n\n// Builds a cosine map for the given input size. This allows multiple input sizes to be memoized automagically\n// if you want to run the DCT over and over.\nvar memoizeCosines = function(N) {\n  cosMap = cosMap || {};\n  cosMap[N] = new Array(N*N);\n\n  var PI_N = Math.PI / N;\n\n  for (var k = 0; k < N; k++) {\n    for (var n = 0; n < N; n++) {\n      cosMap[N][n + (k * N)] = Math.cos(PI_N * (n + 0.5) * k);\n    }\n  }\n};\n\nfunction dct(signal, scale) {\n  var L = signal.length;\n  scale = scale || 2;\n\n  if (!cosMap || !cosMap[L]) memoizeCosines(L);\n\n  var coefficients = signal.map(function () {return 0;});\n\n  return coefficients.map(function (__, ix) {\n    return scale * signal.reduce(function (prev, cur, ix_, arr) {\n      return prev + (cur * cosMap[L][ix_ + (ix * L)]);\n    }, 0);\n  });\n};\n\nmodule.exports = dct;\n","'use strict';\n\nvar utils = require('./utils');\n\n// real to complex fft\nvar fft = function fft(signal) {\n\n  var complexSignal = {};\n\n  if (signal.real === undefined || signal.imag === undefined) {\n    complexSignal = utils.constructComplexArray(signal);\n  } else {\n    complexSignal.real = signal.real.slice();\n    complexSignal.imag = signal.imag.slice();\n  }\n\n  var N = complexSignal.real.length;\n  var logN = Math.log2(N);\n\n  if (Math.round(logN) != logN) throw new Error('Input size must be a power of 2.');\n\n  if (complexSignal.real.length != complexSignal.imag.length) {\n    throw new Error('Real and imaginary components must have the same length.');\n  }\n\n  var bitReversedIndices = utils.bitReverseArray(N);\n\n  // sort array\n  var ordered = {\n    'real': [],\n    'imag': []\n  };\n\n  for (var i = 0; i < N; i++) {\n    ordered.real[bitReversedIndices[i]] = complexSignal.real[i];\n    ordered.imag[bitReversedIndices[i]] = complexSignal.imag[i];\n  }\n\n  for (var _i = 0; _i < N; _i++) {\n    complexSignal.real[_i] = ordered.real[_i];\n    complexSignal.imag[_i] = ordered.imag[_i];\n  }\n  // iterate over the number of stages\n  for (var n = 1; n <= logN; n++) {\n    var currN = Math.pow(2, n);\n\n    // find twiddle factors\n    for (var k = 0; k < currN / 2; k++) {\n      var twiddle = utils.euler(k, currN);\n\n      // on each block of FT, implement the butterfly diagram\n      for (var m = 0; m < N / currN; m++) {\n        var currEvenIndex = currN * m + k;\n        var currOddIndex = currN * m + k + currN / 2;\n\n        var currEvenIndexSample = {\n          'real': complexSignal.real[currEvenIndex],\n          'imag': complexSignal.imag[currEvenIndex]\n        };\n        var currOddIndexSample = {\n          'real': complexSignal.real[currOddIndex],\n          'imag': complexSignal.imag[currOddIndex]\n        };\n\n        var odd = utils.multiply(twiddle, currOddIndexSample);\n\n        var subtractionResult = utils.subtract(currEvenIndexSample, odd);\n        complexSignal.real[currOddIndex] = subtractionResult.real;\n        complexSignal.imag[currOddIndex] = subtractionResult.imag;\n\n        var additionResult = utils.add(odd, currEvenIndexSample);\n        complexSignal.real[currEvenIndex] = additionResult.real;\n        complexSignal.imag[currEvenIndex] = additionResult.imag;\n      }\n    }\n  }\n\n  return complexSignal;\n};\n\n// complex to real ifft\nvar ifft = function ifft(signal) {\n\n  if (signal.real === undefined || signal.imag === undefined) {\n    throw new Error(\"IFFT only accepts a complex input.\");\n  }\n\n  var N = signal.real.length;\n\n  var complexSignal = {\n    'real': [],\n    'imag': []\n  };\n\n  //take complex conjugate in order to be able to use the regular FFT for IFFT\n  for (var i = 0; i < N; i++) {\n    var currentSample = {\n      'real': signal.real[i],\n      'imag': signal.imag[i]\n    };\n\n    var conjugateSample = utils.conj(currentSample);\n    complexSignal.real[i] = conjugateSample.real;\n    complexSignal.imag[i] = conjugateSample.imag;\n  }\n\n  //compute\n  var X = fft(complexSignal);\n\n  //normalize\n  complexSignal.real = X.real.map(function (val) {\n    return val / N;\n  });\n\n  complexSignal.imag = X.imag.map(function (val) {\n    return val / N;\n  });\n\n  return complexSignal;\n};\n\nmodule.exports = {\n  fft: fft,\n  ifft: ifft\n};","'use strict';\n\n// memoization of the reversal of different lengths.\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar memoizedReversal = {};\nvar memoizedZeroBuffers = {};\n\nvar constructComplexArray = function constructComplexArray(signal) {\n  var complexSignal = {};\n\n  complexSignal.real = signal.real === undefined ? signal.slice() : signal.real.slice();\n\n  var bufferSize = complexSignal.real.length;\n\n  if (memoizedZeroBuffers[bufferSize] === undefined) {\n    memoizedZeroBuffers[bufferSize] = Array.apply(null, Array(bufferSize)).map(Number.prototype.valueOf, 0);\n  }\n\n  complexSignal.imag = memoizedZeroBuffers[bufferSize].slice();\n\n  return complexSignal;\n};\n\nvar bitReverseArray = function bitReverseArray(N) {\n  if (memoizedReversal[N] === undefined) {\n    var maxBinaryLength = (N - 1).toString(2).length; //get the binary length of the largest index.\n    var templateBinary = '0'.repeat(maxBinaryLength); //create a template binary of that length.\n    var reversed = {};\n    for (var n = 0; n < N; n++) {\n      var currBinary = n.toString(2); //get binary value of current index.\n\n      //prepend zeros from template to current binary. This makes binary values of all indices have the same length.\n      currBinary = templateBinary.substr(currBinary.length) + currBinary;\n\n      currBinary = [].concat(_toConsumableArray(currBinary)).reverse().join(''); //reverse\n      reversed[n] = parseInt(currBinary, 2); //convert to decimal\n    }\n    memoizedReversal[N] = reversed; //save\n  }\n  return memoizedReversal[N];\n};\n\n// complex multiplication\nvar multiply = function multiply(a, b) {\n  return {\n    'real': a.real * b.real - a.imag * b.imag,\n    'imag': a.real * b.imag + a.imag * b.real\n  };\n};\n\n// complex addition\nvar add = function add(a, b) {\n  return {\n    'real': a.real + b.real,\n    'imag': a.imag + b.imag\n  };\n};\n\n// complex subtraction\nvar subtract = function subtract(a, b) {\n  return {\n    'real': a.real - b.real,\n    'imag': a.imag - b.imag\n  };\n};\n\n// euler's identity e^x = cos(x) + sin(x)\nvar euler = function euler(kn, N) {\n  var x = -2 * Math.PI * kn / N;\n  return { 'real': Math.cos(x), 'imag': Math.sin(x) };\n};\n\n// complex conjugate\nvar conj = function conj(a) {\n  a.imag *= -1;\n  return a;\n};\n\nmodule.exports = {\n  bitReverseArray: bitReverseArray,\n  multiply: multiply,\n  add: add,\n  subtract: subtract,\n  euler: euler,\n  conj: conj,\n  constructComplexArray: constructComplexArray\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\r\n} catch (e) {\r\n\t// This works if the window reference is available\r\n\tif (typeof window === \"object\") g = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n","export default function(args) {\n  if (typeof args.ampSpectrum !== 'object') {\n    throw new TypeError('Valid ampSpectrum is required to generate chroma');\n  }\n  if (typeof args.chromaFilterBank !== 'object') {\n    throw new TypeError('Valid chromaFilterBank is required to generate chroma');\n  }\n\n  var chromagram = args.chromaFilterBank.map((row, i) =>\n    args.ampSpectrum.reduce((acc, v, j) => acc + v * row[j], 0)\n  );\n  var maxVal = Math.max(...chromagram);\n\n\n  return maxVal\n    ? chromagram.map(v => v / maxVal)\n    : chromagram;\n}\n","import * as assert from 'assert';\n\nexport default function() {\n  if (typeof arguments[0].signal !== 'object') {\n    throw new TypeError();\n  }\n\n  var energy = 0;\n  for (var i = 0; i < arguments[0].signal.length; i++) {\n    energy += Math.pow(Math.abs(arguments[0].signal[i]), 2);\n  }\n\n  return energy;\n}\n","export function mu(i, amplitudeSpect) {\n  var numerator = 0;\n  var denominator = 0;\n  for (var k = 0; k < amplitudeSpect.length; k++) {\n    numerator += Math.pow(k, i) * Math.abs(amplitudeSpect[k]);\n    denominator += amplitudeSpect[k];\n  }\n\n  return numerator / denominator;\n}\n","export default function(args) {\n  if (typeof args.ampSpectrum !== 'object' ||\n         typeof args.barkScale !== 'object') {\n    throw new TypeError();\n  }\n\n  var NUM_BARK_BANDS = 24;\n  var specific = new Float32Array(NUM_BARK_BANDS);\n  var total = 0;\n  var normalisedSpectrum = args.ampSpectrum;\n  var bbLimits = new Int32Array(NUM_BARK_BANDS + 1);\n\n  bbLimits[0] = 0;\n  var currentBandEnd = args.barkScale[normalisedSpectrum.length - 1] /\n        NUM_BARK_BANDS;\n  var currentBand = 1;\n  for (let i = 0; i < normalisedSpectrum.length; i++) {\n    while (args.barkScale[i] > currentBandEnd) {\n      bbLimits[currentBand++] = i;\n      currentBandEnd = currentBand *\n\t\t\t\t\t\t\t\targs.barkScale[normalisedSpectrum.length - 1] /\n                NUM_BARK_BANDS;\n    }\n  }\n\n  bbLimits[NUM_BARK_BANDS] = normalisedSpectrum.length - 1;\n\n  //process\n\n  for (let i = 0; i < NUM_BARK_BANDS; i++) {\n    let sum = 0;\n    for (let j = bbLimits[i]; j < bbLimits[i + 1]; j++) {\n\n      sum += normalisedSpectrum[j];\n    }\n\n    specific[i] = Math.pow(sum, 0.23);\n  }\n\n  //get total loudness\n  for (let i = 0; i < specific.length; i++) {\n    total += specific[i];\n  }\n\n  return {\n    specific: specific,\n    total: total,\n  };\n}\n","import powerSpectrum from './powerSpectrum';\nimport freqToMel from './../utilities';\nimport melToFreq from './../utilities';\n\nvar dct = require('dct');\n\nexport default function(args) {\n  if (typeof args.ampSpectrum !== 'object') {\n    throw new TypeError('Valid ampSpectrum is required to generate MFCC');\n  }\n  if (typeof args.melFilterBank !== 'object') {\n    throw new TypeError('Valid melFilterBank is required to generate MFCC');\n  }\n\n  let numberOfMFCCCoefficients = Math.min(40, Math.max(1, args.numberOfMFCCCoefficients || 13));\n\n  // Tutorial from:\n  // http://practicalcryptography.com/miscellaneous/machine-learning\n  // /guide-mel-frequency-cepstral-coefficients-mfccs/\n  let powSpec = powerSpectrum(args);\n  let numFilters = args.melFilterBank.length;\n  let filtered = Array(numFilters);\n\n  if (numFilters < numberOfMFCCCoefficients) {\n    throw new Error(\"Insufficient filter bank for requested number of coefficients\");\n  }\n\n  let loggedMelBands = new Float32Array(numFilters);\n\n  for (let i = 0; i < loggedMelBands.length; i++) {\n    filtered[i] = new Float32Array(args.bufferSize / 2);\n    loggedMelBands[i] = 0;\n    for (let j = 0; j < (args.bufferSize / 2); j++) {\n      //point-wise multiplication between power spectrum and filterbanks.\n      filtered[i][j] = args.melFilterBank[i][j] * powSpec[j];\n\n      //summing up all of the coefficients into one array\n      loggedMelBands[i] += filtered[i][j];\n    }\n\n    //log each coefficient.\n    loggedMelBands[i] = Math.log(loggedMelBands[i] + 1);\n  }\n\n  //dct\n  let loggedMelBandsArray = Array.prototype.slice.call(loggedMelBands);\n  let mfccs = dct(loggedMelBandsArray).slice(0, numberOfMFCCCoefficients);\n\n  return mfccs;\n}\n","import loudness from './loudness';\n\nexport default function() {\n  if (typeof arguments[0].signal !== 'object') {\n    throw new TypeError();\n  }\n\n  var loudnessValue = loudness(arguments[0]);\n  var spec = loudnessValue.specific;\n  var output = 0;\n\n  for (var i = 0; i < spec.length; i++) {\n    if (i < 15) {\n      output += (i + 1) * spec[i + 1];\n    } else {\n      output += 0.066 * Math.exp(0.171 * (i + 1));\n    }\n  }\n\n  output *= 0.11 / loudnessValue.total;\n\n  return output;\n}\n","import loudness from './loudness';\n\nexport default function() {\n  if (typeof arguments[0].signal !== 'object') {\n    throw new TypeError();\n  }\n\n  var loudnessValue = loudness(arguments[0]);\n\n  var max = 0;\n  for (var i = 0; i < loudnessValue.specific.length; i++) {\n    if (loudnessValue.specific[i] > max) {\n      max = loudnessValue.specific[i];\n    }\n  }\n\n  var spread = Math.pow((loudnessValue.total - max) / loudnessValue.total, 2);\n\n  return spread;\n}\n","export default function() {\n  if (typeof arguments[0].ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  var powerSpectrum = new Float32Array(arguments[0].ampSpectrum.length);\n  for (var i = 0; i < powerSpectrum.length; i++) {\n    powerSpectrum[i] =  Math.pow(arguments[0].ampSpectrum[i], 2);\n  }\n\n  return powerSpectrum;\n}\n","export default function(args) {\n  if (typeof args.signal !== 'object') {\n    throw new TypeError();\n  }\n\n  var rms = 0;\n  for (var i = 0; i < args.signal.length; i++) {\n    rms += Math.pow(args.signal[i], 2);\n  }\n\n  rms = rms / args.signal.length;\n  rms = Math.sqrt(rms);\n\n  return rms;\n}\n","import {mu} from './extractorUtilities';\n\nexport default function() {\n  if (typeof arguments[0].ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  return mu(1, arguments[0].ampSpectrum);\n}\n","export default function() {\n  if (typeof arguments[0].ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  var numerator = 0;\n  var denominator = 0;\n  for (var i = 0; i < arguments[0].ampSpectrum.length; i++) {\n    numerator += Math.log(arguments[0].ampSpectrum[i]);\n    denominator += arguments[0].ampSpectrum[i];\n  }\n\n  return Math.exp(numerator / arguments[0].ampSpectrum.length) *\n      arguments[0].ampSpectrum.length / denominator;\n}\n","export default function(args) {\n  if (typeof args.signal !== 'object' ||\n  typeof args.previousSignal != 'object'\n\t\t) {\n    throw new TypeError();\n  }\n\n  let sf = 0;\n  for (let i = -(args.bufferSize / 2); i < signal.length / 2 - 1; i++) {\n    x = Math.abs(args.signal[i]) - Math.abs(args.previousSignal[i]);\n    sf += (x + Math.abs(x)) / 2;\n  }\n\n  return sf;\n}\n","import {mu} from './extractorUtilities';\n\nexport default function() {\n  if (typeof arguments[0].ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  var ampspec = arguments[0].ampSpectrum;\n  var mu1 = mu(1, ampspec);\n  var mu2 = mu(2, ampspec);\n  var mu3 = mu(3, ampspec);\n  var mu4 = mu(4, ampspec);\n  var numerator = -3 * Math.pow(mu1, 4) + 6 * mu1 * mu2 - 4 * mu1 * mu3 + mu4;\n  var denominator = Math.pow(Math.sqrt(mu2 - Math.pow(mu1, 2)), 4);\n  return numerator / denominator;\n}\n","export default function() {\n  if (typeof arguments[0].ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  var ampspec = arguments[0].ampSpectrum;\n\n  //calculate nyquist bin\n  var nyqBin = arguments[0].sampleRate / (2 * (ampspec.length - 1));\n  var ec = 0;\n  for (var i = 0; i < ampspec.length; i++) {\n    ec += ampspec[i];\n  }\n\n  var threshold = 0.99 * ec;\n  var n = ampspec.length - 1;\n  while (ec > threshold && n >= 0) {\n    ec -= ampspec[n];\n    --n;\n  }\n\n  return (n + 1) * nyqBin;\n}\n","import {mu} from './extractorUtilities';\n\nexport default function(args) {\n  if (typeof args.ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  var mu1 = mu(1, args.ampSpectrum);\n  var mu2 = mu(2, args.ampSpectrum);\n  var mu3 = mu(3, args.ampSpectrum);\n  var numerator = 2 * Math.pow(mu1, 3) - 3 * mu1 * mu2 + mu3;\n  var denominator = Math.pow(Math.sqrt(mu2 - Math.pow(mu1, 2)), 3);\n  return numerator / denominator;\n}\n","export default function(args) {\n  if (typeof args.ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  //linear regression\n  let ampSum = 0;\n  let freqSum = 0;\n  let freqs = new Float32Array(args.ampSpectrum.length);\n  let powFreqSum = 0;\n  let ampFreqSum = 0;\n\n  for (var i = 0; i < args.ampSpectrum.length; i++) {\n    ampSum += args.ampSpectrum[i];\n    let curFreq = i * args.sampleRate / args.bufferSize;\n    freqs[i] = curFreq;\n    powFreqSum += curFreq * curFreq;\n    freqSum += curFreq;\n    ampFreqSum += curFreq * args.ampSpectrum[i];\n  }\n\n  return (args.ampSpectrum.length * ampFreqSum - freqSum * ampSum) / (ampSum * (\n        powFreqSum - Math.pow(freqSum, 2)));\n}\n","import {mu} from './extractorUtilities';\n\nexport default function(args) {\n  if (typeof args.ampSpectrum !== 'object') {\n    throw new TypeError();\n  }\n\n  return Math.sqrt(mu(2, args.ampSpectrum) -\n         Math.pow(mu(1, args.ampSpectrum), 2));\n}\n","export default function() {\n  if (typeof arguments[0].signal !== 'object') {\n    throw new TypeError();\n  }\n\n  var zcr = 0;\n  for (var i = 0; i < arguments[0].signal.length; i++) {\n    if ((arguments[0].signal[i] >= 0 && arguments[0].signal[i + 1] < 0) ||\n         (arguments[0].signal[i] < 0 && arguments[0].signal[i + 1] >= 0)) {\n      zcr++;\n    }\n  }\n\n  return zcr;\n}\n","import rms from './extractors/rms';\nimport energy from './extractors/energy';\nimport spectralSlope from './extractors/spectralSlope';\nimport spectralCentroid from './extractors/spectralCentroid';\nimport spectralRolloff from './extractors/spectralRolloff';\nimport spectralFlatness from './extractors/spectralFlatness';\nimport spectralSpread from './extractors/spectralSpread';\nimport spectralSkewness from './extractors/spectralSkewness';\nimport spectralKurtosis from './extractors/spectralKurtosis';\nimport zcr from './extractors/zcr';\nimport loudness from './extractors/loudness';\nimport perceptualSpread from './extractors/perceptualSpread';\nimport perceptualSharpness from './extractors/perceptualSharpness';\nimport mfcc from './extractors/mfcc';\nimport chroma from './extractors/chroma';\nimport powerSpectrum from './extractors/powerSpectrum';\nimport spectralFlux from './extractors/spectralFlux';\n\nlet buffer = function(args) {\n  return args.signal;\n};\n\nlet complexSpectrum = function (args) {\n  return args.complexSpectrum;\n};\n\nlet amplitudeSpectrum = function (args) {\n  return args.ampSpectrum;\n};\n\nexport {\n  buffer,\n  rms,\n  energy,\n  complexSpectrum,\n\n  spectralSlope,\n  spectralCentroid,\n  spectralRolloff,\n  spectralFlatness,\n  spectralSpread,\n  spectralSkewness,\n  spectralKurtosis,\n  amplitudeSpectrum,\n\n  zcr,\n  loudness,\n  perceptualSpread,\n  perceptualSharpness,\n  powerSpectrum,\n  mfcc,\n  chroma,\n  spectralFlux\n};\n","module.exports = require('./main').default;","import * as utilities from './utilities';\nimport * as extractors from './featureExtractors';\nimport {fft, ifft} from 'fftjs';\nimport {MeydaAnalyzer} from './meyda-wa';\n\n/**\n * Meyda Module\n * @module meyda\n */\n\n/**\n * Options for constructing a MeydaAnalyzer\n * @typedef {Object} MeydaOptions\n * @property {AudioContext} audioContext - The Audio Context for the MeydaAnalyzer to operate in.\n * @property {AudioNode} source - The Audio Node for Meyda to listen to.\n * @property {number} [bufferSize] - The size of the buffer.\n * @property {number} [hopSize] - The hop size between buffers.\n * @property {number} [sampleRate] - The number of samples per second in the audio context.\n * @property {Function} [callback] - A function to receive the frames of audio features\n * @property {string} [windowingFunction] - The Windowing Function to apply to the signal before transformation to the frequency domain\n * @property {string|Array.<string>} [featureExtractors] - Specify the feature extractors you want to run on the audio.\n * @property {boolean} [startImmediately] - Pass `true` to start feature extraction immediately\n */\n\n /**\n  * Web Audio context\n  * Either an {@link AudioContext|https://developer.mozilla.org/en-US/docs/Web/API/AudioContext}\n  * or an {@link OfflineAudioContext|https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext}\n  * @typedef {Object} AudioContext\n  */\n\n/**\n * AudioNode\n * A Web AudioNode\n * @typedef {Object} AudioNode\n */\n\n/**\n * ScriptProcessorNode\n * A Web Audio ScriptProcessorNode\n * @typedef {Object} ScriptProcessorNode\n */\n\n/**\n * @class Meyda\n * @hideconstructor\n * @classdesc\n * The schema for the default export of the Meyda library.\n * @example\n * var Meyda = require('meyda');\n */\nvar Meyda = {\n  /**\n   * Meyda stores a reference to the relevant audio context here for use inside\n   * the Web Audio API.\n   * @instance\n   * @member {AudioContext}\n   */\n  audioContext: null,\n  /**\n   * Meyda keeps an internal ScriptProcessorNode in which it runs audio feature\n   * extraction. The ScriptProcessorNode is stored in this member variable.\n   * @instance\n   * @member {ScriptProcessorNode}\n   */\n  spn: null,\n  /**\n   * The length of each buffer that Meyda will extract audio on. When recieving\n   * input via the Web Audio API, the Script Processor Node chunks incoming audio\n   * into arrays of this length. Longer buffers allow for more precision in the\n   * frequency domain, but increase the amount of time it takes for Meyda to\n   * output a set of audio features for the buffer. You can calculate how many\n   * sets of audio features Meyda will output per second by dividing the\n   * buffer size by the sample rate. If you're using Meyda for visualisation,\n   * make sure that you're collecting audio features at a rate that's faster\n   * than or equal to the video frame rate you expect.\n   * @instance\n   * @member {number}\n   */\n  bufferSize: 512,\n  /**\n   * The number of samples per second of the incoming audio. This affects\n   * feature extraction outside of the context of the Web Audio API, and must be\n   * set accurately - otherwise calculations will be off.\n   * @instance\n   * @member {number}\n   */\n  sampleRate: 44100,\n  /**\n   * The number of Mel bands to use in the Mel Frequency Cepstral Co-efficients\n   * feature extractor\n   * @instance\n   * @member {number}\n   */\n  melBands: 26,\n  /**\n   * The number of bands to divide the spectrum into for the Chroma feature\n   * extractor. 12 is the standard number of semitones per octave in the western\n   * music tradition, but Meyda can use an arbitrary number of bands, which\n   * can be useful for microtonal music.\n   * @instance\n   * @member {number}\n   */\n  chromaBands: 12,\n  /**\n   * A function you can provide that will be called for each buffer that Meyda\n   * receives from its source node\n   * @instance\n   * @member {Function}\n   */\n  callback: null,\n  /**\n   * Specify the windowing function to apply to the buffer before the\n   * transformation from the time domain to the frequency domain is performed\n   * @instance\n   * @member {string}\n   */\n  windowingFunction: 'hanning',\n  /**\n   * @member {object}\n   */\n  featureExtractors: extractors,\n  EXTRACTION_STARTED: false,\n  numberOfMFCCCoefficients: 13,\n  _featuresToExtract: [],\n  windowing: utilities.applyWindow,\n  _errors: {\n    notPow2: new Error(\n        'Meyda: Buffer size must be a power of 2, e.g. 64 or 512'),\n    featureUndef: new Error('Meyda: No features defined.'),\n    invalidFeatureFmt: new Error('Meyda: Invalid feature format'),\n    invalidInput: new Error('Meyda: Invalid input.'),\n    noAC: new Error('Meyda: No AudioContext specified.'),\n    noSource: new Error('Meyda: No source node specified.'),\n  },\n\n  /**\n   * @summary\n   * Create a MeydaAnalyzer\n   *\n   * A factory function for creating a MeydaAnalyzer, the interface for using\n   * Meyda in the context of Web Audio.\n   *\n   * @method\n   * @param {MeydaOptions} options Options - an object containing configuration\n   * @returns {MeydaAnalyzer}\n   * @example\n   * const analyzer = Meyda.createMeydaAnalyzer({\n   *   \"audioContext\": audioContext,\n   *   \"source\": source,\n   *   \"bufferSize\": 512,\n   *   \"featureExtractors\": [\"rms\"],\n   *   \"inputs\": 2,\n   *   \"callback\": features => {\n   *     levelRangeElement.value = features.rms;\n   *   }\n   * });\n   */\n  createMeydaAnalyzer: function (options) {\n    return new MeydaAnalyzer(options, Meyda);\n  },\n\n  /**\n   * Extract an audio feature from a buffer\n   * @function\n   * @param {(string|Array.<string>)} feature - the feature you want to extract\n   * @param {Array.<number>} signal\n   * An array of numbers that represents the signal. It should be of length\n   * `meyda.bufferSize`\n   * @param {Array.<number>} [previousSignal] - the previous buffer\n   * @returns {object} Features\n   * @example\n   * meyda.bufferSize = 2048;\n   * const features = meyda.extract(['zcr', 'spectralCentroid'], signal);\n   */\n  extract: function (feature, signal, previousSignal) {\n    if (!signal)\n        throw this._errors.invalidInput;\n    else if (typeof signal != 'object')\n        throw this._errors.invalidInput;\n    else if (!feature)\n        throw this._errors.featureUndef;\n    else if (!utilities.isPowerOfTwo(signal.length))\n        throw this._errors.notPow2;\n\n    if (typeof this.barkScale == 'undefined' ||\n            this.barkScale.length != this.bufferSize) {\n      this.barkScale = utilities.createBarkScale(\n          this.bufferSize,\n          this.sampleRate,\n          this.bufferSize\n      );\n    }\n\n    // Recalculate mel bank if buffer length changed\n    if (typeof this.melFilterBank == 'undefined' ||\n            this.barkScale.length != this.bufferSize ||\n            this.melFilterBank.length != this.melBands) {\n      this.melFilterBank = utilities.createMelFilterBank(\n          Math.max(this.melBands, this.numberOfMFCCCoefficients),\n          this.sampleRate,\n          this.bufferSize);\n    }\n\n    // Recalculate chroma bank if buffer length changed\n    if (typeof this.chromaFilterBank == 'undefined' ||\n            this.chromaFilterBank.length != this.chromaBands) {\n      this.chromaFilterBank = utilities.createChromaFilterBank(\n          this.chromaBands,\n          this.sampleRate,\n          this.bufferSize);\n    }\n\n    if (typeof signal.buffer == 'undefined') {\n      //signal is a normal array, convert to F32A\n      this.signal = utilities.arrayToTyped(signal);\n    } else {\n      this.signal = signal;\n    }\n\n    let preparedSignal = prepareSignalWithSpectrum(\n            signal,\n            this.windowingFunction,\n            this.bufferSize);\n\n    this.signal = preparedSignal.windowedSignal;\n    this.complexSpectrum = preparedSignal.complexSpectrum;\n    this.ampSpectrum = preparedSignal.ampSpectrum;\n\n    if (previousSignal) {\n      let preparedSignal = prepareSignalWithSpectrum(previousSignal,\n              this.windowingFunction,\n              this.bufferSize);\n\n      this.previousSignal = preparedSignal.windowedSignal;\n      this.previousComplexSpectrum = preparedSignal.complexSpectrum;\n      this.previousAmpSpectrum = preparedSignal.ampSpectrum;\n    }\n\n    const extract = (feature) => {\n      return this.featureExtractors[feature]({\n        ampSpectrum:this.ampSpectrum,\n        chromaFilterBank: this.chromaFilterBank,\n        complexSpectrum:this.complexSpectrum,\n        signal:this.signal,\n        bufferSize:this.bufferSize,\n        sampleRate:this.sampleRate,\n        barkScale:this.barkScale,\n        melFilterBank:this.melFilterBank,\n        previousSignal:this.previousSignal,\n        previousAmpSpectrum:this.previousAmpSpectrum,\n        previousComplexSpectrum:this.previousComplexSpectrum,\n        numberOfMFCCCoefficients:this.numberOfMFCCCoefficients,\n      });\n    };\n\n    if (typeof feature === 'object') {\n      return feature.reduce((acc, el) =>\n        Object.assign({}, acc, {\n          [el]: extract(el),\n        }), {});\n    } else if (typeof feature === 'string') {\n      return extract(feature);\n    } else {\n      throw this._errors.invalidFeatureFmt;\n    }\n  },\n};\n\nvar prepareSignalWithSpectrum = function (signal,\n  windowingFunction,\n  bufferSize) {\n  var preparedSignal = {};\n\n  if (typeof signal.buffer == 'undefined') {\n    //signal is a normal array, convert to F32A\n    preparedSignal.signal = utilities.arrayToTyped(signal);\n  }  else {\n    preparedSignal.signal = signal;\n  }\n\n  preparedSignal.windowedSignal = utilities.applyWindow(\n    preparedSignal.signal,\n    windowingFunction);\n\n  preparedSignal.complexSpectrum = fft(preparedSignal.windowedSignal);\n  preparedSignal.ampSpectrum = new Float32Array(bufferSize / 2);\n  for (var i = 0; i < bufferSize / 2; i++) {\n    preparedSignal.ampSpectrum[i] = Math.sqrt(\n      Math.pow(preparedSignal.complexSpectrum.real[i], 2) +\n      Math.pow(preparedSignal.complexSpectrum.imag[i], 2));\n  }\n\n  return preparedSignal;\n};\n\n/**\n * The Meyda class\n * @type {Meyda}\n */\nexport default Meyda;\n\nif (typeof window !== 'undefined') window.Meyda = Meyda;\n","import * as utilities from './utilities';\nimport * as featureExtractors from './featureExtractors';\n\n/**\n  * MeydaAnalyzer\n  * @classdesc\n  * Meyda's interface to the Web Audio API. MeydaAnalyzer abstracts an API on\n  * top of the Web Audio API's ScriptProcessorNode, running the Meyda audio\n  * feature extractors inside that context.\n  *\n  * MeydaAnalyzer's constructor should not be called directly - MeydaAnalyzer\n  * objects should be generated using the {@link Meyda.createMeydaAnalyzer}\n  * factory function in the main Meyda class.\n  *\n  * @example\n  * const analyzer = Meyda.createMeydaAnalyzer({\n  *   \"audioContext\": audioContext,\n  *   \"source\": source,\n  *   \"bufferSize\": 512,\n  *   \"featureExtractors\": [\"rms\"],\n  *   \"inputs\": 2,\n  *   \"callback\": features => {\n  *     levelRangeElement.value = features.rms;\n  *   }\n  * });\n  * @hideconstructor\n  */\nexport class MeydaAnalyzer {\n  constructor(options, _this) {\n    this._m = _this;\n    if (!options.audioContext) {\n      throw this._m.errors.noAC;\n    }\n    else if (options.bufferSize &&\n      !utilities.isPowerOfTwo(options.bufferSize)) {\n      throw this._m._errors.notPow2;\n    }\n    else if (!options.source) {\n      throw this._m._errors.noSource;\n    }\n\n    this._m.audioContext = options.audioContext;\n\n    // TODO: validate options\n    this._m.bufferSize = options.bufferSize || this._m.bufferSize || 256;\n    this._m.hopSize = options.hopSize || this._m.hopSize || this._m.bufferSize;\n    this._m.sampleRate = options.sampleRate\n      || this._m.audioContext.sampleRate || 44100;\n    this._m.callback = options.callback;\n    this._m.windowingFunction = options.windowingFunction || 'hanning';\n    this._m.featureExtractors = featureExtractors;\n    this._m.EXTRACTION_STARTED = options.startImmediately || false;\n\n    //create nodes\n    this._m.spn = this._m.audioContext.createScriptProcessor(\n      this._m.bufferSize, 1, 1);\n    this._m.spn.connect(this._m.audioContext.destination);\n\n    this._m._featuresToExtract = options.featureExtractors || [];\n\n    //always recalculate BS and MFB when a new Meyda analyzer is created.\n    this._m.barkScale = utilities.createBarkScale(\n      this._m.bufferSize,\n      this._m.sampleRate,\n      this._m.bufferSize);\n    this._m.melFilterBank = utilities.createMelFilterBank(\n      this._m.melBands,\n      this._m.sampleRate,\n      this._m.bufferSize);\n\n    this._m.inputData = null;\n    this._m.previousInputData = null;\n\n    this._m.frame = null;\n    this._m.previousFrame = null;\n\n    this.setSource(options.source);\n\n    this._m.spn.onaudioprocess = (e)=> {\n      if (this._m.inputData !== null) {\n        this._m.previousInputData = this._m.inputData;\n      }\n\n      this._m.inputData = e.inputBuffer.getChannelData(0);\n\n      if (!this._m.previousInputData) {\n        var buffer = this._m.inputData;\n      } else  {\n        var buffer = new Float32Array(this._m.previousInputData.length + this._m.inputData.length - this._m.hopSize);\n        buffer.set(this._m.previousInputData.slice(this._m.hopSize));\n        buffer.set(this._m.inputData, this._m.previousInputData.length - this._m.hopSize);\n      };\n\n      var frames = utilities.frame(buffer, this._m.bufferSize, this._m.hopSize);\n\n      frames.forEach(f => {\n        this._m.frame = f;\n\n        var features = this._m.extract(\n          this._m._featuresToExtract,\n          this._m.frame,\n          this._m.previousFrame);\n\n        // call callback if applicable\n        if (typeof this._m.callback === 'function' && this._m.EXTRACTION_STARTED) {\n          this._m.callback(features);\n        }\n\n        this._m.previousFrame = this._m.frame;\n      });\n    };\n  }\n\n  /**\n   * Start feature extraction\n   * The audio features will be passed to the callback function that was defined\n   * in the MeydaOptions that were passed to the factory when constructing the\n   * MeydaAnalyzer.\n   * @param {(string|Array.<string>)} [features]\n   * Change the features that Meyda is extracting. Defaults to the features that\n   * were set upon construction in the options parameter.\n   * @example\n   * analyzer.start('chroma');\n   */\n  start(features) {\n    this._m._featuresToExtract = features || this._m._featuresToExtract;\n    this._m.EXTRACTION_STARTED = true;\n  }\n\n  /**\n   * Stop feature extraction.\n   * @example\n   * analyzer.stop();\n   */\n  stop() {\n    this._m.EXTRACTION_STARTED = false;\n  }\n\n  /**\n   * Set the Audio Node for Meyda to listen to.\n   * @param {AudioNode} source - The Audio Node for Meyda to listen to\n   * @example\n   * analyzer.setSource(audioSourceNode);\n   */\n  setSource(source) {\n    source.connect(this._m.spn);\n  }\n\n  /**\n   * Get a set of features from the current frame.\n   * @param {(string|Array.<string>)} [features]\n   * Change the features that Meyda is extracting\n   * @example\n   * analyzer.get('spectralFlatness');\n   */\n  get(features) {\n    if (this._m.inputData) {\n      return this._m.extract(\n              (features || this._m._featuresToExtract),\n              this._m.inputData,\n              this._m.previousInputData);\n    } else {\n      return null;\n    }\n  }\n}\n","import * as windowing from './windowing';\n\nlet windows = {};\n\nexport function isPowerOfTwo(num) {\n  while (((num % 2) === 0) && num > 1) {\n    num /= 2;\n  }\n\n  return (num === 1);\n}\n\nexport function error(message) {\n  throw new Error('Meyda: ' + message);\n}\n\nexport function pointwiseBufferMult(a, b) {\n  let c = [];\n  for (let i = 0; i < Math.min(a.length, b.length); i++) {\n    c[i] = a[i] * b[i];\n  }\n\n  return c;\n}\n\nexport function applyWindow(signal, windowname) {\n  if (windowname !== 'rect') {\n    if (windowname === '' || !windowname) windowname = 'hanning';\n    if (!windows[windowname]) windows[windowname] = {};\n\n    if (!windows[windowname][signal.length]) {\n      try {\n        windows[windowname][signal.length] = windowing[windowname](\n                    signal.length\n                );\n      }\n      catch (e) {\n        throw new Error('Invalid windowing function');\n      }\n    }\n\n    signal = pointwiseBufferMult(signal, windows[windowname][signal.length]);\n  }\n\n  return signal;\n}\n\nexport function createBarkScale(length, sampleRate, bufferSize) {\n  let barkScale = new Float32Array(length);\n\n  for (var i = 0; i < barkScale.length; i++) {\n    barkScale[i] = i * sampleRate / (bufferSize);\n    barkScale[i] = 13 * Math.atan(barkScale[i] / 1315.8) +\n            3.5 * Math.atan(Math.pow((barkScale[i] / 7518), 2));\n  }\n\n  return barkScale;\n}\n\nexport function typedToArray(t) {\n  // utility to convert typed arrays to normal arrays\n  return Array.prototype.slice.call(t);\n}\n\nexport function arrayToTyped(t) {\n  // utility to convert arrays to typed F32 arrays\n  return Float32Array.from(t);\n}\n\nexport function _normalize(num, range) {\n  return num / range;\n}\n\nexport function normalize(a, range) {\n  return a.map(function (n) { return _normalize(n, range); });\n}\n\nexport function normalizeToOne(a) {\n  var max = Math.max.apply(null, a);\n\n  return a.map(function (n) {\n    return n / max;\n  });\n}\n\nexport function mean(a) {\n  return a.reduce(function (prev, cur) {  return prev + cur;  }) / a.length;\n}\n\nfunction _melToFreq(melValue) {\n  var freqValue = 700 * (Math.exp(melValue / 1125) - 1);\n  return freqValue;\n}\n\nfunction _freqToMel(freqValue) {\n  var melValue = 1125 * Math.log(1 + (freqValue / 700));\n  return melValue;\n}\n\nexport function melToFreq(mV) { return _melToFreq(mV); }\n\nexport function freqToMel(fV) { return _freqToMel(fV); }\n\nexport function createMelFilterBank(numFilters, sampleRate, bufferSize) {\n  //the +2 is the upper and lower limits\n  let melValues = new Float32Array(numFilters + 2);\n  let melValuesInFreq = new Float32Array(numFilters + 2);\n\n  //Generate limits in Hz - from 0 to the nyquist.\n  let lowerLimitFreq = 0;\n  let upperLimitFreq = sampleRate / 2;\n\n  //Convert the limits to Mel\n  let lowerLimitMel = _freqToMel(lowerLimitFreq);\n  let upperLimitMel = _freqToMel(upperLimitFreq);\n\n  //Find the range\n  let range = upperLimitMel - lowerLimitMel;\n\n  //Find the range as part of the linear interpolation\n  let valueToAdd = range / (numFilters + 1);\n\n  let fftBinsOfFreq = Array(numFilters + 2);\n\n  for (let i = 0; i < melValues.length; i++) {\n    // Initialising the mel frequencies\n    // They're a linear interpolation between the lower and upper limits.\n    melValues[i] = i * valueToAdd;\n\n    // Convert back to Hz\n    melValuesInFreq[i] = _melToFreq(melValues[i]);\n\n    // Find the corresponding bins\n    fftBinsOfFreq[i] = Math.floor((bufferSize + 1) *\n                           melValuesInFreq[i] / sampleRate);\n  }\n\n  var filterBank = Array(numFilters);\n  for (let j = 0; j < filterBank.length; j++) {\n    // Create a two dimensional array of size numFilters * (buffersize/2)+1\n    // pre-populating the arrays with 0s.\n    filterBank[j] = Array.apply(\n            null,\n            new Array((bufferSize / 2) + 1)).map(Number.prototype.valueOf, 0);\n\n    //creating the lower and upper slopes for each bin\n    for (let i = fftBinsOfFreq[j]; i < fftBinsOfFreq[j + 1]; i++) {\n      filterBank[j][i] = (i - fftBinsOfFreq[j]) /\n                (fftBinsOfFreq[j + 1] - fftBinsOfFreq[j]);\n    }\n\n    for (let i = fftBinsOfFreq[j + 1]; i < fftBinsOfFreq[j + 2]; i++) {\n      filterBank[j][i] = (fftBinsOfFreq[j + 2] - i) /\n                (fftBinsOfFreq[j + 2] - fftBinsOfFreq[j + 1]);\n    }\n  }\n\n  return filterBank;\n}\n\nexport function hzToOctaves(freq, A440) {\n  return Math.log2(16 * freq / A440);\n}\n\nexport function normalizeByColumn (a) {\n  var emptyRow = a[0].map(() => 0);\n  var colDenominators = a.reduce((acc, row) => {\n    row.forEach((cell, j) => {\n      acc[j] += Math.pow(cell, 2);\n    });\n    return acc;\n  }, emptyRow).map(Math.sqrt);\n  return a.map((row, i) => row.map((v, j) => v / (colDenominators[j] || 1) ));\n};\n\nexport function createChromaFilterBank(numFilters, sampleRate, bufferSize, centerOctave=5, octaveWidth=2, baseC=true, A440=440) {\n  var numOutputBins = Math.floor(bufferSize / 2) + 1;\n\n\n  var frequencyBins = new Array(bufferSize).fill(0)\n    .map((_, i) => numFilters * hzToOctaves(sampleRate * i / bufferSize, A440));\n\n  // Set a value for the 0 Hz bin that is 1.5 octaves below bin 1\n  // (so chroma is 50% rotated from bin 1, and bin width is broad)\n  frequencyBins[0] = frequencyBins[1] - 1.5 * numFilters;\n\n  var binWidthBins = frequencyBins\n    .slice(1)\n    .map((v, i) => Math.max(v - frequencyBins[i]), 1)\n    .concat([1]);\n\n  var halfNumFilters = Math.round(numFilters / 2);\n\n  var filterPeaks = new Array(numFilters).fill(0)\n    .map((_, i) => frequencyBins.map(frq =>\n      ((10 * numFilters + halfNumFilters + frq - i) % numFilters) - halfNumFilters\n    ));\n\n  var weights = filterPeaks.map((row, i) => row.map((_, j) => (\n    Math.exp(-0.5 * Math.pow(2 * filterPeaks[i][j] / binWidthBins[j], 2))\n  )));\n\n  weights = normalizeByColumn(weights);\n\n  if (octaveWidth) {\n    var octaveWeights = frequencyBins.map(v =>\n      Math.exp(-0.5 * Math.pow((v / numFilters - centerOctave) / octaveWidth, 2))\n    );\n    weights = weights.map(row => row.map((cell, j) => cell * octaveWeights[j]));\n  }\n\n  if (baseC) {\n    weights = [...weights.slice(3), ...weights.slice(0, 3)];\n  }\n\n  return weights.map(row => row.slice(0, numOutputBins));\n}\n\nexport function frame(buffer, frameLength, hopLength) {\n  if (buffer.length < frameLength) {\n    throw new Error('Buffer is too short for frame length');\n  }\n  if (hopLength < 1) {\n    throw new Error('Hop length cannot be less that 1');\n  }\n  if (frameLength < 1) {\n    throw new Error('Frame length cannot be less that 1');\n  }\n\n  const numFrames = 1 + Math.floor((buffer.length - frameLength) / hopLength);\n\n  return new Array(numFrames).fill(0).map((_, i) =>\n    buffer.slice(i * hopLength, (i * hopLength) + frameLength));\n}\n","export function blackman(size) {\n  let blackmanBuffer = new Float32Array(size);\n  let coeff1 = 2 * Math.PI / (size - 1);\n  let coeff2 = 2 * coeff1;\n\n  //According to http://uk.mathworks.com/help/signal/ref/blackman.html\n  //first half of the window\n  for (let i = 0; i < size / 2; i++) {\n    blackmanBuffer[i] = 0.42 - 0.5 * Math.cos(i * coeff1) +\n            0.08 * Math.cos(i * coeff2);\n  }\n\n  //second half of the window\n  for (let i = size / 2; i > 0; i--) {\n    blackmanBuffer[size - i] = blackmanBuffer[i - 1];\n  }\n\n  return blackmanBuffer;\n}\n\nexport function sine(size) {\n  let coeff = Math.PI / (size - 1);\n  let sineBuffer = new Float32Array(size);\n\n  for (let i = 0; i < size; i++) {\n    sineBuffer[i] = Math.sin(coeff * i);\n  }\n\n  return sineBuffer;\n}\n\nexport function hanning(size) {\n  let hanningBuffer = new Float32Array(size);\n  for (let i = 0; i < size; i++) {\n    // According to the R documentation\n    // http://ugrad.stat.ubc.ca/R/library/e1071/html/hanning.window.html\n    hanningBuffer[i] = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / (size - 1));\n  }\n\n  return hanningBuffer;\n}\n\nexport function hamming(size) {\n  let hammingBuffer = new Float32Array(size);\n  for (let i = 0; i < size; i++) {\n    //According to http://uk.mathworks.com/help/signal/ref/hamming.html\n    hammingBuffer[i] = 0.54 - 0.46 * Math.cos(2 * Math.PI * (i / size - 1));\n  }\n\n  return hammingBuffer;\n}\n"],"sourceRoot":""}