decocms 2.333.0 → 2.334.0

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/Buckets.js

@@ -0,0 +1,273 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export class Buckets {
+    backing;
+    indexBase;
+    indexStart;
+    indexEnd;
+    /**
+     * The term index refers to the number of the exponential histogram bucket
+     * used to determine its boundaries. The lower boundary of a bucket is
+     * determined by base ** index and the upper boundary of a bucket is
+     * determined by base ** (index + 1). index values are signed to account
+     * for values less than or equal to 1.
+     *
+     * indexBase is the index of the 0th position in the
+     * backing array, i.e., backing[0] is the count
+     * in the bucket with index `indexBase`.
+     *
+     * indexStart is the smallest index value represented
+     * in the backing array.
+     *
+     * indexEnd is the largest index value represented in
+     * the backing array.
+     */
+    constructor(backing = new BucketsBacking(), indexBase = 0, indexStart = 0, indexEnd = 0) {
+        this.backing = backing;
+        this.indexBase = indexBase;
+        this.indexStart = indexStart;
+        this.indexEnd = indexEnd;
+    }
+    /**
+     * Offset is the bucket index of the smallest entry in the counts array
+     * @returns {number}
+     */
+    get offset() {
+        return this.indexStart;
+    }
+    /**
+     * Buckets is a view into the backing array.
+     * @returns {number}
+     */
+    get length() {
+        if (this.backing.length === 0) {
+            return 0;
+        }
+        if (this.indexEnd === this.indexStart && this.at(0) === 0) {
+            return 0;
+        }
+        return this.indexEnd - this.indexStart + 1;
+    }
+    /**
+     * An array of counts, where count[i] carries the count
+     * of the bucket at index (offset+i).  count[i] is the count of
+     * values greater than base^(offset+i) and less than or equal to
+     * base^(offset+i+1).
+     * @returns {number} The logical counts based on the backing array
+     */
+    counts() {
+        return Array.from({ length: this.length }, (_, i) => this.at(i));
+    }
+    /**
+     * At returns the count of the bucket at a position in the logical
+     * array of counts.
+     * @param position
+     * @returns {number}
+     */
+    at(position) {
+        const bias = this.indexBase - this.indexStart;
+        if (position < bias) {
+            position += this.backing.length;
+        }
+        position -= bias;
+        return this.backing.countAt(position);
+    }
+    /**
+     * incrementBucket increments the backing array index by `increment`
+     * @param bucketIndex
+     * @param increment
+     */
+    incrementBucket(bucketIndex, increment) {
+        this.backing.increment(bucketIndex, increment);
+    }
+    /**
+     * decrementBucket decrements the backing array index by `decrement`
+     * if decrement is greater than the current value, it's set to 0.
+     * @param bucketIndex
+     * @param decrement
+     */
+    decrementBucket(bucketIndex, decrement) {
+        this.backing.decrement(bucketIndex, decrement);
+    }
+    /**
+     * trim removes leading and / or trailing zero buckets (which can occur
+     * after diffing two histos) and rotates the backing array so that the
+     * smallest non-zero index is in the 0th position of the backing array
+     */
+    trim() {
+        for (let i = 0; i < this.length; i++) {
+            if (this.at(i) !== 0) {
+                this.indexStart += i;
+                break;
+            }
+            else if (i === this.length - 1) {
+                //the entire array is zeroed out
+                this.indexStart = this.indexEnd = this.indexBase = 0;
+                return;
+            }
+        }
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (this.at(i) !== 0) {
+                this.indexEnd -= this.length - i - 1;
+                break;
+            }
+        }
+        this._rotate();
+    }
+    /**
+     * downscale first rotates, then collapses 2**`by`-to-1 buckets.
+     * @param by
+     */
+    downscale(by) {
+        this._rotate();
+        const size = 1 + this.indexEnd - this.indexStart;
+        const each = 1 << by;
+        let inpos = 0;
+        let outpos = 0;
+        for (let pos = this.indexStart; pos <= this.indexEnd;) {
+            let mod = pos % each;
+            if (mod < 0) {
+                mod += each;
+            }
+            for (let i = mod; i < each && inpos < size; i++) {
+                this._relocateBucket(outpos, inpos);
+                inpos++;
+                pos++;
+            }
+            outpos++;
+        }
+        this.indexStart >>= by;
+        this.indexEnd >>= by;
+        this.indexBase = this.indexStart;
+    }
+    /**
+     * Clone returns a deep copy of Buckets
+     * @returns {Buckets}
+     */
+    clone() {
+        return new Buckets(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd);
+    }
+    /**
+     * _rotate shifts the backing array contents so that indexStart ==
+     * indexBase to simplify the downscale logic.
+     */
+    _rotate() {
+        const bias = this.indexBase - this.indexStart;
+        if (bias === 0) {
+            return;
+        }
+        else if (bias > 0) {
+            this.backing.reverse(0, this.backing.length);
+            this.backing.reverse(0, bias);
+            this.backing.reverse(bias, this.backing.length);
+        }
+        else {
+            // negative bias, this can happen when diffing two histograms
+            this.backing.reverse(0, this.backing.length);
+            this.backing.reverse(0, this.backing.length + bias);
+        }
+        this.indexBase = this.indexStart;
+    }
+    /**
+     * _relocateBucket adds the count in counts[src] to counts[dest] and
+     * resets count[src] to zero.
+     */
+    _relocateBucket(dest, src) {
+        if (dest === src) {
+            return;
+        }
+        this.incrementBucket(dest, this.backing.emptyBucket(src));
+    }
+}
+/**
+ * BucketsBacking holds the raw buckets and some utility methods to
+ * manage them.
+ */
+class BucketsBacking {
+    _counts;
+    constructor(_counts = [0]) {
+        this._counts = _counts;
+    }
+    /**
+     * length returns the physical size of the backing array, which
+     * is >= buckets.length()
+     */
+    get length() {
+        return this._counts.length;
+    }
+    /**
+     * countAt returns the count in a specific bucket
+     */
+    countAt(pos) {
+        return this._counts[pos];
+    }
+    /**
+     * growTo grows a backing array and copies old entries
+     * into their correct new positions.
+     */
+    growTo(newSize, oldPositiveLimit, newPositiveLimit) {
+        const tmp = new Array(newSize).fill(0);
+        tmp.splice(newPositiveLimit, this._counts.length - oldPositiveLimit, ...this._counts.slice(oldPositiveLimit));
+        tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit));
+        this._counts = tmp;
+    }
+    /**
+     * reverse the items in the backing array in the range [from, limit).
+     */
+    reverse(from, limit) {
+        const num = Math.floor((from + limit) / 2) - from;
+        for (let i = 0; i < num; i++) {
+            const tmp = this._counts[from + i];
+            this._counts[from + i] = this._counts[limit - i - 1];
+            this._counts[limit - i - 1] = tmp;
+        }
+    }
+    /**
+     * emptyBucket empties the count from a bucket, for
+     * moving into another.
+     */
+    emptyBucket(src) {
+        const tmp = this._counts[src];
+        this._counts[src] = 0;
+        return tmp;
+    }
+    /**
+     * increments a bucket by `increment`
+     */
+    increment(bucketIndex, increment) {
+        this._counts[bucketIndex] += increment;
+    }
+    /**
+     * decrements a bucket by `decrement`
+     */
+    decrement(bucketIndex, decrement) {
+        if (this._counts[bucketIndex] >= decrement) {
+            this._counts[bucketIndex] -= decrement;
+        }
+        else {
+            // this should not happen, but we're being defensive against
+            // negative counts.
+            this._counts[bucketIndex] = 0;
+        }
+    }
+    /**
+     * clone returns a deep copy of BucketsBacking
+     */
+    clone() {
+        return new BucketsBacking([...this._counts]);
+    }
+}
+//# sourceMappingURL=Buckets.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/Buckets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Buckets.js","sourceRoot":"","sources":["../../../../src/aggregator/exponential-histogram/Buckets.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport class Buckets {\n  /**\n   * The term index refers to the number of the exponential histogram bucket\n   * used to determine its boundaries. The lower boundary of a bucket is\n   * determined by base ** index and the upper boundary of a bucket is\n   * determined by base ** (index + 1). index values are signed to account\n   * for values less than or equal to 1.\n   *\n   * indexBase is the index of the 0th position in the\n   * backing array, i.e., backing[0] is the count\n   * in the bucket with index `indexBase`.\n   *\n   * indexStart is the smallest index value represented\n   * in the backing array.\n   *\n   * indexEnd is the largest index value represented in\n   * the backing array.\n   */\n  constructor(\n    public backing = new BucketsBacking(),\n    public indexBase = 0,\n    public indexStart = 0,\n    public indexEnd = 0\n  ) {}\n\n  /**\n   * Offset is the bucket index of the smallest entry in the counts array\n   * @returns {number}\n   */\n  get offset(): number {\n    return this.indexStart;\n  }\n\n  /**\n   * Buckets is a view into the backing array.\n   * @returns {number}\n   */\n  get length(): number {\n    if (this.backing.length === 0) {\n      return 0;\n    }\n\n    if (this.indexEnd === this.indexStart && this.at(0) === 0) {\n      return 0;\n    }\n\n    return this.indexEnd - this.indexStart + 1;\n  }\n\n  /**\n   * An array of counts, where count[i] carries the count\n   * of the bucket at index (offset+i).  count[i] is the count of\n   * values greater than base^(offset+i) and less than or equal to\n   * base^(offset+i+1).\n   * @returns {number} The logical counts based on the backing array\n   */\n  counts(): number[] {\n    return Array.from({ length: this.length }, (_, i) => this.at(i));\n  }\n\n  /**\n   * At returns the count of the bucket at a position in the logical\n   * array of counts.\n   * @param position\n   * @returns {number}\n   */\n  at(position: number): number {\n    const bias = this.indexBase - this.indexStart;\n    if (position < bias) {\n      position += this.backing.length;\n    }\n\n    position -= bias;\n    return this.backing.countAt(position);\n  }\n\n  /**\n   * incrementBucket increments the backing array index by `increment`\n   * @param bucketIndex\n   * @param increment\n   */\n  incrementBucket(bucketIndex: number, increment: number) {\n    this.backing.increment(bucketIndex, increment);\n  }\n\n  /**\n   * decrementBucket decrements the backing array index by `decrement`\n   * if decrement is greater than the current value, it's set to 0.\n   * @param bucketIndex\n   * @param decrement\n   */\n  decrementBucket(bucketIndex: number, decrement: number) {\n    this.backing.decrement(bucketIndex, decrement);\n  }\n\n  /**\n   * trim removes leading and / or trailing zero buckets (which can occur\n   * after diffing two histos) and rotates the backing array so that the\n   * smallest non-zero index is in the 0th position of the backing array\n   */\n  trim() {\n    for (let i = 0; i < this.length; i++) {\n      if (this.at(i) !== 0) {\n        this.indexStart += i;\n        break;\n      } else if (i === this.length - 1) {\n        //the entire array is zeroed out\n        this.indexStart = this.indexEnd = this.indexBase = 0;\n        return;\n      }\n    }\n\n    for (let i = this.length - 1; i >= 0; i--) {\n      if (this.at(i) !== 0) {\n        this.indexEnd -= this.length - i - 1;\n        break;\n      }\n    }\n\n    this._rotate();\n  }\n\n  /**\n   * downscale first rotates, then collapses 2**`by`-to-1 buckets.\n   * @param by\n   */\n  downscale(by: number) {\n    this._rotate();\n\n    const size = 1 + this.indexEnd - this.indexStart;\n    const each = 1 << by;\n    let inpos = 0;\n    let outpos = 0;\n\n    for (let pos = this.indexStart; pos <= this.indexEnd; ) {\n      let mod = pos % each;\n      if (mod < 0) {\n        mod += each;\n      }\n      for (let i = mod; i < each && inpos < size; i++) {\n        this._relocateBucket(outpos, inpos);\n        inpos++;\n        pos++;\n      }\n      outpos++;\n    }\n\n    this.indexStart >>= by;\n    this.indexEnd >>= by;\n    this.indexBase = this.indexStart;\n  }\n\n  /**\n   * Clone returns a deep copy of Buckets\n   * @returns {Buckets}\n   */\n  clone(): Buckets {\n    return new Buckets(\n      this.backing.clone(),\n      this.indexBase,\n      this.indexStart,\n      this.indexEnd\n    );\n  }\n\n  /**\n   * _rotate shifts the backing array contents so that indexStart ==\n   * indexBase to simplify the downscale logic.\n   */\n  private _rotate() {\n    const bias = this.indexBase - this.indexStart;\n\n    if (bias === 0) {\n      return;\n    } else if (bias > 0) {\n      this.backing.reverse(0, this.backing.length);\n      this.backing.reverse(0, bias);\n      this.backing.reverse(bias, this.backing.length);\n    } else {\n      // negative bias, this can happen when diffing two histograms\n      this.backing.reverse(0, this.backing.length);\n      this.backing.reverse(0, this.backing.length + bias);\n    }\n    this.indexBase = this.indexStart;\n  }\n\n  /**\n   * _relocateBucket adds the count in counts[src] to counts[dest] and\n   * resets count[src] to zero.\n   */\n  private _relocateBucket(dest: number, src: number) {\n    if (dest === src) {\n      return;\n    }\n    this.incrementBucket(dest, this.backing.emptyBucket(src));\n  }\n}\n\n/**\n * BucketsBacking holds the raw buckets and some utility methods to\n * manage them.\n */\nclass BucketsBacking {\n  constructor(private _counts = [0]) {}\n\n  /**\n   * length returns the physical size of the backing array, which\n   * is >= buckets.length()\n   */\n  get length(): number {\n    return this._counts.length;\n  }\n\n  /**\n   * countAt returns the count in a specific bucket\n   */\n  countAt(pos: number): number {\n    return this._counts[pos];\n  }\n\n  /**\n   * growTo grows a backing array and copies old entries\n   * into their correct new positions.\n   */\n  growTo(newSize: number, oldPositiveLimit: number, newPositiveLimit: number) {\n    const tmp = new Array<number>(newSize).fill(0);\n    tmp.splice(\n      newPositiveLimit,\n      this._counts.length - oldPositiveLimit,\n      ...this._counts.slice(oldPositiveLimit)\n    );\n    tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit));\n    this._counts = tmp;\n  }\n\n  /**\n   * reverse the items in the backing array in the range [from, limit).\n   */\n  reverse(from: number, limit: number) {\n    const num = Math.floor((from + limit) / 2) - from;\n    for (let i = 0; i < num; i++) {\n      const tmp = this._counts[from + i];\n      this._counts[from + i] = this._counts[limit - i - 1];\n      this._counts[limit - i - 1] = tmp;\n    }\n  }\n\n  /**\n   * emptyBucket empties the count from a bucket, for\n   * moving into another.\n   */\n  emptyBucket(src: number): number {\n    const tmp = this._counts[src];\n    this._counts[src] = 0;\n    return tmp;\n  }\n\n  /**\n   * increments a bucket by `increment`\n   */\n  increment(bucketIndex: number, increment: number) {\n    this._counts[bucketIndex] += increment;\n  }\n\n  /**\n   * decrements a bucket by `decrement`\n   */\n  decrement(bucketIndex: number, decrement: number) {\n    if (this._counts[bucketIndex] >= decrement) {\n      this._counts[bucketIndex] -= decrement;\n    } else {\n      // this should not happen, but we're being defensive against\n      // negative counts.\n      this._counts[bucketIndex] = 0;\n    }\n  }\n\n  /**\n   * clone returns a deep copy of BucketsBacking\n   */\n  clone(): BucketsBacking {\n    return new BucketsBacking([...this._counts]);\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/ExponentMapping.d.ts

@@ -0,0 +1,31 @@
+import { Mapping } from './types';
+/**
+ * ExponentMapping implements exponential mapping functions for
+ * scales <=0. For scales > 0 LogarithmMapping should be used.
+ */
+export declare class ExponentMapping implements Mapping {
+    private readonly _shift;
+    constructor(scale: number);
+    /**
+     * Maps positive floating point values to indexes corresponding to scale
+     * @param value
+     * @returns {number} index for provided value at the current scale
+     */
+    mapToIndex(value: number): number;
+    /**
+     * Returns the lower bucket boundary for the given index for scale
+     *
+     * @param index
+     * @returns {number}
+     */
+    lowerBoundary(index: number): number;
+    /**
+     * The scale used by this mapping
+     * @returns {number}
+     */
+    get scale(): number;
+    private _minNormalLowerBoundaryIndex;
+    private _maxNormalLowerBoundaryIndex;
+    private _rightShift;
+}
+//# sourceMappingURL=ExponentMapping.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/ExponentMapping.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ieee754 from './ieee754';
+import * as util from '../util';
+import { MappingError } from './types';
+/**
+ * ExponentMapping implements exponential mapping functions for
+ * scales <=0. For scales > 0 LogarithmMapping should be used.
+ */
+export class ExponentMapping {
+    _shift;
+    constructor(scale) {
+        this._shift = -scale;
+    }
+    /**
+     * Maps positive floating point values to indexes corresponding to scale
+     * @param value
+     * @returns {number} index for provided value at the current scale
+     */
+    mapToIndex(value) {
+        if (value < ieee754.MIN_VALUE) {
+            return this._minNormalLowerBoundaryIndex();
+        }
+        const exp = ieee754.getNormalBase2(value);
+        // In case the value is an exact power of two, compute a
+        // correction of -1. Note, we are using a custom _rightShift
+        // to accommodate a 52-bit argument, which the native bitwise
+        // operators do not support
+        const correction = this._rightShift(ieee754.getSignificand(value) - 1, ieee754.SIGNIFICAND_WIDTH);
+        return (exp + correction) >> this._shift;
+    }
+    /**
+     * Returns the lower bucket boundary for the given index for scale
+     *
+     * @param index
+     * @returns {number}
+     */
+    lowerBoundary(index) {
+        const minIndex = this._minNormalLowerBoundaryIndex();
+        if (index < minIndex) {
+            throw new MappingError(`underflow: ${index} is < minimum lower boundary: ${minIndex}`);
+        }
+        const maxIndex = this._maxNormalLowerBoundaryIndex();
+        if (index > maxIndex) {
+            throw new MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+        }
+        return util.ldexp(1, index << this._shift);
+    }
+    /**
+     * The scale used by this mapping
+     * @returns {number}
+     */
+    get scale() {
+        if (this._shift === 0) {
+            return 0;
+        }
+        return -this._shift;
+    }
+    _minNormalLowerBoundaryIndex() {
+        let index = ieee754.MIN_NORMAL_EXPONENT >> this._shift;
+        if (this._shift < 2) {
+            index--;
+        }
+        return index;
+    }
+    _maxNormalLowerBoundaryIndex() {
+        return ieee754.MAX_NORMAL_EXPONENT >> this._shift;
+    }
+    _rightShift(value, shift) {
+        return Math.floor(value * Math.pow(2, -shift));
+    }
+}
+//# sourceMappingURL=ExponentMapping.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/ExponentMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExponentMapping.js","sourceRoot":"","sources":["../../../../../src/aggregator/exponential-histogram/mapping/ExponentMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,EAAW,YAAY,EAAE,MAAM,SAAS,CAAC;AAEhD;;;GAGG;AACH,MAAM,OAAO,eAAe;IACT,MAAM,CAAS;IAEhC,YAAY,KAAa;QACvB,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,KAAa;QACtB,IAAI,KAAK,GAAG,OAAO,CAAC,SAAS,EAAE;YAC7B,OAAO,IAAI,CAAC,4BAA4B,EAAE,CAAC;SAC5C;QAED,MAAM,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAE1C,wDAAwD;QACxD,4DAA4D;QAC5D,6DAA6D;QAC7D,2BAA2B;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CACjC,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,EACjC,OAAO,CAAC,iBAAiB,CAC1B,CAAC;QAEF,OAAO,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,KAAa;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACrD,IAAI,KAAK,GAAG,QAAQ,EAAE;YACpB,MAAM,IAAI,YAAY,CACpB,cAAc,KAAK,iCAAiC,QAAQ,EAAE,CAC/D,CAAC;SACH;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QACrD,IAAI,KAAK,GAAG,QAAQ,EAAE;YACpB,MAAM,IAAI,YAAY,CACpB,aAAa,KAAK,iCAAiC,QAAQ,EAAE,CAC9D,CAAC;SACH;QAED,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACH,IAAI,KAAK;QACP,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YACrB,OAAO,CAAC,CAAC;SACV;QACD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;IACtB,CAAC;IAEO,4BAA4B;QAClC,IAAI,KAAK,GAAG,OAAO,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,CAAC;QACvD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YACnB,KAAK,EAAE,CAAC;SACT;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,4BAA4B;QAClC,OAAO,OAAO,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,CAAC;IACpD,CAAC;IAEO,WAAW,CAAC,KAAa,EAAE,KAAa;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as ieee754 from './ieee754';\nimport * as util from '../util';\nimport { Mapping, MappingError } from './types';\n\n/**\n * ExponentMapping implements exponential mapping functions for\n * scales <=0. For scales > 0 LogarithmMapping should be used.\n */\nexport class ExponentMapping implements Mapping {\n  private readonly _shift: number;\n\n  constructor(scale: number) {\n    this._shift = -scale;\n  }\n\n  /**\n   * Maps positive floating point values to indexes corresponding to scale\n   * @param value\n   * @returns {number} index for provided value at the current scale\n   */\n  mapToIndex(value: number): number {\n    if (value < ieee754.MIN_VALUE) {\n      return this._minNormalLowerBoundaryIndex();\n    }\n\n    const exp = ieee754.getNormalBase2(value);\n\n    // In case the value is an exact power of two, compute a\n    // correction of -1. Note, we are using a custom _rightShift\n    // to accommodate a 52-bit argument, which the native bitwise\n    // operators do not support\n    const correction = this._rightShift(\n      ieee754.getSignificand(value) - 1,\n      ieee754.SIGNIFICAND_WIDTH\n    );\n\n    return (exp + correction) >> this._shift;\n  }\n\n  /**\n   * Returns the lower bucket boundary for the given index for scale\n   *\n   * @param index\n   * @returns {number}\n   */\n  lowerBoundary(index: number): number {\n    const minIndex = this._minNormalLowerBoundaryIndex();\n    if (index < minIndex) {\n      throw new MappingError(\n        `underflow: ${index} is < minimum lower boundary: ${minIndex}`\n      );\n    }\n    const maxIndex = this._maxNormalLowerBoundaryIndex();\n    if (index > maxIndex) {\n      throw new MappingError(\n        `overflow: ${index} is > maximum lower boundary: ${maxIndex}`\n      );\n    }\n\n    return util.ldexp(1, index << this._shift);\n  }\n\n  /**\n   * The scale used by this mapping\n   * @returns {number}\n   */\n  get scale(): number {\n    if (this._shift === 0) {\n      return 0;\n    }\n    return -this._shift;\n  }\n\n  private _minNormalLowerBoundaryIndex(): number {\n    let index = ieee754.MIN_NORMAL_EXPONENT >> this._shift;\n    if (this._shift < 2) {\n      index--;\n    }\n\n    return index;\n  }\n\n  private _maxNormalLowerBoundaryIndex(): number {\n    return ieee754.MAX_NORMAL_EXPONENT >> this._shift;\n  }\n\n  private _rightShift(value: number, shift: number): number {\n    return Math.floor(value * Math.pow(2, -shift));\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/LogarithmMapping.d.ts

@@ -0,0 +1,32 @@
+import { Mapping } from './types';
+/**
+ * LogarithmMapping implements exponential mapping functions for scale > 0.
+ * For scales <= 0 the exponent mapping should be used.
+ */
+export declare class LogarithmMapping implements Mapping {
+    private readonly _scale;
+    private readonly _scaleFactor;
+    private readonly _inverseFactor;
+    constructor(scale: number);
+    /**
+     * Maps positive floating point values to indexes corresponding to scale
+     * @param value
+     * @returns {number} index for provided value at the current scale
+     */
+    mapToIndex(value: number): number;
+    /**
+     * Returns the lower bucket boundary for the given index for scale
+     *
+     * @param index
+     * @returns {number}
+     */
+    lowerBoundary(index: number): number;
+    /**
+     * The scale used by this mapping
+     * @returns {number}
+     */
+    get scale(): number;
+    private _minNormalLowerBoundaryIndex;
+    private _maxNormalLowerBoundaryIndex;
+}
+//# sourceMappingURL=LogarithmMapping.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/LogarithmMapping.js

@@ -0,0 +1,94 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ieee754 from './ieee754';
+import * as util from '../util';
+import { MappingError } from './types';
+/**
+ * LogarithmMapping implements exponential mapping functions for scale > 0.
+ * For scales <= 0 the exponent mapping should be used.
+ */
+export class LogarithmMapping {
+    _scale;
+    _scaleFactor;
+    _inverseFactor;
+    constructor(scale) {
+        this._scale = scale;
+        this._scaleFactor = util.ldexp(Math.LOG2E, scale);
+        this._inverseFactor = util.ldexp(Math.LN2, -scale);
+    }
+    /**
+     * Maps positive floating point values to indexes corresponding to scale
+     * @param value
+     * @returns {number} index for provided value at the current scale
+     */
+    mapToIndex(value) {
+        if (value <= ieee754.MIN_VALUE) {
+            return this._minNormalLowerBoundaryIndex() - 1;
+        }
+        // exact power of two special case
+        if (ieee754.getSignificand(value) === 0) {
+            const exp = ieee754.getNormalBase2(value);
+            return (exp << this._scale) - 1;
+        }
+        // non-power of two cases. use Math.floor to round the scaled logarithm
+        const index = Math.floor(Math.log(value) * this._scaleFactor);
+        const maxIndex = this._maxNormalLowerBoundaryIndex();
+        if (index >= maxIndex) {
+            return maxIndex;
+        }
+        return index;
+    }
+    /**
+     * Returns the lower bucket boundary for the given index for scale
+     *
+     * @param index
+     * @returns {number}
+     */
+    lowerBoundary(index) {
+        const maxIndex = this._maxNormalLowerBoundaryIndex();
+        if (index >= maxIndex) {
+            if (index === maxIndex) {
+                return 2 * Math.exp((index - (1 << this._scale)) / this._scaleFactor);
+            }
+            throw new MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+        }
+        const minIndex = this._minNormalLowerBoundaryIndex();
+        if (index <= minIndex) {
+            if (index === minIndex) {
+                return ieee754.MIN_VALUE;
+            }
+            else if (index === minIndex - 1) {
+                return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2;
+            }
+            throw new MappingError(`overflow: ${index} is < minimum lower boundary: ${minIndex}`);
+        }
+        return Math.exp(index * this._inverseFactor);
+    }
+    /**
+     * The scale used by this mapping
+     * @returns {number}
+     */
+    get scale() {
+        return this._scale;
+    }
+    _minNormalLowerBoundaryIndex() {
+        return ieee754.MIN_NORMAL_EXPONENT << this._scale;
+    }
+    _maxNormalLowerBoundaryIndex() {
+        return ((ieee754.MAX_NORMAL_EXPONENT + 1) << this._scale) - 1;
+    }
+}
+//# sourceMappingURL=LogarithmMapping.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/LogarithmMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogarithmMapping.js","sourceRoot":"","sources":["../../../../../src/aggregator/exponential-histogram/mapping/LogarithmMapping.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as ieee754 from './ieee754';\nimport * as util from '../util';\nimport { Mapping, MappingError } from './types';\n\n/**\n * LogarithmMapping implements exponential mapping functions for scale > 0.\n * For scales <= 0 the exponent mapping should be used.\n */\nexport class LogarithmMapping implements Mapping {\n  private readonly _scale: number;\n  private readonly _scaleFactor: number;\n  private readonly _inverseFactor: number;\n\n  constructor(scale: number) {\n    this._scale = scale;\n    this._scaleFactor = util.ldexp(Math.LOG2E, scale);\n    this._inverseFactor = util.ldexp(Math.LN2, -scale);\n  }\n\n  /**\n   * Maps positive floating point values to indexes corresponding to scale\n   * @param value\n   * @returns {number} index for provided value at the current scale\n   */\n  mapToIndex(value: number): number {\n    if (value <= ieee754.MIN_VALUE) {\n      return this._minNormalLowerBoundaryIndex() - 1;\n    }\n\n    // exact power of two special case\n    if (ieee754.getSignificand(value) === 0) {\n      const exp = ieee754.getNormalBase2(value);\n      return (exp << this._scale) - 1;\n    }\n\n    // non-power of two cases. use Math.floor to round the scaled logarithm\n    const index = Math.floor(Math.log(value) * this._scaleFactor);\n    const maxIndex = this._maxNormalLowerBoundaryIndex();\n    if (index >= maxIndex) {\n      return maxIndex;\n    }\n\n    return index;\n  }\n\n  /**\n   * Returns the lower bucket boundary for the given index for scale\n   *\n   * @param index\n   * @returns {number}\n   */\n  lowerBoundary(index: number): number {\n    const maxIndex = this._maxNormalLowerBoundaryIndex();\n    if (index >= maxIndex) {\n      if (index === maxIndex) {\n        return 2 * Math.exp((index - (1 << this._scale)) / this._scaleFactor);\n      }\n      throw new MappingError(\n        `overflow: ${index} is > maximum lower boundary: ${maxIndex}`\n      );\n    }\n\n    const minIndex = this._minNormalLowerBoundaryIndex();\n    if (index <= minIndex) {\n      if (index === minIndex) {\n        return ieee754.MIN_VALUE;\n      } else if (index === minIndex - 1) {\n        return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2;\n      }\n      throw new MappingError(\n        `overflow: ${index} is < minimum lower boundary: ${minIndex}`\n      );\n    }\n\n    return Math.exp(index * this._inverseFactor);\n  }\n\n  /**\n   * The scale used by this mapping\n   * @returns {number}\n   */\n  get scale(): number {\n    return this._scale;\n  }\n\n  private _minNormalLowerBoundaryIndex(): number {\n    return ieee754.MIN_NORMAL_EXPONENT << this._scale;\n  }\n\n  private _maxNormalLowerBoundaryIndex(): number {\n    return ((ieee754.MAX_NORMAL_EXPONENT + 1) << this._scale) - 1;\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/getMapping.d.ts

@@ -0,0 +1,10 @@
+import { Mapping } from './types';
+/**
+ * getMapping returns an appropriate mapping for the given scale. For scales -10
+ * to 0 the underlying type will be ExponentMapping. For scales 1 to 20 the
+ * underlying type will be LogarithmMapping.
+ * @param scale a number in the range [-10, 20]
+ * @returns {Mapping}
+ */
+export declare function getMapping(scale: number): Mapping;
+//# sourceMappingURL=getMapping.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/getMapping.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ExponentMapping } from './ExponentMapping';
+import { LogarithmMapping } from './LogarithmMapping';
+import { MappingError } from './types';
+const MIN_SCALE = -10;
+const MAX_SCALE = 20;
+const PREBUILT_MAPPINGS = Array.from({ length: 31 }, (_, i) => {
+    if (i > 10) {
+        return new LogarithmMapping(i - 10);
+    }
+    return new ExponentMapping(i - 10);
+});
+/**
+ * getMapping returns an appropriate mapping for the given scale. For scales -10
+ * to 0 the underlying type will be ExponentMapping. For scales 1 to 20 the
+ * underlying type will be LogarithmMapping.
+ * @param scale a number in the range [-10, 20]
+ * @returns {Mapping}
+ */
+export function getMapping(scale) {
+    if (scale > MAX_SCALE || scale < MIN_SCALE) {
+        throw new MappingError(`expected scale >= ${MIN_SCALE} && <= ${MAX_SCALE}, got: ${scale}`);
+    }
+    // mappings are offset by 10. scale -10 is at position 0 and scale 20 is at 30
+    return PREBUILT_MAPPINGS[scale + 10];
+}
+//# sourceMappingURL=getMapping.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/aggregator/exponential-histogram/mapping/getMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMapping.js","sourceRoot":"","sources":["../../../../../src/aggregator/exponential-histogram/mapping/getMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAW,MAAM,SAAS,CAAC;AAEhD,MAAM,SAAS,GAAG,CAAC,EAAE,CAAC;AACtB,MAAM,SAAS,GAAG,EAAE,CAAC;AACrB,MAAM,iBAAiB,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;IAC5D,IAAI,CAAC,GAAG,EAAE,EAAE;QACV,OAAO,IAAI,gBAAgB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;KACrC;IACD,OAAO,IAAI,eAAe,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;AACrC,CAAC,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,IAAI,KAAK,GAAG,SAAS,IAAI,KAAK,GAAG,SAAS,EAAE;QAC1C,MAAM,IAAI,YAAY,CACpB,qBAAqB,SAAS,UAAU,SAAS,UAAU,KAAK,EAAE,CACnE,CAAC;KACH;IACD,8EAA8E;IAC9E,OAAO,iBAAiB,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC;AACvC,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ExponentMapping } from './ExponentMapping';\nimport { LogarithmMapping } from './LogarithmMapping';\nimport { MappingError, Mapping } from './types';\n\nconst MIN_SCALE = -10;\nconst MAX_SCALE = 20;\nconst PREBUILT_MAPPINGS = Array.from({ length: 31 }, (_, i) => {\n  if (i > 10) {\n    return new LogarithmMapping(i - 10);\n  }\n  return new ExponentMapping(i - 10);\n});\n\n/**\n * getMapping returns an appropriate mapping for the given scale. For scales -10\n * to 0 the underlying type will be ExponentMapping. For scales 1 to 20 the\n * underlying type will be LogarithmMapping.\n * @param scale a number in the range [-10, 20]\n * @returns {Mapping}\n */\nexport function getMapping(scale: number): Mapping {\n  if (scale > MAX_SCALE || scale < MIN_SCALE) {\n    throw new MappingError(\n      `expected scale >= ${MIN_SCALE} && <= ${MAX_SCALE}, got: ${scale}`\n    );\n  }\n  // mappings are offset by 10. scale -10 is at position 0 and scale 20 is at 30\n  return PREBUILT_MAPPINGS[scale + 10];\n}\n"]}