source: trip-planner-front/node_modules/hdr-histogram-js/dist/hdrhistogram.umd.js@ 6a3a178

!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("pako")):"function"==typeof define&&define.amd?define(["exports","pako"],e):e((t=t||self).hdr={},t.pako)}(this,(function(exports,pako){"use strict";const{pow:pow,floor:floor}=Math,TWO_POW_32=pow(2,32);class ByteBuffer{constructor(t){this.position=0,this.data=t,this.int32ArrayForConvert=new Uint32Array(1),this.int8ArrayForConvert=new Uint8Array(this.int32ArrayForConvert.buffer)}static allocate(t=16){return new ByteBuffer(new Uint8Array(t))}put(t){if(this.position===this.data.length){const t=this.data;this.data=new Uint8Array(2*this.data.length),this.data.set(t)}this.data[this.position]=t,this.position++}putInt32(t){if(this.data.length-this.position<4){const t=this.data;this.data=new Uint8Array(2*this.data.length+4),this.data.set(t)}this.int32ArrayForConvert[0]=t,this.data.set(this.int8ArrayForConvert.reverse(),this.position),this.position+=4}putInt64(t){this.putInt32(floor(t/TWO_POW_32)),this.putInt32(t)}putArray(t){if(this.data.length-this.position<t.byteLength){const e=this.data;this.data=new Uint8Array(this.position+t.byteLength),this.data.set(e)}this.data.set(t,this.position),this.position+=t.byteLength}get(){const t=this.data[this.position];return this.position++,t}getInt32(){this.int8ArrayForConvert.set(this.data.slice(this.position,this.position+4).reverse());const t=this.int32ArrayForConvert[0];return this.position+=4,t}getInt64(){const t=this.getInt32(),e=this.getInt32();return t*TWO_POW_32+e}resetPosition(){this.position=0}}class HistogramIterationValue{constructor(){this.reset()}reset(){this.valueIteratedTo=0,this.valueIteratedFrom=0,this.countAtValueIteratedTo=0,this.countAddedInThisIterationStep=0,this.totalCountToThisValue=0,this.totalValueToThisValue=0,this.percentile=0,this.percentileLevelIteratedTo=0}}class JsHistogramIterator{constructor(){this.currentIterationValue=new HistogramIterationValue}resetIterator(t){this.histogram=t,this.savedHistogramTotalRawCount=t.totalCount,this.arrayTotalCount=t.totalCount,this.currentIndex=0,this.currentValueAtIndex=0,this.nextValueAtIndex=Math.pow(2,t.unitMagnitude),this.prevValueIteratedTo=0,this.totalCountToPrevIndex=0,this.totalCountToCurrentIndex=0,this.totalValueToCurrentIndex=0,this.countAtThisValue=0,this.freshSubBucket=!0,this.currentIterationValue.reset()}hasNext(){if(this.histogram.totalCount!==this.savedHistogramTotalRawCount)throw"Concurrent Modification Exception";return this.totalCountToCurrentIndex<this.arrayTotalCount}next(){for(;!this.exhaustedSubBuckets();){if(this.countAtThisValue=this.histogram.getCountAtIndex(this.currentIndex),this.freshSubBucket&&(this.totalCountToCurrentIndex+=this.countAtThisValue,this.totalValueToCurrentIndex+=this.countAtThisValue*this.histogram.highestEquivalentValue(this.currentValueAtIndex),this.freshSubBucket=!1),this.reachedIterationLevel()){const t=this.getValueIteratedTo();if(Object.assign(this.currentIterationValue,{valueIteratedTo:t,valueIteratedFrom:this.prevValueIteratedTo,countAtValueIteratedTo:this.countAtThisValue,countAddedInThisIterationStep:this.totalCountToCurrentIndex-this.totalCountToPrevIndex,totalCountToThisValue:this.totalCountToCurrentIndex,totalValueToThisValue:this.totalValueToCurrentIndex,percentile:100*this.totalCountToCurrentIndex/this.arrayTotalCount,percentileLevelIteratedTo:this.getPercentileIteratedTo()}),this.prevValueIteratedTo=t,this.totalCountToPrevIndex=this.totalCountToCurrentIndex,this.incrementIterationLevel(),this.histogram.totalCount!==this.savedHistogramTotalRawCount)throw new Error("Concurrent Modification Exception");return this.currentIterationValue}this.incrementSubBucket()}throw new Error("Index Out Of Bounds Exception")}getPercentileIteratedTo(){return 100*this.totalCountToCurrentIndex/this.arrayTotalCount}getPercentileIteratedFrom(){return 100*this.totalCountToPrevIndex/this.arrayTotalCount}getValueIteratedTo(){return this.histogram.highestEquivalentValue(this.currentValueAtIndex)}exhaustedSubBuckets(){return this.currentIndex>=this.histogram.countsArrayLength}incrementSubBucket(){this.freshSubBucket=!0,this.currentIndex++,this.currentValueAtIndex=this.histogram.valueFromIndex(this.currentIndex),this.nextValueAtIndex=this.histogram.valueFromIndex(this.currentIndex+1)}}class RecordedValuesIterator extends JsHistogramIterator{constructor(t){super(),this.doReset(t)}reset(){this.doReset(this.histogram)}doReset(t){super.resetIterator(t),this.visitedIndex=-1}incrementIterationLevel(){this.visitedIndex=this.currentIndex}reachedIterationLevel(){return 0!=this.histogram.getCountAtIndex(this.currentIndex)&&this.visitedIndex!==this.currentIndex}}const{pow:pow$1,floor:floor$1,log2:log2}=Math;class PercentileIterator extends JsHistogramIterator{constructor(t,e){super(),this.percentileTicksPerHalfDistance=0,this.percentileLevelToIterateTo=0,this.percentileLevelToIterateFrom=0,this.reachedLastRecordedValue=!1,this.doReset(t,e)}reset(t){this.doReset(this.histogram,t)}doReset(t,e){super.resetIterator(t),this.percentileTicksPerHalfDistance=e,this.percentileLevelToIterateTo=0,this.percentileLevelToIterateFrom=0,this.reachedLastRecordedValue=!1}hasNext(){return!!super.hasNext()||!this.reachedLastRecordedValue&&this.arrayTotalCount>0&&(this.percentileLevelToIterateTo=100,this.reachedLastRecordedValue=!0,!0)}incrementIterationLevel(){this.percentileLevelToIterateFrom=this.percentileLevelToIterateTo;const t=this.percentileTicksPerHalfDistance*pow$1(2,floor$1(log2(100/(100-this.percentileLevelToIterateTo)))+1);this.percentileLevelToIterateTo+=100/t}reachedIterationLevel(){if(0===this.countAtThisValue)return!1;return 100*this.totalCountToCurrentIndex/this.arrayTotalCount>=this.percentileLevelToIterateTo}getPercentileIteratedTo(){return this.percentileLevelToIterateTo}getPercentileIteratedFrom(){return this.percentileLevelToIterateFrom}}const leftPadding=t=>e=>e.length<t?" ".repeat(t-e.length)+e:e,integerFormatter=t=>{const e=leftPadding(t);return t=>e(""+t)},{floor:floor$2,log10:log10,pow:pow$2}=Math,numberOfDigits=t=>floor$2(log10(t)+1),keepSignificantDigits=t=>e=>{const r=numberOfDigits(e);if(r>t){return e-e%pow$2(10,r-t)}return e},floatFormatter=(t,e)=>{const r=new Intl.NumberFormat("en-US",{maximumFractionDigits:e,minimumFractionDigits:e,useGrouping:!1}),n=leftPadding(t);return t=>n(r.format(t))},ulp=t=>Math.pow(2,Math.floor(Math.log2(t))-52),NO_TAG="NO TAG",toSummary=t=>{const{totalCount:e,maxValue:r,numberOfSignificantValueDigits:n}=t,i=keepSignificantDigits(n);return{p50:i(t.getValueAtPercentile(50)),p75:i(t.getValueAtPercentile(75)),p90:i(t.getValueAtPercentile(90)),p97_5:i(t.getValueAtPercentile(97.5)),p99:i(t.getValueAtPercentile(99)),p99_9:i(t.getValueAtPercentile(99.9)),p99_99:i(t.getValueAtPercentile(99.99)),p99_999:i(t.getValueAtPercentile(99.999)),max:r,totalCount:e}},{pow:pow$3,floor:floor$3,ceil:ceil,log2:log2$1,max:max,min:min}=Math;class JsHistogram{constructor(t,e,r){if(this.autoResize=!1,this.startTimeStampMsec=Number.MAX_SAFE_INTEGER,this.endTimeStampMsec=0,this.tag=NO_TAG,this.maxValue=0,this.minNonZeroValue=Number.MAX_SAFE_INTEGER,this.identity=0,this.highestTrackableValue=0,this.lowestDiscernibleValue=0,this.numberOfSignificantValueDigits=0,this.bucketCount=0,this.subBucketCount=0,this.countsArrayLength=0,this.wordSizeInBytes=0,t<1)throw new Error("lowestDiscernibleValue must be >= 1");if(e<2*t)throw new Error(`highestTrackableValue must be >= 2 * lowestDiscernibleValue ( 2 * ${t} )`);if(r<0||r>5)throw new Error("numberOfSignificantValueDigits must be between 0 and 5");this.identity=JsHistogram.identityBuilder++,this.init(t,e,r)}incrementTotalCount(){this._totalCount++}addToTotalCount(t){this._totalCount+=t}setTotalCount(t){this._totalCount=t}get totalCount(){return this._totalCount}updatedMaxValue(t){const e=t+this.unitMagnitudeMask;this.maxValue=e}updateMinNonZeroValue(t){if(t<=this.unitMagnitudeMask)return;const e=floor$3(t/this.lowestDiscernibleValueRounded)*this.lowestDiscernibleValueRounded;this.minNonZeroValue=e}init(t,e,r){this.lowestDiscernibleValue=t,this.highestTrackableValue=e,this.numberOfSignificantValueDigits=r;const n=2*floor$3(pow$3(10,r));this.unitMagnitude=floor$3(log2$1(t)),this.lowestDiscernibleValueRounded=pow$3(2,this.unitMagnitude),this.unitMagnitudeMask=this.lowestDiscernibleValueRounded-1;const i=ceil(log2$1(n));this.subBucketHalfCountMagnitude=(i>1?i:1)-1,this.subBucketCount=pow$3(2,this.subBucketHalfCountMagnitude+1),this.subBucketHalfCount=this.subBucketCount/2,this.subBucketMask=(floor$3(this.subBucketCount)-1)*pow$3(2,this.unitMagnitude),this.establishSize(e),this.leadingZeroCountBase=53-this.unitMagnitude-this.subBucketHalfCountMagnitude-1,this.percentileIterator=new PercentileIterator(this,1),this.recordedValuesIterator=new RecordedValuesIterator(this)}establishSize(t){this.countsArrayLength=this.determineArrayLengthNeeded(t),this.bucketCount=this.getBucketsNeededToCoverValue(t),this.highestTrackableValue=t}determineArrayLengthNeeded(t){if(t<2*this.lowestDiscernibleValue)throw new Error("highestTrackableValue ("+t+") cannot be < (2 * lowestDiscernibleValue)");return this.getLengthForNumberOfBuckets(this.getBucketsNeededToCoverValue(t))}getLengthForNumberOfBuckets(t){return(t+1)*(this.subBucketCount/2)}getBucketsNeededToCoverValue(t){let e=this.subBucketCount*pow$3(2,this.unitMagnitude),r=1;for(;e<=t;){if(e>Number.MAX_SAFE_INTEGER/2)return r+1;e*=2,r++}return r}recordValue(t){this.recordSingleValue(t)}recordSingleValue(t){const e=this.countsArrayIndex(t);e>=this.countsArrayLength?this.handleRecordException(1,t):this.incrementCountAtIndex(e),this.updateMinAndMax(t),this.incrementTotalCount()}handleRecordException(t,e){if(!this.autoResize)throw new Error("Value "+e+" is outside of histogram covered range");this.resize(e);var r=this.countsArrayIndex(e);this.addToCountAtIndex(r,t),this.highestTrackableValue=this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength-1))}countsArrayIndex(t){if(t<0)throw new Error("Histogram recorded value cannot be negative.");const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return this.computeCountsArrayIndex(e,r)}computeCountsArrayIndex(t,e){return(t+1)*pow$3(2,this.subBucketHalfCountMagnitude)+(e-this.subBucketHalfCount)}getBucketIndex(t){return max(floor$3(log2$1(t))-this.subBucketHalfCountMagnitude-this.unitMagnitude,0)}getSubBucketIndex(t,e){return floor$3(t/pow$3(2,e+this.unitMagnitude))}updateMinAndMax(t){t>this.maxValue&&this.updatedMaxValue(t),t<this.minNonZeroValue&&0!==t&&this.updateMinNonZeroValue(t)}getValueAtPercentile(t){const e=min(t,100)/100*this.totalCount,r=max(ceil(e-ulp(e)),1);let n=0;for(let e=0;e<this.countsArrayLength;e++)if(n+=this.getCountAtIndex(e),n>=r){var i=this.valueFromIndex(e);return 0===t?this.lowestEquivalentValue(i):this.highestEquivalentValue(i)}return 0}valueFromIndexes(t,e){return e*pow$3(2,t+this.unitMagnitude)}valueFromIndex(t){let e=floor$3(t/this.subBucketHalfCount)-1,r=t%this.subBucketHalfCount+this.subBucketHalfCount;return e<0&&(r-=this.subBucketHalfCount,e=0),this.valueFromIndexes(e,r)}lowestEquivalentValue(t){const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return this.valueFromIndexes(e,r)}highestEquivalentValue(t){return this.nextNonEquivalentValue(t)-1}nextNonEquivalentValue(t){return this.lowestEquivalentValue(t)+this.sizeOfEquivalentValueRange(t)}sizeOfEquivalentValueRange(t){const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return pow$3(2,this.unitMagnitude+(r>=this.subBucketCount?e+1:e))}medianEquivalentValue(t){return this.lowestEquivalentValue(t)+floor$3(this.sizeOfEquivalentValueRange(t)/2)}get mean(){if(0===this.totalCount)return 0;this.recordedValuesIterator.reset();let t=0;for(;this.recordedValuesIterator.hasNext();){const e=this.recordedValuesIterator.next();t+=this.medianEquivalentValue(e.valueIteratedTo)*e.countAtValueIteratedTo}return t/this.totalCount}getStdDeviation(t=this.mean){if(0===this.totalCount)return 0;let e=0;for(this.recordedValuesIterator.reset();this.recordedValuesIterator.hasNext();){const r=this.recordedValuesIterator.next(),n=this.medianEquivalentValue(r.valueIteratedTo)-t;e+=n*n*r.countAddedInThisIterationStep}return Math.sqrt(e/this.totalCount)}get stdDeviation(){if(0===this.totalCount)return 0;const t=this.mean;let e=0;for(this.recordedValuesIterator.reset();this.recordedValuesIterator.hasNext();){const r=this.recordedValuesIterator.next(),n=this.medianEquivalentValue(r.valueIteratedTo)-t;e+=n*n*r.countAddedInThisIterationStep}return Math.sqrt(e/this.totalCount)}outputPercentileDistribution(t=5,e=1,r=!1){let n="";n+=r?'"Value","Percentile","TotalCount","1/(1-Percentile)"\n':"       Value     Percentile TotalCount 1/(1-Percentile)\n\n";const i=this.percentileIterator;let o,s;if(i.reset(t),r){const t=floatFormatter(0,this.numberOfSignificantValueDigits),r=floatFormatter(0,12),n=floatFormatter(0,2);o=i=>t(i.valueIteratedTo/e)+","+r(i.percentileLevelIteratedTo/100)+","+i.totalCountToThisValue+","+n(1/(1-i.percentileLevelIteratedTo/100))+"\n",s=n=>t(n.valueIteratedTo/e)+","+r(n.percentileLevelIteratedTo/100)+","+n.totalCountToThisValue+",Infinity\n"}else{const t=floatFormatter(12,this.numberOfSignificantValueDigits),r=floatFormatter(2,12),n=integerFormatter(10),i=floatFormatter(14,2);o=o=>t(o.valueIteratedTo/e)+" "+r(o.percentileLevelIteratedTo/100)+" "+n(o.totalCountToThisValue)+" "+i(1/(1-o.percentileLevelIteratedTo/100))+"\n",s=i=>t(i.valueIteratedTo/e)+" "+r(i.percentileLevelIteratedTo/100)+" "+n(i.totalCountToThisValue)+"\n"}for(;i.hasNext();){const t=i.next();t.percentileLevelIteratedTo<100?n+=o(t):n+=s(t)}if(!r){const t=floatFormatter(12,this.numberOfSignificantValueDigits),r=this.mean,i=t(r/e),o=t(this.getStdDeviation(r)/e),s=t(this.maxValue/e),a=integerFormatter(12);n+=`#[Mean    = ${i}, StdDeviation   = ${o}]\n#[Max     = ${s}, Total count    = ${a(this.totalCount)}]\n#[Buckets = ${a(this.bucketCount)}, SubBuckets     = ${a(this.subBucketCount)}]\n`}return n}get summary(){return toSummary(this)}toJSON(){return this.summary}inspect(){return this.toString()}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}get estimatedFootprintInBytes(){return this._getEstimatedFootprintInBytes()}recordSingleValueWithExpectedInterval(t,e){if(this.recordSingleValue(t),!(e<=0))for(let r=t-e;r>=e;r-=e)this.recordSingleValue(r)}recordCountAtValue(t,e){const r=this.countsArrayIndex(e);r>=this.countsArrayLength?this.handleRecordException(t,e):this.addToCountAtIndex(r,t),this.updateMinAndMax(e),this.addToTotalCount(t)}recordValueWithCount(t,e){this.recordCountAtValue(e,t)}recordValueWithExpectedInterval(t,e){this.recordSingleValueWithExpectedInterval(t,e)}recordValueWithCountAndExpectedInterval(t,e,r){if(this.recordCountAtValue(e,t),!(r<=0))for(let n=t-r;n>=r;n-=r)this.recordCountAtValue(e,n)}addWhileCorrectingForCoordinatedOmission(t,e){const r=this,n=new RecordedValuesIterator(t);for(;n.hasNext();){const t=n.next();r.recordValueWithCountAndExpectedInterval(t.valueIteratedTo,t.countAtValueIteratedTo,e)}}add(t){if(!(t instanceof JsHistogram))throw new Error("Cannot add a WASM histogram to a regular JS histogram");if(this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength-1))<t.maxValue){if(!this.autoResize)throw new Error("The other histogram includes values that do not fit in this histogram's range.");this.resize(t.maxValue)}if(this.bucketCount===t.bucketCount&&this.subBucketCount===t.subBucketCount&&this.unitMagnitude===t.unitMagnitude){let e=0;for(let r=0;r<t.countsArrayLength;r++){const n=t.getCountAtIndex(r);n>0&&(this.addToCountAtIndex(r,n),e+=n)}this.setTotalCount(this.totalCount+e),this.updatedMaxValue(max(this.maxValue,t.maxValue)),this.updateMinNonZeroValue(min(this.minNonZeroValue,t.minNonZeroValue))}else{const e=t.countsArrayIndex(t.maxValue);let r=t.getCountAtIndex(e);this.recordCountAtValue(r,t.valueFromIndex(e));for(let n=0;n<e;n++)r=t.getCountAtIndex(n),r>0&&this.recordCountAtValue(r,t.valueFromIndex(n))}this.startTimeStampMsec=min(this.startTimeStampMsec,t.startTimeStampMsec),this.endTimeStampMsec=max(this.endTimeStampMsec,t.endTimeStampMsec)}getCountAtValue(t){const e=min(max(0,this.countsArrayIndex(t)),this.countsArrayLength-1);return this.getCountAtIndex(e)}subtract(t){const e=this.valueFromIndex(this.countsArrayLength-1);if(!(t instanceof JsHistogram))throw new Error("Cannot subtract a WASM histogram to a regular JS histogram");if(e<t.maxValue){if(!this.autoResize)throw new Error("The other histogram includes values that do not fit in this histogram's range.");this.resize(t.maxValue)}if(this.bucketCount===t.bucketCount&&this.subBucketCount===t.subBucketCount&&this.unitMagnitude===t.unitMagnitude){let e=0;for(let r=0;r<t.countsArrayLength;r++){const n=t.getCountAtIndex(r);n>0&&(this.addToCountAtIndex(r,-n),e+=n)}this.setTotalCount(this.totalCount-e)}else for(let e=0;e<t.countsArrayLength;e++){const r=t.getCountAtIndex(e);if(r>0){const n=t.valueFromIndex(e);if(this.getCountAtValue(n)<r)throw new Error("otherHistogram count ("+r+") at value "+n+" is larger than this one's ("+this.getCountAtValue(n)+")");this.recordCountAtValue(-r,n)}}(this.getCountAtValue(this.maxValue)<=0||this.getCountAtValue(this.minNonZeroValue)<=0)&&this.establishInternalTackingValues()}establishInternalTackingValues(t=this.countsArrayLength){this.maxValue=0,this.minNonZeroValue=Number.MAX_VALUE;let e=-1,r=-1,n=0;for(let i=0;i<t;i++){const t=this.getCountAtIndex(i);t>0&&(n+=t,e=i,-1==r&&0!=i&&(r=i))}e>=0&&this.updatedMaxValue(this.highestEquivalentValue(this.valueFromIndex(e))),r>=0&&this.updateMinNonZeroValue(this.valueFromIndex(r)),this.setTotalCount(n)}reset(){this.clearCounts(),this.setTotalCount(0),this.startTimeStampMsec=0,this.endTimeStampMsec=0,this.tag=NO_TAG,this.maxValue=0,this.minNonZeroValue=Number.MAX_SAFE_INTEGER}destroy(){}}
/*! *****************************************************************************
  Copyright (c) Microsoft Corporation.

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.

  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */function __awaiter(t,e,r,n){return new(r||(r=Promise))((function(i,o){function s(t){try{u(n.next(t))}catch(t){o(t)}}function a(t){try{u(n.throw(t))}catch(t){o(t)}}function u(t){var e;t.done?i(t.value):(e=t.value,e instanceof r?e:new r((function(t){t(e)}))).then(s,a)}u((n=n.apply(t,e||[])).next())}))}const BINARY="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";for(var toByteArray_1=toByteArray,fromByteArray_1=fromByteArray,lookup=[],revLookup=[],Arr="undefined"!=typeof Uint8Array?Uint8Array:Array,code="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",i=0,len=code.length;i<len;++i)lookup[i]=code[i],revLookup[code.charCodeAt(i)]=i;function getLens(t){var e=t.length;if(e%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var r=t.indexOf("=");return-1===r&&(r=e),[r,r===e?0:4-r%4]}function _byteLength(t,e,r){return 3*(e+r)/4-r}function toByteArray(t){var e,r,n=getLens(t),i=n[0],o=n[1],s=new Arr(_byteLength(t,i,o)),a=0,u=o>0?i-4:i;for(r=0;r<u;r+=4)e=revLookup[t.charCodeAt(r)]<<18|revLookup[t.charCodeAt(r+1)]<<12|revLookup[t.charCodeAt(r+2)]<<6|revLookup[t.charCodeAt(r+3)],s[a++]=e>>16&255,s[a++]=e>>8&255,s[a++]=255&e;return 2===o&&(e=revLookup[t.charCodeAt(r)]<<2|revLookup[t.charCodeAt(r+1)]>>4,s[a++]=255&e),1===o&&(e=revLookup[t.charCodeAt(r)]<<10|revLookup[t.charCodeAt(r+1)]<<4|revLookup[t.charCodeAt(r+2)]>>2,s[a++]=e>>8&255,s[a++]=255&e),s}function tripletToBase64(t){return lookup[t>>18&63]+lookup[t>>12&63]+lookup[t>>6&63]+lookup[63&t]}function encodeChunk(t,e,r){for(var n,i=[],o=e;o<r;o+=3)n=(t[o]<<16&16711680)+(t[o+1]<<8&65280)+(255&t[o+2]),i.push(tripletToBase64(n));return i.join("")}function fromByteArray(t){for(var e,r=t.length,n=r%3,i=[],o=0,s=r-n;o<s;o+=16383)i.push(encodeChunk(t,o,o+16383>s?s:o+16383));return 1===n?(e=t[r-1],i.push(lookup[e>>2]+lookup[e<<4&63]+"==")):2===n&&(e=(t[r-2]<<8)+t[r-1],i.push(lookup[e>>10]+lookup[e>>4&63]+lookup[e<<2&63]+"=")),i.join("")}revLookup["-".charCodeAt(0)]=62,revLookup["_".charCodeAt(0)]=63;const ID_OFFSET=-8,SIZE_OFFSET=-4,ARRAYBUFFER_ID=0,STRING_ID=1,ARRAYBUFFERVIEW=1,ARRAY=2,STATICARRAY=4,VAL_ALIGN_OFFSET=6,VAL_SIGNED=2048,VAL_FLOAT=4096,VAL_MANAGED=16384,ARRAYBUFFERVIEW_BUFFER_OFFSET=0,ARRAYBUFFERVIEW_DATASTART_OFFSET=4,ARRAYBUFFERVIEW_DATALENGTH_OFFSET=8,ARRAYBUFFERVIEW_SIZE=12,ARRAY_LENGTH_OFFSET=12,ARRAY_SIZE=16,BIGINT="undefined"!=typeof BigUint64Array,THIS=Symbol(),CHUNKSIZE=1024;function getStringImpl(t,e){const r=new Uint32Array(t),n=new Uint16Array(t);let i=r[e+SIZE_OFFSET>>>2]>>>1,o=e>>>1;if(i<=CHUNKSIZE)return String.fromCharCode.apply(String,n.subarray(o,o+i));const s=[];do{const t=n[o+CHUNKSIZE-1],e=t>=55296&&t<56320?CHUNKSIZE-1:CHUNKSIZE;s.push(String.fromCharCode.apply(String,n.subarray(o,o+=e))),i-=e}while(i>CHUNKSIZE);return s.join("")+String.fromCharCode.apply(String,n.subarray(o,o+i))}function preInstantiate(t){const e={};function r(t,e){return t?getStringImpl(t.buffer,e):"<yet unknown>"}const n=t.env=t.env||{};return n.abort=n.abort||function(t,i,o,s){const a=e.memory||n.memory;throw Error("abort: "+r(a,t)+" at "+r(a,i)+":"+o+":"+s)},n.trace=n.trace||function(t,i){const o=e.memory||n.memory;console.log("trace: "+r(o,t)+(i?" ":"")+Array.prototype.slice.call(arguments,2,2+i).join(", "))},n.seed=n.seed||function(){return Date.now()},t.Math=t.Math||Math,t.Date=t.Date||Date,e}function postInstantiate(t,e){const r=e.exports,n=r.memory,i=r.table,o=r.__alloc,s=r.__retain,a=r.__rtti_base||-1;function u(t){const e=new Uint32Array(n.buffer);if((t>>>=0)>=e[a>>>2])throw Error("invalid id: "+t);return e[(a+4>>>2)+2*t]}function l(t){const e=new Uint32Array(n.buffer);if((t>>>=0)>=e[a>>>2])throw Error("invalid id: "+t);return e[(a+4>>>2)+2*t+1]}function h(t){return 31-Math.clz32(t>>>VAL_ALIGN_OFFSET&31)}function c(t,e,r){const i=n.buffer;if(r)switch(t){case 2:return new Float32Array(i);case 3:return new Float64Array(i)}else switch(t){case 0:return new(e?Int8Array:Uint8Array)(i);case 1:return new(e?Int16Array:Uint16Array)(i);case 2:return new(e?Int32Array:Uint32Array)(i);case 3:return new(e?BigInt64Array:BigUint64Array)(i)}throw Error("unsupported align: "+t)}function d(t){const e=new Uint32Array(n.buffer),r=e[t+ID_OFFSET>>>2],i=u(r);if(!(i&(ARRAYBUFFERVIEW|ARRAY|STATICARRAY)))throw Error("not an array: "+r+", flags="+i);const o=h(i);let s=i&STATICARRAY?t:e[t+ARRAYBUFFERVIEW_DATASTART_OFFSET>>>2];const a=i&ARRAY?e[t+ARRAY_LENGTH_OFFSET>>>2]:e[s+SIZE_OFFSET>>>2]>>>o;return c(o,i&VAL_SIGNED,i&VAL_FLOAT).subarray(s>>>=o,s+a)}function g(t,e,r){return new t(m(t,e,r))}function m(t,e,r){const i=n.buffer,o=new Uint32Array(i),s=o[r+ARRAYBUFFERVIEW_DATASTART_OFFSET>>>2];return new t(i,s,o[s+SIZE_OFFSET>>>2]>>>e)}function f(e,r,n){t["__get"+r]=g.bind(null,e,n),t["__get"+r+"View"]=m.bind(null,e,n)}return t.__allocString=function(t){const e=t.length,r=o(e<<1,STRING_ID),i=new Uint16Array(n.buffer);for(var s=0,a=r>>>1;s<e;++s)i[a+s]=t.charCodeAt(s);return r},t.__getString=function(t){const e=n.buffer;if(new Uint32Array(e)[t+ID_OFFSET>>>2]!==STRING_ID)throw Error("not a string: "+t);return getStringImpl(e,t)},t.__allocArray=function(t,e){const r=u(t);if(!(r&(ARRAYBUFFERVIEW|ARRAY|STATICARRAY)))throw Error("not an array: "+t+", flags= "+r);const i=h(r),a=e.length,l=o(a<<i,r&STATICARRAY?t:ARRAYBUFFER_ID);let d;if(r&STATICARRAY)d=l;else{const e=o(r&ARRAY?ARRAY_SIZE:ARRAYBUFFERVIEW_SIZE,t),u=new Uint32Array(n.buffer);u[e+ARRAYBUFFERVIEW_BUFFER_OFFSET>>>2]=s(l),u[e+ARRAYBUFFERVIEW_DATASTART_OFFSET>>>2]=l,u[e+ARRAYBUFFERVIEW_DATALENGTH_OFFSET>>>2]=a<<i,r&ARRAY&&(u[e+ARRAY_LENGTH_OFFSET>>>2]=a),d=e}const g=c(i,r&VAL_SIGNED,r&VAL_FLOAT);if(r&VAL_MANAGED)for(let t=0;t<a;++t)g[(l>>>i)+t]=s(e[t]);else g.set(e,l>>>i);return d},t.__getArrayView=d,t.__getArray=function(t){const e=d(t),r=e.length,n=new Array(r);for(let t=0;t<r;t++)n[t]=e[t];return n},t.__getArrayBuffer=function(t){const e=n.buffer,r=new Uint32Array(e)[t+SIZE_OFFSET>>>2];return e.slice(t,t+r)},[Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array].forEach(t=>{f(t,t.name,31-Math.clz32(t.BYTES_PER_ELEMENT))}),BIGINT&&[BigUint64Array,BigInt64Array].forEach(t=>{f(t,t.name.slice(3),3)}),t.__instanceof=function(t,e){const r=new Uint32Array(n.buffer);let i=r[t+ID_OFFSET>>>2];if(i<=r[a>>>2])do{if(i==e)return!0;i=l(i)}while(i);return!1},t.memory=t.memory||n,t.table=t.table||i,demangle(r,t)}function isResponse(t){return"undefined"!=typeof Response&&t instanceof Response}function isModule(t){return t instanceof WebAssembly.Module}async function instantiate(t,e={}){if(isResponse(t=await t))return instantiateStreaming(t,e);const r=isModule(t)?t:await WebAssembly.compile(t),n=preInstantiate(e),i=await WebAssembly.instantiate(r,e);return{module:r,instance:i,exports:postInstantiate(n,i)}}var instantiate_1=instantiate;function instantiateSync(t,e={}){const r=isModule(t)?t:new WebAssembly.Module(t),n=preInstantiate(e),i=new WebAssembly.Instance(r,e);return{module:r,instance:i,exports:postInstantiate(n,i)}}var instantiateSync_1=instantiateSync;async function instantiateStreaming(t,e={}){if(!WebAssembly.instantiateStreaming)return instantiate(isResponse(t=await t)?t.arrayBuffer():t,e);const r=preInstantiate(e),n=await WebAssembly.instantiateStreaming(t,e),i=postInstantiate(r,n.instance);return{...n,exports:i}}function demangle(t,e={}){e=Object.create(e);const r=t.__argumentsLength?e=>{t.__argumentsLength.value=e}:t.__setArgumentsLength||t.__setargc||(()=>{});for(let n in t){if(!Object.prototype.hasOwnProperty.call(t,n))continue;const i=t[n];let o=n.split("."),s=e;for(;o.length>1;){let t=o.shift();Object.prototype.hasOwnProperty.call(s,t)||(s[t]={}),s=s[t]}let a=o[0],u=a.indexOf("#");if(u>=0){const e=a.substring(0,u),o=s[e];if(void 0===o||!o.prototype){const t=function(...e){return t.wrap(t.prototype.constructor(0,...e))};t.prototype={valueOf:function(){return this[THIS]}},t.wrap=function(e){return Object.create(t.prototype,{[THIS]:{value:e,writable:!1}})},o&&Object.getOwnPropertyNames(o).forEach(e=>Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(o,e))),s[e]=t}if(a=a.substring(u+1),s=s[e].prototype,/^(get|set):/.test(a)){if(!Object.prototype.hasOwnProperty.call(s,a=a.substring(4))){let e=t[n.replace("set:","get:")],r=t[n.replace("get:","set:")];Object.defineProperty(s,a,{get:function(){return e(this[THIS])},set:function(t){r(this[THIS],t)},enumerable:!0})}}else"constructor"===a?(s[a]=(...t)=>(r(t.length),i(...t))).original=i:(s[a]=function(...t){return r(t.length),i(this[THIS],...t)}).original=i}else/^(get|set):/.test(a)?Object.prototype.hasOwnProperty.call(s,a=a.substring(4))||Object.defineProperty(s,a,{get:t[n.replace("set:","get:")],set:t[n.replace("get:","set:")],enumerable:!0}):"function"==typeof i&&i!==r?(s[a]=(...t)=>(r(t.length),i(...t))).original=i:s[a]=i}return e}const isNode="undefined"!=typeof process&&process.version,isWorker="function"==typeof importScripts,webAssemblyAvailable=(()=>{let t=!1;return t=isNode?"WebAssembly"in global:isWorker||"WebAssembly"in window,t})();let wasm=void 0;const initWebAssembly=()=>__awaiter(void 0,void 0,void 0,(function*(){if(!webAssemblyAvailable)throw new Error("WebAssembly not available here!");if(!wasm)return instantiate_1(pako.inflate(toByteArray_1(BINARY))).then(t=>wasm=t.exports||t)})),initWebAssemblySync=()=>{if(wasm)return;const t=instantiateSync_1(pako.inflate(toByteArray_1(BINARY)));wasm=t.exports||t},webAssemblyReady=()=>!!wasm,defaultRequest={bitBucketSize:32,autoResize:!0,lowestDiscernibleValue:1,highestTrackableValue:2,numberOfSignificantValueDigits:3},remoteHistogramClassFor=t=>"packed"===t?"PackedHistogram":"Histogram"+t,destroyedWasmHistogram=new Proxy({},{get:function(t,e){throw new Error("Cannot use a destroyed histogram")}});class WasmHistogram{constructor(t,e){this._wasmHistogram=t,this._remoteHistogramClass=e,this.tag=NO_TAG}static build(t=defaultRequest){if(!webAssemblyReady())throw new Error("WebAssembly is not ready yet!");const e=Object.assign({},defaultRequest,t),r=remoteHistogramClassFor(e.bitBucketSize);return new WasmHistogram(new wasm[r](e.lowestDiscernibleValue,e.highestTrackableValue,e.numberOfSignificantValueDigits,e.autoResize),r)}static decode(t,e=32,r=0){if(!webAssemblyReady())throw new Error("WebAssembly is not ready yet!");const n=remoteHistogramClassFor(e),i="decode"+n,o=wasm.__retain(wasm.__allocArray(wasm.UINT8ARRAY_ID,t)),s=new WasmHistogram(wasm[n].wrap(wasm[i](o,r)),n);return wasm.__release(o),s}get numberOfSignificantValueDigits(){return this._wasmHistogram.numberOfSignificantValueDigits}get autoResize(){return!!this._wasmHistogram.autoResize}set autoResize(t){this._wasmHistogram.autoResize=t}get highestTrackableValue(){return this._wasmHistogram.highestTrackableValue}set highestTrackableValue(t){this._wasmHistogram.highestTrackableValue=t}get startTimeStampMsec(){return this._wasmHistogram.startTimeStampMsec}set startTimeStampMsec(t){this._wasmHistogram.startTimeStampMsec=t}get endTimeStampMsec(){return this._wasmHistogram.endTimeStampMsec}set endTimeStampMsec(t){this._wasmHistogram.endTimeStampMsec=t}get totalCount(){return this._wasmHistogram.totalCount}get stdDeviation(){return this._wasmHistogram.stdDeviation}get mean(){return this._wasmHistogram.mean}get estimatedFootprintInBytes(){return 192+this._wasmHistogram.estimatedFootprintInBytes}get minNonZeroValue(){return this._wasmHistogram.minNonZeroValue}get maxValue(){return this._wasmHistogram.maxValue}recordValue(t){this._wasmHistogram.recordValue(t)}recordValueWithCount(t,e){this._wasmHistogram.recordValueWithCount(t,e)}recordValueWithExpectedInterval(t,e){this._wasmHistogram.recordValueWithExpectedInterval(t,e)}getValueAtPercentile(t){return this._wasmHistogram.getValueAtPercentile(t)}outputPercentileDistribution(t=5,e=1,r=!1){if(r)throw new Error("CSV output not supported by wasm histograms");return wasm.__getString(this._wasmHistogram.outputPercentileDistribution(t,e))}isDestroyed(){return this._wasmHistogram===destroyedWasmHistogram}get summary(){return toSummary(this)}toJSON(){return this.summary}toString(){return this.isDestroyed()?"Destroyed WASM histogram":`WASM ${this._remoteHistogramClass} ${JSON.stringify(this,null,2)}`}inspect(){return this.toString()}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}addWhileCorrectingForCoordinatedOmission(t,e){this._wasmHistogram.addWhileCorrectingForCoordinatedOmission(t,e)}copyCorrectedForCoordinatedOmission(t){return new WasmHistogram(wasm[this._remoteHistogramClass].wrap(this._wasmHistogram.copyCorrectedForCoordinatedOmission(t)),this._remoteHistogramClass)}add(t){if(!(t instanceof WasmHistogram))throw new Error("Cannot add a regular JS histogram to a WASM histogram");this._wasmHistogram["add"+t._remoteHistogramClass](t._wasmHistogram)}subtract(t){if(!(t instanceof WasmHistogram))throw new Error("Cannot subtract a regular JS histogram to a WASM histogram");this._wasmHistogram["subtract"+t._remoteHistogramClass](t._wasmHistogram)}encode(){const t=this._wasmHistogram.encode(),e=wasm.__getUint8Array(t);return wasm.__release(t),e}reset(){this.tag=NO_TAG,this._wasmHistogram.reset()}destroy(){wasm.__release(this._wasmHistogram),this._wasmHistogram=destroyedWasmHistogram}}const MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY=16,MAX_SUPPORTED_PACKED_COUNTS_ARRAY_LENGTH=Math.pow(2,13)-1,SET_0_START_INDEX=0,NUMBER_OF_SETS=8,LEAF_LEVEL_SHIFT=3,NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET=0,NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS=1,PACKED_ARRAY_GROWTH_INCREMENT=16,PACKED_ARRAY_GROWTH_FRACTION_POW2=4,{pow:pow$4,ceil:ceil$1,log2:log2$2,max:max$1}=Math,bitCount=t=>{for(var e=0;0!==t;)e+=bitCount32(0|t),t/=4294967296;return e},bitCount32=t=>16843009*((t=(858993459&(t-=t>>1&1431655765))+(t>>2&858993459))+(t>>4)&252645135)>>24;class PackedArrayContext{constructor(t,e){this.populatedShortLength=0,this.topLevelShift=Number.MAX_VALUE,this.physicalLength=Math.max(e,MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY),this.isPacked=this.physicalLength<=MAX_SUPPORTED_PACKED_COUNTS_ARRAY_LENGTH,this.isPacked||(this.physicalLength=t),this.array=new ArrayBuffer(8*this.physicalLength),this.initArrayViews(this.array),this.init(t)}initArrayViews(t){this.byteArray=new Uint8Array(t),this.shortArray=new Uint16Array(t),this.longArray=new Float64Array(t)}init(t){if(this.isPacked){this.populatedShortLength=SET_0_START_INDEX+8;for(let t=0;t<NUMBER_OF_SETS;t++)this.setAtShortIndex(SET_0_START_INDEX+t,0);this.setVirtualLength(t)}else this.virtualLength=t}clear(){this.byteArray.fill(0),this.init(this.virtualLength)}copyAndIncreaseSize(t,e){const r=new PackedArrayContext(e,t);return this.isPacked&&r.populateEquivalentEntriesWithEntriesFromOther(this),r}getPopulatedShortLength(){return this.populatedShortLength}getPopulatedLongLength(){return this.getPopulatedShortLength()+3>>2}setAtByteIndex(t,e){this.byteArray[t]=e}getAtByteIndex(t){return this.byteArray[t]}addAtByteIndex(t,e){const r=this.byteArray[t]+e;return this.byteArray[t]=r,r}setPopulatedLongLength(t){this.populatedShortLength=t<<2}getVirtualLength(){return this.virtualLength}length(){return this.physicalLength}setAtShortIndex(t,e){this.shortArray[t]=e}setAtLongIndex(t,e){this.longArray[t]=e}getAtShortIndex(t){return this.shortArray[t]}getIndexAtShortIndex(t){return this.shortArray[t]}setPackedSlotIndicators(t,e){this.setAtShortIndex(t+NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET,e)}getPackedSlotIndicators(t){return 65535&this.shortArray[t+NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET]}getIndexAtEntrySlot(t,e){return this.getAtShortIndex(t+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+e)}setIndexAtEntrySlot(t,e,r){this.setAtShortIndex(t+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+e,r)}expandArrayIfNeeded(t){const e=this.length();if(e<this.getPopulatedLongLength()+t){const r=max$1(t,PACKED_ARRAY_GROWTH_INCREMENT,this.getPopulatedLongLength()>>PACKED_ARRAY_GROWTH_FRACTION_POW2);this.resizeArray(e+r)}}newEntry(t){const e=this.populatedShortLength;this.expandArrayIfNeeded(1+(t>>2)),this.populatedShortLength=e+t;for(let r=0;r<t;r++)this.setAtShortIndex(e+r,-1);return e}newLeafEntry(){let t;return t=this.getPopulatedLongLength(),this.expandArrayIfNeeded(1),this.setPopulatedLongLength(t+1),this.setAtLongIndex(t,0),t}consolidateEntry(t,e){const r=this.getPackedSlotIndicators(e),n=this.getPackedSlotIndicators(t),i=bitCount(n&(n^r)-1),o=bitCount(n);let s=0;for(let r=0;r<o;r++)if(r!==i){const n=this.getIndexAtEntrySlot(e,s);0!==n&&this.setIndexAtEntrySlot(t,r,n),s++}}expandEntry(t,e,r,n,i){let o=65535&this.getAtShortIndex(t);o|=n;const s=bitCount(o);if(r>=s)throw new Error("inserted slot index is out of range given provided masks");const a=s+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS;let u=0;i?u=this.newLeafEntry():(u=this.newEntry(NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS),this.setPackedSlotIndicators(u,0));const l=u,h=this.newEntry(a);return this.setPackedSlotIndicators(h,o),this.setIndexAtEntrySlot(h,r,l),this.setAtShortIndex(e,h),this.consolidateEntry(h,t),h}getRootEntry(t,e=!1){const r=SET_0_START_INDEX+t;let n=this.getIndexAtShortIndex(r);if(0==n){if(!e)return 0;n=this.newEntry(NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS),this.setPackedSlotIndicators(n,0),this.setAtShortIndex(r,n)}return n}getPackedIndex(t,e,r){if(e>=this.virtualLength)throw new Error(`Attempting access at index ${e}, beyond virtualLength ${this.virtualLength}`);let n=SET_0_START_INDEX+t,i=this.getRootEntry(t,r);if(0==i)return-1;for(let t=this.topLevelShift;t>=LEAF_LEVEL_SHIFT;t-=4){const o=t===LEAF_LEVEL_SHIFT,s=this.getPackedSlotIndicators(i),a=1<<(e/pow$4(2,t)&15),u=bitCount(s&a-1);if(0==(s&a)){if(!r)return-1;i=this.expandEntry(i,n,u,a,o)}n=i+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+u,i=this.getIndexAtShortIndex(n)}return(i<<3)+(7&e)}determineTopLevelShiftForVirtualLength(t){const e=ceil$1(log2$2(t));let r=4*ceil$1((e-3)/4);r=max$1(r,8);return r-4+3}setVirtualLength(t){if(!this.isPacked)throw new Error("Should never be adjusting the virtual size of a non-packed context");this.topLevelShift=this.determineTopLevelShiftForVirtualLength(t),this.virtualLength=t}getTopLevelShift(){return this.topLevelShift}resizeArray(t){const e=new Uint8Array(8*t);e.set(this.byteArray),this.array=e.buffer,this.initArrayViews(this.array),this.physicalLength=t}populateEquivalentEntriesWithEntriesFromOther(t){if(this.virtualLength<t.getVirtualLength())throw new Error("Cannot populate array of smaller virtual length");for(let e=0;e<NUMBER_OF_SETS;e++){const r=t.getAtShortIndex(SET_0_START_INDEX+e);if(0==r)continue;let n=SET_0_START_INDEX+e;for(let e=this.topLevelShift;e>t.topLevelShift;e-=4){const t=NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+1,e=this.newEntry(t);this.setAtShortIndex(n,e),this.setPackedSlotIndicators(e,1),n=e+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS}this.copyEntriesAtLevelFromOther(t,r,n,t.topLevelShift)}}copyEntriesAtLevelFromOther(t,e,r,n){const i=n==LEAF_LEVEL_SHIFT,o=t.getPackedSlotIndicators(e),s=bitCount(o),a=NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+s,u=this.newEntry(a);this.setAtShortIndex(r,u),this.setAtShortIndex(u+NON_LEAF_ENTRY_SLOT_INDICATORS_OFFSET,o);for(let r=0;r<s;r++)if(i){const n=this.newLeafEntry();this.setIndexAtEntrySlot(u,r,n);const i=t.getIndexAtEntrySlot(e,r);this.longArray[n]=t.longArray[i]}else{const i=t.getIndexAtEntrySlot(e,r);this.copyEntriesAtLevelFromOther(t,i,u+NON_LEAF_ENTRY_HEADER_SIZE_IN_SHORTS+r,n-4)}}getAtUnpackedIndex(t){return this.longArray[t]}setAtUnpackedIndex(t,e){this.longArray[t]=e}lazysetAtUnpackedIndex(t,e){this.longArray[t]=e}incrementAndGetAtUnpackedIndex(t){return this.longArray[t]++,this.longArray[t]}addAndGetAtUnpackedIndex(t,e){return this.longArray[t]+=e,this.longArray[t]}nonLeafEntryToString(t,e,r){let n="";for(let t=0;t<r;t++)n+="  ";try{const i=this.getPackedSlotIndicators(t);n+=`slotIndiators: 0x${toHex(i)}, prevVersionIndex: 0: [ `;const o=bitCount(i);for(let e=0;e<o;e++)n+=this.getIndexAtEntrySlot(t,e),e<o-1&&(n+=", ");n+=` ] (indexShift = ${e})\n`;const s=e==LEAF_LEVEL_SHIFT;for(let i=0;i<o;i++){const o=this.getIndexAtEntrySlot(t,i);n+=s?this.leafEntryToString(o,r+4):this.nonLeafEntryToString(o,e-4,r+4)}}catch(r){n+=`Exception thrown at nonLeafEnty at index ${t} with indexShift ${e}\n`}return n}leafEntryToString(t,e){let r="";for(let t=0;t<e;t++)r+="  ";try{r+="Leaf bytes : ";for(let e=0;e<8;e++)r+=`0x${toHex(this.byteArray[8*t+e])} `;r+="\n"}catch(e){r+=`Exception thrown at leafEnty at index ${t}\n`}return r}toString(){let t="PackedArrayContext:\n";if(!this.isPacked)return t+"Context is unpacked:\n";for(let e=0;e<NUMBER_OF_SETS;e++)try{const r=SET_0_START_INDEX+e,n=this.getIndexAtShortIndex(r);if(t+=`Set ${e}: root = ${n} \n`,0==n)continue;t+=this.nonLeafEntryToString(n,this.topLevelShift,4)}catch(r){t+=`Exception thrown in set ${e}%d\n`}return t}}const toHex=t=>Number(t).toString(16).padStart(2,"0"),NUMBER_OF_SETS$1=8,{pow:pow$5,floor:floor$4}=Math;class PackedArray{constructor(t,e=MINIMUM_INITIAL_PACKED_ARRAY_CAPACITY){this.arrayContext=new PackedArrayContext(t,e)}setVirtualLength(t){if(t<this.length())throw new Error("Cannot set virtual length, as requested length "+t+" is smaller than the current virtual length "+this.length());const e=this.arrayContext;e.isPacked&&e.determineTopLevelShiftForVirtualLength(t)==e.getTopLevelShift()?e.setVirtualLength(t):this.arrayContext=e.copyAndIncreaseSize(this.getPhysicalLength(),t)}get(t){let e=0;for(let r=0;r<NUMBER_OF_SETS$1;r++){let n=0;if(!this.arrayContext.isPacked)return this.arrayContext.getAtUnpackedIndex(t);const i=this.arrayContext.getPackedIndex(r,t,!1);if(i<0)return e;n=this.arrayContext.getAtByteIndex(i)*pow$5(2,r<<3),e+=n}return e}increment(t){this.add(t,1)}safeGetPackedIndexgetPackedIndex(t,e){return this.arrayContext.getPackedIndex(t,e,!0)}add(t,e){let r=e;for(let n=0,i=0;n<NUMBER_OF_SETS$1;n++,i+=8){if(!this.arrayContext.isPacked)return void this.arrayContext.addAndGetAtUnpackedIndex(t,e);const i=this.safeGetPackedIndexgetPackedIndex(n,t),o=255&r,s=this.arrayContext.addAtByteIndex(i,o);if(r-=o,r/=pow$5(2,8),r+=floor$4(s/pow$5(2,8)),0==r)return}}set(t,e){let r=0,n=e;for(let i=0;i<NUMBER_OF_SETS$1;i++){if(!this.arrayContext.isPacked)return void this.arrayContext.setAtUnpackedIndex(t,e);if(0==n){if(this.arrayContext.getPackedIndex(i,t,!1)<0)return}const o=this.arrayContext.getPackedIndex(i,t,!0),s=255&n;n=floor$4(n/pow$5(2,8)),i<r||(this.arrayContext.setAtByteIndex(o,s),r++)}}getPhysicalLength(){return this.arrayContext.physicalLength}length(){return this.arrayContext.getVirtualLength()}clear(){this.arrayContext.clear()}toString(){let t="PackedArray:\n";return t+=this.arrayContext.toString(),t}}class PackedHistogram extends JsHistogram{constructor(t,e,r){super(t,e,r),this._totalCount=0,this.packedCounts=new PackedArray(this.countsArrayLength)}clearCounts(){this.packedCounts.clear()}incrementCountAtIndex(t){this.packedCounts.increment(t)}addToCountAtIndex(t,e){this.packedCounts.add(t,e)}setCountAtIndex(t,e){this.packedCounts.set(t,e)}resize(t){this.establishSize(t),this.packedCounts.setVirtualLength(this.countsArrayLength)}getCountAtIndex(t){return this.packedCounts.get(t)}_getEstimatedFootprintInBytes(){return 192+8*this.packedCounts.getPhysicalLength()}copyCorrectedForCoordinatedOmission(t){const e=new PackedHistogram(this.lowestDiscernibleValue,this.highestTrackableValue,this.numberOfSignificantValueDigits);return e.addWhileCorrectingForCoordinatedOmission(this,t),e}toString(){return"PackedHistogram "+JSON.stringify(this,null,2)}}class TypedArrayHistogram extends JsHistogram{constructor(t,e,r,n){super(e,r,n),this.arrayCtr=t,this._totalCount=0,this._counts=new t(this.countsArrayLength)}clearCounts(){this._counts.fill(0)}incrementCountAtIndex(t){const e=this._counts[t]+1;if(e<0)throw e+" would overflow short integer count";this._counts[t]=e}addToCountAtIndex(t,e){const r=this._counts[t]+e;if(r<Number.MIN_SAFE_INTEGER||r>Number.MAX_SAFE_INTEGER)throw r+" would overflow integer count";this._counts[t]=r}setCountAtIndex(t,e){if(e<Number.MIN_SAFE_INTEGER||e>Number.MAX_SAFE_INTEGER)throw e+" would overflow integer count";this._counts[t]=e}resize(t){this.establishSize(t);const e=new this.arrayCtr(this.countsArrayLength);e.set(this._counts),this._counts=e}getCountAtIndex(t){return this._counts[t]}_getEstimatedFootprintInBytes(){return 1024+this._counts.BYTES_PER_ELEMENT*this._counts.length}copyCorrectedForCoordinatedOmission(t){const e=new TypedArrayHistogram(this.arrayCtr,this.lowestDiscernibleValue,this.highestTrackableValue,this.numberOfSignificantValueDigits);return e.addWhileCorrectingForCoordinatedOmission(this,t),e}toString(){return`Histogram ${8*this._counts.BYTES_PER_ELEMENT}b ${JSON.stringify(this,null,2)}`}}class Int8Histogram extends TypedArrayHistogram{constructor(t,e,r){super(Uint8Array,t,e,r)}}class Int16Histogram extends TypedArrayHistogram{constructor(t,e,r){super(Uint16Array,t,e,r)}}class Int32Histogram extends TypedArrayHistogram{constructor(t,e,r){super(Uint32Array,t,e,r)}}class Float64Histogram extends TypedArrayHistogram{constructor(t,e,r){super(Float64Array,t,e,r)}}function constructorFromBucketSize(t){switch(t){case"packed":return PackedHistogram;case 8:return Int8Histogram;case 16:return Int16Histogram;case 32:return Int32Histogram;case 64:return Float64Histogram;default:throw new Error("Incorrect parameter bitBucketSize")}}const{pow:pow$6,floor:floor$5}=Math,TWO_POW_7=pow$6(2,7),TWO_POW_14=pow$6(2,14),TWO_POW_21=pow$6(2,21),TWO_POW_28=pow$6(2,28),TWO_POW_35=pow$6(2,35),TWO_POW_42=pow$6(2,42),TWO_POW_49=pow$6(2,49),TWO_POW_56=pow$6(2,56);class ZigZagEncoding{static encode(t,e){e>=0?e*=2:e=2*-e-1,e<TWO_POW_7?t.put(e):(t.put(128|e),e<TWO_POW_14?t.put(floor$5(e/TWO_POW_7)):(t.put(128|floor$5(e/TWO_POW_7)),e<TWO_POW_21?t.put(floor$5(e/TWO_POW_14)):(t.put(128|floor$5(e/TWO_POW_14)),e<TWO_POW_28?t.put(floor$5(e/TWO_POW_21)):(t.put(128|floor$5(e/TWO_POW_21)),e<TWO_POW_35?t.put(floor$5(e/TWO_POW_28)):(t.put(128|floor$5(e/TWO_POW_28)),e<TWO_POW_42?t.put(floor$5(e/TWO_POW_35)):(t.put(128|floor$5(e/TWO_POW_35)),e<TWO_POW_49?t.put(floor$5(e/TWO_POW_42)):(t.put(128|floor$5(e/TWO_POW_42)),e<TWO_POW_56?t.put(floor$5(e/TWO_POW_49)):(t.put(floor$5(e/TWO_POW_49)+128),t.put(floor$5(e/TWO_POW_56))))))))))}static decode(t){let e=t.get(),r=127&e;return 0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_7,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_14,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_21,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_28,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_35,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_42,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_49,0!=(128&e)&&(e=t.get(),r+=(127&e)*TWO_POW_56)))))))),r%2==0?r/=2:r=-(r+1)/2,r}}const{max:max$2}=Math,V2EncodingCookieBase=478450435,V2CompressedEncodingCookieBase=478450436,V2maxWordSizeInBytes=9,encodingCookie=16|V2EncodingCookieBase,compressedEncodingCookie=16|V2CompressedEncodingCookieBase;function fillBufferFromCountsArray(t,e){const r=t.countsArrayIndex(t.maxValue)+1;let n=0;for(;n<r;){const i=t.getCountAtIndex(n++);if(i<0)throw new Error("Cannot encode histogram containing negative counts ("+i+") at index "+n+", corresponding the value range ["+t.lowestEquivalentValue(t.valueFromIndex(n))+","+t.nextNonEquivalentValue(t.valueFromIndex(n))+")");let o=0;if(0==i)for(o=1;n<r&&0==t.getCountAtIndex(n);)o++,n++;o>1?ZigZagEncoding.encode(e,-o):ZigZagEncoding.encode(e,i)}}function encodeIntoByteBuffer(t,e){const r=e.position;e.putInt32(encodingCookie),e.putInt32(0),e.putInt32(1),e.putInt32(t.numberOfSignificantValueDigits),e.putInt64(t.lowestDiscernibleValue),e.putInt64(t.highestTrackableValue),e.putInt64(1);const n=e.position;fillBufferFromCountsArray(t,e);const i=e.position;return e.position=r+4,e.putInt32(i-n),e.position=i,i-r}function fillCountsArrayFromSourceBuffer(t,e,r,n){if(2!=n&&4!=n&&8!=n&&n!=V2maxWordSizeInBytes)throw new Error("word size must be 2, 4, 8, or V2maxWordSizeInBytes ("+V2maxWordSizeInBytes+") bytes");let i=0;const o=e.position+r;for(;e.position<o;){let r=0,n=ZigZagEncoding.decode(e);n<0?(r=-n,i+=r):t.setCountAtIndex(i++,n)}return i}function getCookieBase(t){return-241&t}function getWordSizeInBytesFromCookie(t){if(getCookieBase(t)==V2EncodingCookieBase||getCookieBase(t)==V2CompressedEncodingCookieBase)return V2maxWordSizeInBytes;return 14&(240&t)>>4}function findDeflateFunction(){try{return eval('require("zlib").deflateSync')}catch(t){return pako?pako.deflate:()=>{throw new Error("pako library is mandatory for encoding/deconding on the browser side")}}}function findInflateFunction(){try{return eval('require("zlib").inflateSync')}catch(t){return pako?pako.inflate:()=>{throw new Error("pako library is mandatory for encoding/deconding on the browser side")}}}const deflate=findDeflateFunction(),inflate=findInflateFunction();function doDecode(t,e=32,r=0){const n=new ByteBuffer(t),i=n.getInt32();let o,s,a,u;if(getCookieBase(i)!==V2EncodingCookieBase)throw new Error("The buffer does not contain a Histogram (no valid V2 encoding cookie found)");if(getWordSizeInBytesFromCookie(i)!=V2maxWordSizeInBytes)throw new Error("The buffer does not contain a Histogram (no valid cookie found)");o=n.getInt32(),n.getInt32(),s=n.getInt32(),a=n.getInt64(),u=n.getInt64(),n.getInt64(),u=max$2(u,r);const l=new(constructorFromBucketSize(e))(a,u,s),h=fillCountsArrayFromSourceBuffer(l,n,o,V2maxWordSizeInBytes);return l.establishInternalTackingValues(h),l}function doEncodeIntoCompressedBase64(t){const e=t?{level:t}:{},r=ByteBuffer.allocate();r.putInt32(compressedEncodingCookie);const n=ByteBuffer.allocate(),i=encodeIntoByteBuffer(this,n),o=n.data.slice(0,i),s=deflate(o,e);return r.putInt32(s.byteLength),r.putArray(s),fromByteArray_1(r.data)}JsHistogram.decode=doDecode,JsHistogram.prototype.encodeIntoCompressedBase64=doEncodeIntoCompressedBase64;const V2CompressedEncodingCookieBase$1=478450436,compressedEncodingCookie$1=16|V2CompressedEncodingCookieBase$1;function decompress(t){const e=new ByteBuffer(t),r=e.position;if((-241&e.getInt32())!==V2CompressedEncodingCookieBase$1)throw new Error("Encoding not supported, only V2 is supported");const n=e.getInt32();return inflate(e.data.slice(r+8,r+8+n))}const decodeFromCompressedBase64=(t,e=32,r=!1,n=0)=>{const i=decompress(toByteArray_1(t.trim()));return r?WasmHistogram.decode(i,e,n):JsHistogram.decode(i,e,n)};function encodeWasmIntoCompressedBase64(t){const e=t?{level:t}:{},r=ByteBuffer.allocate();r.putInt32(compressedEncodingCookie$1);const n=this.encode(),i=deflate(n,e);return r.putInt32(i.byteLength),r.putArray(i),fromByteArray_1(r.data)}WasmHistogram.prototype.encodeIntoCompressedBase64=encodeWasmIntoCompressedBase64;const encodeIntoCompressedBase64=(t,e)=>{if(t instanceof WasmHistogram)return t.encodeIntoCompressedBase64(e);if(t instanceof JsHistogram)return t.encodeIntoCompressedBase64(e);throw new Error("Unsupported Histogram implementation")},TAG_PREFIX="Tag=",TAG_PREFIX_LENGTH="Tag=".length;class HistogramLogReader{constructor(t,e=32,r=!1){this.lines=splitLines(t),this.currentLineIndex=0,this.bitBucketSize=e,this.useWebAssembly=r}nextIntervalHistogram(t=0,e=Number.MAX_VALUE){for(;this.currentLineIndex<this.lines.length;){const r=this.lines[this.currentLineIndex];if(this.currentLineIndex++,r.startsWith("#[StartTime:"))this.parseStartTimeFromLine(r);else if(r.startsWith("#[BaseTime:"))this.parseBaseTimeFromLine(r);else if(r.startsWith("#")||r.startsWith('"StartTimestamp"'));else if(r.includes(",")){const n=r.split(","),[i]=n;let o;i.startsWith(TAG_PREFIX)?(o=i.substring(TAG_PREFIX_LENGTH),n.shift()):o=NO_TAG;const[s,a,,u]=n,l=Number.parseFloat(s);if(this.baseTimeSec||(l<this.startTimeSec-31536e3?this.baseTimeSec=this.startTimeSec:this.baseTimeSec=0),e<l)return null;if(l<t)continue;const h=decodeFromCompressedBase64(u,this.bitBucketSize,this.useWebAssembly);h.startTimeStampMsec=1e3*(this.baseTimeSec+l);const c=Number.parseFloat(a);return h.endTimeStampMsec=1e3*(this.baseTimeSec+l+c),h.tag=o,h}}return null}parseStartTimeFromLine(t){this.startTimeSec=Number.parseFloat(t.split(" ")[1])}parseBaseTimeFromLine(t){this.baseTimeSec=Number.parseFloat(t.split(" ")[1])}}const splitLines=t=>t.split(/\r\n|\r|\n/g),shouldIncludeNoTag=t=>t.find(t=>!t.startsWith("#")&&!t.startsWith('"')&&!t.startsWith(TAG_PREFIX)&&t.includes(",")),listTags=t=>{const e=splitLines(t),r=e.filter(t=>t.includes(",")&&t.startsWith(TAG_PREFIX)).map(t=>t.substring(TAG_PREFIX_LENGTH,t.indexOf(","))),n=new Set(r),i=Array.from(n);return shouldIncludeNoTag(e)&&i.unshift("NO TAG"),i},HISTOGRAM_LOG_FORMAT_VERSION="1.3",timeFormatter=floatFormatter(5,3);class HistogramLogWriter{constructor(t){this.log=t,this.baseTime=0}outputIntervalHistogram(t,e=(t.startTimeStampMsec-this.baseTime)/1e3,r=(t.endTimeStampMsec-this.baseTime)/1e3,n=1e3){const i=encodeIntoCompressedBase64(t),o=`${timeFormatter(e)},${timeFormatter(r-e)},${timeFormatter(t.maxValue/n)},${i}\n`;t.tag&&t.tag!==NO_TAG?this.log(`Tag=${t.tag},${o}`):this.log(o)}outputComment(t){this.log(`#${t}\n`)}outputStartTime(t){this.outputComment(`[StartTime: ${floatFormatter(5,3)(t/1e3)} (seconds since epoch), ${new Date(t)}]\n`)}outputLegend(){this.log('"StartTimestamp","Interval_Length","Interval_Max","Interval_Compressed_Histogram"\n')}outputLogFormatVersion(){this.outputComment("[Histogram log format version "+HISTOGRAM_LOG_FORMAT_VERSION+"]")}}const defaultRequest$1={bitBucketSize:32,autoResize:!0,lowestDiscernibleValue:1,highestTrackableValue:2,numberOfSignificantValueDigits:3,useWebAssembly:!1},build=(t=defaultRequest$1)=>{const e=Object.assign({},defaultRequest$1,t);if(t.useWebAssembly&&webAssemblyAvailable)return WasmHistogram.build(e);const r=new(constructorFromBucketSize(e.bitBucketSize))(e.lowestDiscernibleValue,e.highestTrackableValue,e.numberOfSignificantValueDigits);return r.autoResize=e.autoResize,r};class Recorder{constructor(t=defaultRequest$1,e=(()=>(new Date).getTime())){this.histogramBuildRequest=t,this.clock=e,this.activeHistogram=build(this.histogramBuildRequest),Recorder.idGenerator++,this.activeHistogram.containingInstanceId=Recorder.idGenerator,this.activeHistogram.startTimeStampMsec=e()}recordValue(t){this.activeHistogram.recordValue(t)}recordValueWithCount(t,e){this.activeHistogram.recordValueWithCount(t,e)}recordValueWithExpectedInterval(t,e){this.activeHistogram.recordValueWithExpectedInterval(t,e)}getIntervalHistogram(t){if(t){if(t.containingInstanceId!==this.activeHistogram.containingInstanceId)throw"replacement histogram must have been obtained via a previous getIntervalHistogram() call from this Recorder"}this.inactiveHistogram=t,this.performIntervalSample();const e=this.inactiveHistogram;return this.inactiveHistogram=null,e}getIntervalHistogramInto(t){this.performIntervalSample(),this.inactiveHistogram&&(t.add(this.inactiveHistogram),t.startTimeStampMsec=this.inactiveHistogram.startTimeStampMsec,t.endTimeStampMsec=this.inactiveHistogram.endTimeStampMsec)}reset(){this.activeHistogram.reset(),this.activeHistogram.startTimeStampMsec=this.clock()}performIntervalSample(){this.inactiveHistogram||(this.inactiveHistogram=build(this.histogramBuildRequest),this.inactiveHistogram.containingInstanceId=this.activeHistogram.containingInstanceId),this.inactiveHistogram.reset();const t=this.activeHistogram;this.activeHistogram=this.inactiveHistogram,this.inactiveHistogram=t;const e=this.clock();this.inactiveHistogram.endTimeStampMsec=e,this.activeHistogram.startTimeStampMsec=e}destroy(){var t;this.activeHistogram.destroy(),null===(t=this.inactiveHistogram)||void 0===t||t.destroy()}}Recorder.idGenerator=0,exports.ByteBuffer=ByteBuffer,exports.Float64Histogram=Float64Histogram,exports.HistogramLogReader=HistogramLogReader,exports.HistogramLogWriter=HistogramLogWriter,exports.Int16Histogram=Int16Histogram,exports.Int32Histogram=Int32Histogram,exports.Int8Histogram=Int8Histogram,exports.JsHistogram=JsHistogram,exports.PackedHistogram=PackedHistogram,exports.Recorder=Recorder,exports.WasmHistogram=WasmHistogram,exports.build=build,exports.decodeFromCompressedBase64=decodeFromCompressedBase64,exports.encodeIntoCompressedBase64=encodeIntoCompressedBase64,exports.initWebAssembly=initWebAssembly,exports.initWebAssemblySync=initWebAssemblySync,exports.listTags=listTags,Object.defineProperty(exports,"__esModule",{value:!0})}));