@safaricom-mxl/web-sdk 0.0.18 → 0.0.19

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"LastValue.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.LastValueAggregator = exports.LastValueAccumulation = void 0;\nconst types_1 = require(\"./types\");\nconst core_1 = require(\"@opentelemetry/core\");\nconst MetricData_1 = require(\"../export/MetricData\");\nclass LastValueAccumulation {\n    startTime;\n    _current;\n    sampleTime;\n    constructor(startTime, current = 0, sampleTime = [0, 0]) {\n        this.startTime = startTime;\n        this._current = current;\n        this.sampleTime = sampleTime;\n    }\n    record(value) {\n        this._current = value;\n        this.sampleTime = (0, core_1.millisToHrTime)(Date.now());\n    }\n    setStartTime(startTime) {\n        this.startTime = startTime;\n    }\n    toPointValue() {\n        return this._current;\n    }\n}\nexports.LastValueAccumulation = LastValueAccumulation;\n/** Basic aggregator which calculates a LastValue from individual measurements. */\nclass LastValueAggregator {\n    kind = types_1.AggregatorKind.LAST_VALUE;\n    createAccumulation(startTime) {\n        return new LastValueAccumulation(startTime);\n    }\n    /**\n     * Returns the result of the merge of the given accumulations.\n     *\n     * Return the newly captured (delta) accumulation for LastValueAggregator.\n     */\n    merge(previous, delta) {\n        // nanoseconds may lose precisions.\n        const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(delta.sampleTime) >=\n            (0, core_1.hrTimeToMicroseconds)(previous.sampleTime)\n            ? delta\n            : previous;\n        return new LastValueAccumulation(previous.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);\n    }\n    /**\n     * Returns a new DELTA aggregation by comparing two cumulative measurements.\n     *\n     * A delta aggregation is not meaningful to LastValueAggregator, just return\n     * the newly captured (delta) accumulation for LastValueAggregator.\n     */\n    diff(previous, current) {\n        // nanoseconds may lose precisions.\n        const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(current.sampleTime) >=\n            (0, core_1.hrTimeToMicroseconds)(previous.sampleTime)\n            ? current\n            : previous;\n        return new LastValueAccumulation(current.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);\n    }\n    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {\n        return {\n            descriptor,\n            aggregationTemporality,\n            dataPointType: MetricData_1.DataPointType.GAUGE,\n            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n                return {\n                    attributes,\n                    startTime: accumulation.startTime,\n                    endTime,\n                    value: accumulation.toPointValue(),\n                };\n            }),\n        };\n    }\n}\nexports.LastValueAggregator = LastValueAggregator;\n//# sourceMappingURL=LastValue.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,sBAAsB,QAAQ,wBAAwB,KAAK;CACnE,MAAM,UAAA,gBAAA;CACN,MAAM,SAAS,QAAQ,sBAAsB;CAC7C,MAAM,eAAA,qBAAA;CACN,IAAM,wBAAN,MAA4B;EACxB;EACA;EACA;EACA,YAAY,WAAW,UAAU,GAAG,aAAa,CAAC,GAAG,EAAE,EAAE;AACrD,QAAK,YAAY;AACjB,QAAK,WAAW;AAChB,QAAK,aAAa;;EAEtB,OAAO,OAAO;AACV,QAAK,WAAW;AAChB,QAAK,cAAc,GAAG,OAAO,gBAAgB,KAAK,KAAK,CAAC;;EAE5D,aAAa,WAAW;AACpB,QAAK,YAAY;;EAErB,eAAe;AACX,UAAO,KAAK;;;AAGpB,SAAQ,wBAAwB;;CAEhC,IAAM,sBAAN,MAA0B;EACtB,OAAO,QAAQ,eAAe;EAC9B,mBAAmB,WAAW;AAC1B,UAAO,IAAI,sBAAsB,UAAU;;;;;;;EAO/C,MAAM,UAAU,OAAO;GAEnB,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,MAAM,WAAW,KACxE,GAAG,OAAO,sBAAsB,SAAS,WAAW,GACnD,QACA;AACN,UAAO,IAAI,sBAAsB,SAAS,WAAW,mBAAmB,cAAc,EAAE,mBAAmB,WAAW;;;;;;;;EAQ1H,KAAK,UAAU,SAAS;GAEpB,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,QAAQ,WAAW,KAC1E,GAAG,OAAO,sBAAsB,SAAS,WAAW,GACnD,UACA;AACN,UAAO,IAAI,sBAAsB,QAAQ,WAAW,mBAAmB,cAAc,EAAE,mBAAmB,WAAW;;EAEzH,aAAa,YAAY,wBAAwB,0BAA0B,SAAS;AAChF,UAAO;IACH;IACA;IACA,eAAe,aAAa,cAAc;IAC1C,YAAY,yBAAyB,KAAK,CAAC,YAAY,kBAAkB;AACrE,YAAO;MACH;MACA,WAAW,aAAa;MACxB;MACA,OAAO,aAAa,cAAc;MACrC;MACH;IACL;;;AAGT,SAAQ,sBAAsB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sum.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SumAggregator = exports.SumAccumulation = void 0;\nconst types_1 = require(\"./types\");\nconst MetricData_1 = require(\"../export/MetricData\");\nclass SumAccumulation {\n    startTime;\n    monotonic;\n    _current;\n    reset;\n    constructor(startTime, monotonic, current = 0, reset = false) {\n        this.startTime = startTime;\n        this.monotonic = monotonic;\n        this._current = current;\n        this.reset = reset;\n    }\n    record(value) {\n        if (this.monotonic && value < 0) {\n            return;\n        }\n        this._current += value;\n    }\n    setStartTime(startTime) {\n        this.startTime = startTime;\n    }\n    toPointValue() {\n        return this._current;\n    }\n}\nexports.SumAccumulation = SumAccumulation;\n/** Basic aggregator which calculates a Sum from individual measurements. */\nclass SumAggregator {\n    kind = types_1.AggregatorKind.SUM;\n    monotonic;\n    constructor(monotonic) {\n        this.monotonic = monotonic;\n    }\n    createAccumulation(startTime) {\n        return new SumAccumulation(startTime, this.monotonic);\n    }\n    /**\n     * Returns the result of the merge of the given accumulations.\n     */\n    merge(previous, delta) {\n        const prevPv = previous.toPointValue();\n        const deltaPv = delta.toPointValue();\n        if (delta.reset) {\n            return new SumAccumulation(delta.startTime, this.monotonic, deltaPv, delta.reset);\n        }\n        return new SumAccumulation(previous.startTime, this.monotonic, prevPv + deltaPv);\n    }\n    /**\n     * Returns a new DELTA aggregation by comparing two cumulative measurements.\n     */\n    diff(previous, current) {\n        const prevPv = previous.toPointValue();\n        const currPv = current.toPointValue();\n        /**\n         * If the SumAggregator is a monotonic one and the previous point value is\n         * greater than the current one, a reset is deemed to be happened.\n         * Return the current point value to prevent the value from been reset.\n         */\n        if (this.monotonic && prevPv > currPv) {\n            return new SumAccumulation(current.startTime, this.monotonic, currPv, true);\n        }\n        return new SumAccumulation(current.startTime, this.monotonic, currPv - prevPv);\n    }\n    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {\n        return {\n            descriptor,\n            aggregationTemporality,\n            dataPointType: MetricData_1.DataPointType.SUM,\n            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n                return {\n                    attributes,\n                    startTime: accumulation.startTime,\n                    endTime,\n                    value: accumulation.toPointValue(),\n                };\n            }),\n            isMonotonic: this.monotonic,\n        };\n    }\n}\nexports.SumAggregator = SumAggregator;\n//# sourceMappingURL=Sum.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,QAAQ,kBAAkB,KAAK;CACvD,MAAM,UAAA,gBAAA;CACN,MAAM,eAAA,qBAAA;CACN,IAAM,kBAAN,MAAsB;EAClB;EACA;EACA;EACA;EACA,YAAY,WAAW,WAAW,UAAU,GAAG,QAAQ,OAAO;AAC1D,QAAK,YAAY;AACjB,QAAK,YAAY;AACjB,QAAK,WAAW;AAChB,QAAK,QAAQ;;EAEjB,OAAO,OAAO;AACV,OAAI,KAAK,aAAa,QAAQ,EAC1B;AAEJ,QAAK,YAAY;;EAErB,aAAa,WAAW;AACpB,QAAK,YAAY;;EAErB,eAAe;AACX,UAAO,KAAK;;;AAGpB,SAAQ,kBAAkB;;CAE1B,IAAM,gBAAN,MAAoB;EAChB,OAAO,QAAQ,eAAe;EAC9B;EACA,YAAY,WAAW;AACnB,QAAK,YAAY;;EAErB,mBAAmB,WAAW;AAC1B,UAAO,IAAI,gBAAgB,WAAW,KAAK,UAAU;;;;;EAKzD,MAAM,UAAU,OAAO;GACnB,MAAM,SAAS,SAAS,cAAc;GACtC,MAAM,UAAU,MAAM,cAAc;AACpC,OAAI,MAAM,MACN,QAAO,IAAI,gBAAgB,MAAM,WAAW,KAAK,WAAW,SAAS,MAAM,MAAM;AAErF,UAAO,IAAI,gBAAgB,SAAS,WAAW,KAAK,WAAW,SAAS,QAAQ;;;;;EAKpF,KAAK,UAAU,SAAS;GACpB,MAAM,SAAS,SAAS,cAAc;GACtC,MAAM,SAAS,QAAQ,cAAc;;;;;;AAMrC,OAAI,KAAK,aAAa,SAAS,OAC3B,QAAO,IAAI,gBAAgB,QAAQ,WAAW,KAAK,WAAW,QAAQ,KAAK;AAE/E,UAAO,IAAI,gBAAgB,QAAQ,WAAW,KAAK,WAAW,SAAS,OAAO;;EAElF,aAAa,YAAY,wBAAwB,0BAA0B,SAAS;AAChF,UAAO;IACH;IACA;IACA,eAAe,aAAa,cAAc;IAC1C,YAAY,yBAAyB,KAAK,CAAC,YAAY,kBAAkB;AACrE,YAAO;MACH;MACA,WAAW,aAAa;MACxB;MACA,OAAO,aAAa,cAAc;MACrC;MACH;IACF,aAAa,KAAK;IACrB;;;AAGT,SAAQ,gBAAgB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Buckets.cjs","names":[],"sources":["../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Buckets = void 0;\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nclass Buckets {\n    backing;\n    indexBase;\n    indexStart;\n    indexEnd;\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(backing = new BucketsBacking(), indexBase = 0, indexStart = 0, indexEnd = 0) {\n        this.backing = backing;\n        this.indexBase = indexBase;\n        this.indexStart = indexStart;\n        this.indexEnd = indexEnd;\n    }\n    /**\n     * Offset is the bucket index of the smallest entry in the counts array\n     * @returns {number}\n     */\n    get offset() {\n        return this.indexStart;\n    }\n    /**\n     * Buckets is a view into the backing array.\n     * @returns {number}\n     */\n    get length() {\n        if (this.backing.length === 0) {\n            return 0;\n        }\n        if (this.indexEnd === this.indexStart && this.at(0) === 0) {\n            return 0;\n        }\n        return this.indexEnd - this.indexStart + 1;\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() {\n        return Array.from({ length: this.length }, (_, i) => this.at(i));\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) {\n        const bias = this.indexBase - this.indexStart;\n        if (position < bias) {\n            position += this.backing.length;\n        }\n        position -= bias;\n        return this.backing.countAt(position);\n    }\n    /**\n     * incrementBucket increments the backing array index by `increment`\n     * @param bucketIndex\n     * @param increment\n     */\n    incrementBucket(bucketIndex, increment) {\n        this.backing.increment(bucketIndex, increment);\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, decrement) {\n        this.backing.decrement(bucketIndex, decrement);\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            }\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        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        this._rotate();\n    }\n    /**\n     * downscale first rotates, then collapses 2**`by`-to-1 buckets.\n     * @param by\n     */\n    downscale(by) {\n        this._rotate();\n        const size = 1 + this.indexEnd - this.indexStart;\n        const each = 1 << by;\n        let inpos = 0;\n        let outpos = 0;\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        this.indexStart >>= by;\n        this.indexEnd >>= by;\n        this.indexBase = this.indexStart;\n    }\n    /**\n     * Clone returns a deep copy of Buckets\n     * @returns {Buckets}\n     */\n    clone() {\n        return new Buckets(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd);\n    }\n    /**\n     * _rotate shifts the backing array contents so that indexStart ==\n     * indexBase to simplify the downscale logic.\n     */\n    _rotate() {\n        const bias = this.indexBase - this.indexStart;\n        if (bias === 0) {\n            return;\n        }\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        }\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     * _relocateBucket adds the count in counts[src] to counts[dest] and\n     * resets count[src] to zero.\n     */\n    _relocateBucket(dest, src) {\n        if (dest === src) {\n            return;\n        }\n        this.incrementBucket(dest, this.backing.emptyBucket(src));\n    }\n}\nexports.Buckets = Buckets;\n/**\n * BucketsBacking holds the raw buckets and some utility methods to\n * manage them.\n */\nclass BucketsBacking {\n    _counts;\n    constructor(counts = [0]) {\n        this._counts = counts;\n    }\n    /**\n     * length returns the physical size of the backing array, which\n     * is >= buckets.length()\n     */\n    get length() {\n        return this._counts.length;\n    }\n    /**\n     * countAt returns the count in a specific bucket\n     */\n    countAt(pos) {\n        return this._counts[pos];\n    }\n    /**\n     * growTo grows a backing array and copies old entries\n     * into their correct new positions.\n     */\n    growTo(newSize, oldPositiveLimit, newPositiveLimit) {\n        const tmp = new Array(newSize).fill(0);\n        tmp.splice(newPositiveLimit, this._counts.length - oldPositiveLimit, ...this._counts.slice(oldPositiveLimit));\n        tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit));\n        this._counts = tmp;\n    }\n    /**\n     * reverse the items in the backing array in the range [from, limit).\n     */\n    reverse(from, limit) {\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     * emptyBucket empties the count from a bucket, for\n     * moving into another.\n     */\n    emptyBucket(src) {\n        const tmp = this._counts[src];\n        this._counts[src] = 0;\n        return tmp;\n    }\n    /**\n     * increments a bucket by `increment`\n     */\n    increment(bucketIndex, increment) {\n        this._counts[bucketIndex] += increment;\n    }\n    /**\n     * decrements a bucket by `decrement`\n     */\n    decrement(bucketIndex, decrement) {\n        if (this._counts[bucketIndex] >= decrement) {\n            this._counts[bucketIndex] -= decrement;\n        }\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     * clone returns a deep copy of BucketsBacking\n     */\n    clone() {\n        return new BucketsBacking([...this._counts]);\n    }\n}\n//# sourceMappingURL=Buckets.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExponentMapping.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExponentMapping = void 0;\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nconst ieee754 = require(\"./ieee754\");\nconst util = require(\"../util\");\nconst types_1 = require(\"./types\");\n/**\n * ExponentMapping implements exponential mapping functions for\n * scales <=0. For scales > 0 LogarithmMapping should be used.\n */\nclass ExponentMapping {\n    _shift;\n    constructor(scale) {\n        this._shift = -scale;\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) {\n        if (value < ieee754.MIN_VALUE) {\n            return this._minNormalLowerBoundaryIndex();\n        }\n        const exp = ieee754.getNormalBase2(value);\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(ieee754.getSignificand(value) - 1, ieee754.SIGNIFICAND_WIDTH);\n        return (exp + correction) >> this._shift;\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) {\n        const minIndex = this._minNormalLowerBoundaryIndex();\n        if (index < minIndex) {\n            throw new types_1.MappingError(`underflow: ${index} is < minimum lower boundary: ${minIndex}`);\n        }\n        const maxIndex = this._maxNormalLowerBoundaryIndex();\n        if (index > maxIndex) {\n            throw new types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);\n        }\n        return util.ldexp(1, index << this._shift);\n    }\n    /**\n     * The scale used by this mapping\n     * @returns {number}\n     */\n    get scale() {\n        if (this._shift === 0) {\n            return 0;\n        }\n        return -this._shift;\n    }\n    _minNormalLowerBoundaryIndex() {\n        let index = ieee754.MIN_NORMAL_EXPONENT >> this._shift;\n        if (this._shift < 2) {\n            index--;\n        }\n        return index;\n    }\n    _maxNormalLowerBoundaryIndex() {\n        return ieee754.MAX_NORMAL_EXPONENT >> this._shift;\n    }\n    _rightShift(value, shift) {\n        return Math.floor(value * Math.pow(2, -shift));\n    }\n}\nexports.ExponentMapping = ExponentMapping;\n//# sourceMappingURL=ExponentMapping.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,kBAAkB,KAAK;CAK/B,MAAM,UAAA,kBAAA;CACN,MAAM,OAAA,eAAA;CACN,MAAM,UAAA,gBAAA;;;;;CAKN,IAAM,kBAAN,MAAsB;EAClB;EACA,YAAY,OAAO;AACf,QAAK,SAAS,CAAC;;;;;;;EAOnB,WAAW,OAAO;AACd,OAAI,QAAQ,QAAQ,UAChB,QAAO,KAAK,8BAA8B;AAQ9C,UANY,QAAQ,eAAe,MAMxB,GADQ,KAAK,YAAY,QAAQ,eAAe,MAAM,GAAG,GAAG,QAAQ,kBACvD,IAAK,KAAK;;;;;;;;EAQtC,cAAc,OAAO;GACjB,MAAM,WAAW,KAAK,8BAA8B;AACpD,OAAI,QAAQ,SACR,OAAM,IAAI,QAAQ,aAAa,cAAc,MAAM,gCAAgC,WAAW;GAElG,MAAM,WAAW,KAAK,8BAA8B;AACpD,OAAI,QAAQ,SACR,OAAM,IAAI,QAAQ,aAAa,aAAa,MAAM,gCAAgC,WAAW;AAEjG,UAAO,KAAK,MAAM,GAAG,SAAS,KAAK,OAAO;;;;;;EAM9C,IAAI,QAAQ;AACR,OAAI,KAAK,WAAW,EAChB,QAAO;AAEX,UAAO,CAAC,KAAK;;EAEjB,+BAA+B;GAC3B,IAAI,QAAQ,QAAQ,uBAAuB,KAAK;AAChD,OAAI,KAAK,SAAS,EACd;AAEJ,UAAO;;EAEX,+BAA+B;AAC3B,UAAO,QAAQ,uBAAuB,KAAK;;EAE/C,YAAY,OAAO,OAAO;AACtB,UAAO,KAAK,MAAM,QAAQ,KAAK,IAAI,GAAG,CAAC,MAAM,CAAC;;;AAGtD,SAAQ,kBAAkB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"LogarithmMapping.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.LogarithmMapping = void 0;\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nconst ieee754 = require(\"./ieee754\");\nconst util = require(\"../util\");\nconst types_1 = require(\"./types\");\n/**\n * LogarithmMapping implements exponential mapping functions for scale > 0.\n * For scales <= 0 the exponent mapping should be used.\n */\nclass LogarithmMapping {\n    _scale;\n    _scaleFactor;\n    _inverseFactor;\n    constructor(scale) {\n        this._scale = scale;\n        this._scaleFactor = util.ldexp(Math.LOG2E, scale);\n        this._inverseFactor = util.ldexp(Math.LN2, -scale);\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) {\n        if (value <= ieee754.MIN_VALUE) {\n            return this._minNormalLowerBoundaryIndex() - 1;\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        // 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        return index;\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) {\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 types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);\n        }\n        const minIndex = this._minNormalLowerBoundaryIndex();\n        if (index <= minIndex) {\n            if (index === minIndex) {\n                return ieee754.MIN_VALUE;\n            }\n            else if (index === minIndex - 1) {\n                return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2;\n            }\n            throw new types_1.MappingError(`overflow: ${index} is < minimum lower boundary: ${minIndex}`);\n        }\n        return Math.exp(index * this._inverseFactor);\n    }\n    /**\n     * The scale used by this mapping\n     * @returns {number}\n     */\n    get scale() {\n        return this._scale;\n    }\n    _minNormalLowerBoundaryIndex() {\n        return ieee754.MIN_NORMAL_EXPONENT << this._scale;\n    }\n    _maxNormalLowerBoundaryIndex() {\n        return ((ieee754.MAX_NORMAL_EXPONENT + 1) << this._scale) - 1;\n    }\n}\nexports.LogarithmMapping = LogarithmMapping;\n//# sourceMappingURL=LogarithmMapping.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,mBAAmB,KAAK;CAKhC,MAAM,UAAA,kBAAA;CACN,MAAM,OAAA,eAAA;CACN,MAAM,UAAA,gBAAA;;;;;CAKN,IAAM,mBAAN,MAAuB;EACnB;EACA;EACA;EACA,YAAY,OAAO;AACf,QAAK,SAAS;AACd,QAAK,eAAe,KAAK,MAAM,KAAK,OAAO,MAAM;AACjD,QAAK,iBAAiB,KAAK,MAAM,KAAK,KAAK,CAAC,MAAM;;;;;;;EAOtD,WAAW,OAAO;AACd,OAAI,SAAS,QAAQ,UACjB,QAAO,KAAK,8BAA8B,GAAG;AAGjD,OAAI,QAAQ,eAAe,MAAM,KAAK,EAElC,SADY,QAAQ,eAAe,MACxB,IAAI,KAAK,UAAU;GAGlC,MAAM,QAAQ,KAAK,MAAM,KAAK,IAAI,MAAM,GAAG,KAAK,aAAa;GAC7D,MAAM,WAAW,KAAK,8BAA8B;AACpD,OAAI,SAAS,SACT,QAAO;AAEX,UAAO;;;;;;;;EAQX,cAAc,OAAO;GACjB,MAAM,WAAW,KAAK,8BAA8B;AACpD,OAAI,SAAS,UAAU;AACnB,QAAI,UAAU,SACV,QAAO,IAAI,KAAK,KAAK,SAAS,KAAK,KAAK,WAAW,KAAK,aAAa;AAEzE,UAAM,IAAI,QAAQ,aAAa,aAAa,MAAM,gCAAgC,WAAW;;GAEjG,MAAM,WAAW,KAAK,8BAA8B;AACpD,OAAI,SAAS,UAAU;AACnB,QAAI,UAAU,SACV,QAAO,QAAQ;aAEV,UAAU,WAAW,EAC1B,QAAO,KAAK,KAAK,SAAS,KAAK,KAAK,WAAW,KAAK,aAAa,GAAG;AAExE,UAAM,IAAI,QAAQ,aAAa,aAAa,MAAM,gCAAgC,WAAW;;AAEjG,UAAO,KAAK,IAAI,QAAQ,KAAK,eAAe;;;;;;EAMhD,IAAI,QAAQ;AACR,UAAO,KAAK;;EAEhB,+BAA+B;AAC3B,UAAO,QAAQ,uBAAuB,KAAK;;EAE/C,+BAA+B;AAC3B,WAAS,QAAQ,sBAAsB,KAAM,KAAK,UAAU;;;AAGpE,SAAQ,mBAAmB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/getMapping.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"getMapping.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/getMapping.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getMapping = void 0;\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nconst ExponentMapping_1 = require(\"./ExponentMapping\");\nconst LogarithmMapping_1 = require(\"./LogarithmMapping\");\nconst types_1 = require(\"./types\");\nconst MIN_SCALE = -10;\nconst MAX_SCALE = 20;\nconst PREBUILT_MAPPINGS = Array.from({ length: 31 }, (_, i) => {\n    if (i > 10) {\n        return new LogarithmMapping_1.LogarithmMapping(i - 10);\n    }\n    return new ExponentMapping_1.ExponentMapping(i - 10);\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 */\nfunction getMapping(scale) {\n    if (scale > MAX_SCALE || scale < MIN_SCALE) {\n        throw new types_1.MappingError(`expected scale >= ${MIN_SCALE} && <= ${MAX_SCALE}, got: ${scale}`);\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}\nexports.getMapping = getMapping;\n//# sourceMappingURL=getMapping.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,aAAa,KAAK;CAK1B,MAAM,oBAAA,0BAAA;CACN,MAAM,qBAAA,2BAAA;CACN,MAAM,UAAA,gBAAA;CACN,MAAM,YAAY;CAClB,MAAM,YAAY;CAClB,MAAM,oBAAoB,MAAM,KAAK,EAAE,QAAQ,IAAI,GAAG,GAAG,MAAM;AAC3D,MAAI,IAAI,GACJ,QAAO,IAAI,mBAAmB,iBAAiB,IAAI,GAAG;AAE1D,SAAO,IAAI,kBAAkB,gBAAgB,IAAI,GAAG;GACtD;;;;;;;;CAQF,SAAS,WAAW,OAAO;AACvB,MAAI,QAAQ,aAAa,QAAQ,UAC7B,OAAM,IAAI,QAAQ,aAAa,qBAAqB,UAAU,SAAS,UAAU,SAAS,QAAQ;AAGtG,SAAO,kBAAkB,QAAQ;;AAErC,SAAQ,aAAa"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ieee754.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ieee754.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ieee754.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getSignificand = exports.getNormalBase2 = exports.MIN_VALUE = exports.MAX_NORMAL_EXPONENT = exports.MIN_NORMAL_EXPONENT = exports.SIGNIFICAND_WIDTH = void 0;\n/**\n * The functions and constants in this file allow us to interact\n * with the internal representation of an IEEE 64-bit floating point\n * number. We need to work with all 64-bits, thus, care needs to be\n * taken when working with Javascript's bitwise operators (<<, >>, &,\n * |, etc) as they truncate operands to 32-bits. In order to work around\n * this we work with the 64-bits as two 32-bit halves, perform bitwise\n * operations on them independently, and combine the results (if needed).\n */\nexports.SIGNIFICAND_WIDTH = 52;\n/**\n * EXPONENT_MASK is set to 1 for the hi 32-bits of an IEEE 754\n * floating point exponent: 0x7ff00000.\n */\nconst EXPONENT_MASK = 0x7ff00000;\n/**\n * SIGNIFICAND_MASK is the mask for the significand portion of the hi 32-bits\n * of an IEEE 754 double-precision floating-point value: 0xfffff\n */\nconst SIGNIFICAND_MASK = 0xfffff;\n/**\n * EXPONENT_BIAS is the exponent bias specified for encoding\n * the IEEE 754 double-precision floating point exponent: 1023\n */\nconst EXPONENT_BIAS = 1023;\n/**\n * MIN_NORMAL_EXPONENT is the minimum exponent of a normalized\n * floating point: -1022.\n */\nexports.MIN_NORMAL_EXPONENT = -EXPONENT_BIAS + 1;\n/**\n * MAX_NORMAL_EXPONENT is the maximum exponent of a normalized\n * floating point: 1023.\n */\nexports.MAX_NORMAL_EXPONENT = EXPONENT_BIAS;\n/**\n * MIN_VALUE is the smallest normal number\n */\nexports.MIN_VALUE = Math.pow(2, -1022);\n/**\n * getNormalBase2 extracts the normalized base-2 fractional exponent.\n * This returns k for the equation f x 2**k where f is\n * in the range [1, 2).  Note that this function is not called for\n * subnormal numbers.\n * @param {number} value - the value to determine normalized base-2 fractional\n *    exponent for\n * @returns {number} the normalized base-2 exponent\n */\nfunction getNormalBase2(value) {\n    const dv = new DataView(new ArrayBuffer(8));\n    dv.setFloat64(0, value);\n    // access the raw 64-bit float as 32-bit uints\n    const hiBits = dv.getUint32(0);\n    const expBits = (hiBits & EXPONENT_MASK) >> 20;\n    return expBits - EXPONENT_BIAS;\n}\nexports.getNormalBase2 = getNormalBase2;\n/**\n * GetSignificand returns the 52 bit (unsigned) significand as a signed value.\n * @param {number} value - the floating point number to extract the significand from\n * @returns {number} The 52-bit significand\n */\nfunction getSignificand(value) {\n    const dv = new DataView(new ArrayBuffer(8));\n    dv.setFloat64(0, value);\n    // access the raw 64-bit float as two 32-bit uints\n    const hiBits = dv.getUint32(0);\n    const loBits = dv.getUint32(4);\n    // extract the significand bits from the hi bits and left shift 32 places note:\n    // we can't use the native << operator as it will truncate the result to 32-bits\n    const significandHiBits = (hiBits & SIGNIFICAND_MASK) * Math.pow(2, 32);\n    // combine the hi and lo bits and return\n    return significandHiBits + loBits;\n}\nexports.getSignificand = getSignificand;\n//# sourceMappingURL=ieee754.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,iBAAiB,QAAQ,iBAAiB,QAAQ,YAAY,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ,oBAAoB,KAAK;;;;;;;;;;AAUnK,SAAQ,oBAAoB;;;;;CAK5B,MAAM,gBAAgB;;;;;CAKtB,MAAM,mBAAmB;;;;;CAKzB,MAAM,gBAAgB;;;;;AAKtB,SAAQ,sBAAsB,CAAC,gBAAgB;;;;;AAK/C,SAAQ,sBAAsB;;;;AAI9B,SAAQ,YAAY,KAAK,IAAI,GAAG,MAAM;;;;;;;;;;CAUtC,SAAS,eAAe,OAAO;EAC3B,MAAM,qBAAK,IAAI,yBAAS,IAAI,YAAY,EAAE,CAAC;AAC3C,KAAG,WAAW,GAAG,MAAM;AAIvB,WAFe,GAAG,UAAU,EACL,GAAG,kBAAkB,MAC3B;;AAErB,SAAQ,iBAAiB;;;;;;CAMzB,SAAS,eAAe,OAAO;EAC3B,MAAM,qBAAK,IAAI,yBAAS,IAAI,YAAY,EAAE,CAAC;AAC3C,KAAG,WAAW,GAAG,MAAM;EAEvB,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,MAAM,SAAS,GAAG,UAAU,EAAE;AAK9B,UAF2B,SAAS,oBAAoB,KAAK,IAAI,GAAG,GAAG,GAE5C;;AAE/B,SAAQ,iBAAiB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/types.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/types.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MappingError = void 0;\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nclass MappingError extends Error {\n}\nexports.MappingError = MappingError;\n//# sourceMappingURL=types.js.map"],"x_google_ignoreList":[0],"mappings":";;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,eAAe,KAAK;CAK5B,IAAM,eAAN,cAA2B,MAAM;AAEjC,SAAQ,eAAe"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/util.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.cjs","names":[],"sources":["../../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/util.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.nextGreaterSquare = exports.ldexp = void 0;\n/**\n * Note: other languages provide this as a built in function. This is\n * a naive, but functionally correct implementation. This is used sparingly,\n * when creating a new mapping in a running application.\n *\n * ldexp returns frac × 2**exp. With the following special cases:\n *   ldexp(±0, exp) = ±0\n *   ldexp(±Inf, exp) = ±Inf\n *   ldexp(NaN, exp) = NaN\n * @param frac\n * @param exp\n * @returns {number}\n */\nfunction ldexp(frac, exp) {\n    if (frac === 0 ||\n        frac === Number.POSITIVE_INFINITY ||\n        frac === Number.NEGATIVE_INFINITY ||\n        Number.isNaN(frac)) {\n        return frac;\n    }\n    return frac * Math.pow(2, exp);\n}\nexports.ldexp = ldexp;\n/**\n * Computes the next power of two that is greater than or equal to v.\n * This implementation more efficient than, but functionally equivalent\n * to Math.pow(2, Math.ceil(Math.log(x)/Math.log(2))).\n * @param v\n * @returns {number}\n */\nfunction nextGreaterSquare(v) {\n    // The following expression computes the least power-of-two\n    // that is >= v.  There are a number of tricky ways to\n    // do this, see https://stackoverflow.com/questions/466204/rounding-up-to-next-power-of-2\n    v--;\n    v |= v >> 1;\n    v |= v >> 2;\n    v |= v >> 4;\n    v |= v >> 8;\n    v |= v >> 16;\n    v++;\n    return v;\n}\nexports.nextGreaterSquare = nextGreaterSquare;\n//# sourceMappingURL=util.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,oBAAoB,QAAQ,QAAQ,KAAK;;;;;;;;;;;;;;CAcjD,SAAS,MAAM,MAAM,KAAK;AACtB,MAAI,SAAS,KACT,SAAS,OAAO,qBAChB,SAAS,OAAO,qBAChB,OAAO,MAAM,KAAK,CAClB,QAAO;AAEX,SAAO,OAAO,KAAK,IAAI,GAAG,IAAI;;AAElC,SAAQ,QAAQ;;;;;;;;CAQhB,SAAS,kBAAkB,GAAG;AAI1B;AACA,OAAK,KAAK;AACV,OAAK,KAAK;AACV,OAAK,KAAK;AACV,OAAK,KAAK;AACV,OAAK,KAAK;AACV;AACA,SAAO;;AAEX,SAAQ,oBAAoB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/index.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SumAggregator = exports.SumAccumulation = exports.LastValueAggregator = exports.LastValueAccumulation = exports.ExponentialHistogramAggregator = exports.ExponentialHistogramAccumulation = exports.HistogramAggregator = exports.HistogramAccumulation = exports.DropAggregator = void 0;\nvar Drop_1 = require(\"./Drop\");\nObject.defineProperty(exports, \"DropAggregator\", { enumerable: true, get: function () { return Drop_1.DropAggregator; } });\nvar Histogram_1 = require(\"./Histogram\");\nObject.defineProperty(exports, \"HistogramAccumulation\", { enumerable: true, get: function () { return Histogram_1.HistogramAccumulation; } });\nObject.defineProperty(exports, \"HistogramAggregator\", { enumerable: true, get: function () { return Histogram_1.HistogramAggregator; } });\nvar ExponentialHistogram_1 = require(\"./ExponentialHistogram\");\nObject.defineProperty(exports, \"ExponentialHistogramAccumulation\", { enumerable: true, get: function () { return ExponentialHistogram_1.ExponentialHistogramAccumulation; } });\nObject.defineProperty(exports, \"ExponentialHistogramAggregator\", { enumerable: true, get: function () { return ExponentialHistogram_1.ExponentialHistogramAggregator; } });\nvar LastValue_1 = require(\"./LastValue\");\nObject.defineProperty(exports, \"LastValueAccumulation\", { enumerable: true, get: function () { return LastValue_1.LastValueAccumulation; } });\nObject.defineProperty(exports, \"LastValueAggregator\", { enumerable: true, get: function () { return LastValue_1.LastValueAggregator; } });\nvar Sum_1 = require(\"./Sum\");\nObject.defineProperty(exports, \"SumAccumulation\", { enumerable: true, get: function () { return Sum_1.SumAccumulation; } });\nObject.defineProperty(exports, \"SumAggregator\", { enumerable: true, get: function () { return Sum_1.SumAggregator; } });\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,QAAQ,kBAAkB,QAAQ,sBAAsB,QAAQ,wBAAwB,QAAQ,iCAAiC,QAAQ,mCAAmC,QAAQ,sBAAsB,QAAQ,wBAAwB,QAAQ,iBAAiB,KAAK;CAChS,IAAI,SAAA,eAAA;AACJ,QAAO,eAAe,SAAS,kBAAkB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,OAAO;;EAAmB,CAAC;CAC1H,IAAI,cAAA,oBAAA;AACJ,QAAO,eAAe,SAAS,yBAAyB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,YAAY;;EAA0B,CAAC;AAC7I,QAAO,eAAe,SAAS,uBAAuB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,YAAY;;EAAwB,CAAC;CACzI,IAAI,yBAAA,+BAAA;AACJ,QAAO,eAAe,SAAS,oCAAoC;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,uBAAuB;;EAAqC,CAAC;AAC9K,QAAO,eAAe,SAAS,kCAAkC;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,uBAAuB;;EAAmC,CAAC;CAC1K,IAAI,cAAA,oBAAA;AACJ,QAAO,eAAe,SAAS,yBAAyB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,YAAY;;EAA0B,CAAC;AAC7I,QAAO,eAAe,SAAS,uBAAuB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,YAAY;;EAAwB,CAAC;CACzI,IAAI,QAAA,cAAA;AACJ,QAAO,eAAe,SAAS,mBAAmB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,MAAM;;EAAoB,CAAC;AAC3H,QAAO,eAAe,SAAS,iBAAiB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,MAAM;;EAAkB,CAAC"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/types.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/types.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AggregatorKind = void 0;\n/** The kind of aggregator. */\nvar AggregatorKind;\n(function (AggregatorKind) {\n    AggregatorKind[AggregatorKind[\"DROP\"] = 0] = \"DROP\";\n    AggregatorKind[AggregatorKind[\"SUM\"] = 1] = \"SUM\";\n    AggregatorKind[AggregatorKind[\"LAST_VALUE\"] = 2] = \"LAST_VALUE\";\n    AggregatorKind[AggregatorKind[\"HISTOGRAM\"] = 3] = \"HISTOGRAM\";\n    AggregatorKind[AggregatorKind[\"EXPONENTIAL_HISTOGRAM\"] = 4] = \"EXPONENTIAL_HISTOGRAM\";\n})(AggregatorKind = exports.AggregatorKind || (exports.AggregatorKind = {}));\n//# sourceMappingURL=types.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,iBAAiB,KAAK;AAG9B,EAAC,SAAU,gBAAgB;AACvB,iBAAe,eAAe,UAAU,KAAK;AAC7C,iBAAe,eAAe,SAAS,KAAK;AAC5C,iBAAe,eAAe,gBAAgB,KAAK;AACnD,iBAAe,eAAe,eAAe,KAAK;AAClD,iBAAe,eAAe,2BAA2B,KAAK;IAC9C,QAAQ,mBAAmB,QAAQ,iBAAiB,EAAE,EAAE"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationSelector.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AggregationSelector.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationSelector.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = exports.DEFAULT_AGGREGATION_SELECTOR = void 0;\nconst AggregationTemporality_1 = require(\"./AggregationTemporality\");\nconst AggregationOption_1 = require(\"../view/AggregationOption\");\nconst DEFAULT_AGGREGATION_SELECTOR = _instrumentType => {\n    return {\n        type: AggregationOption_1.AggregationType.DEFAULT,\n    };\n};\nexports.DEFAULT_AGGREGATION_SELECTOR = DEFAULT_AGGREGATION_SELECTOR;\nconst DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = _instrumentType => AggregationTemporality_1.AggregationTemporality.CUMULATIVE;\nexports.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;\n//# sourceMappingURL=AggregationSelector.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,2CAA2C,QAAQ,+BAA+B,KAAK;CAC/F,MAAM,2BAAA,iCAAA;CACN,MAAM,sBAAA,4BAAA;CACN,MAAM,gCAA+B,oBAAmB;AACpD,SAAO,EACH,MAAM,oBAAoB,gBAAgB,SAC7C;;AAEL,SAAQ,+BAA+B;CACvC,MAAM,4CAA2C,oBAAmB,yBAAyB,uBAAuB;AACpH,SAAQ,2CAA2C"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationTemporality.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AggregationTemporality.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationTemporality.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AggregationTemporality = void 0;\n/**\n * AggregationTemporality indicates the way additive quantities are expressed.\n */\nvar AggregationTemporality;\n(function (AggregationTemporality) {\n    AggregationTemporality[AggregationTemporality[\"DELTA\"] = 0] = \"DELTA\";\n    AggregationTemporality[AggregationTemporality[\"CUMULATIVE\"] = 1] = \"CUMULATIVE\";\n})(AggregationTemporality = exports.AggregationTemporality || (exports.AggregationTemporality = {}));\n//# sourceMappingURL=AggregationTemporality.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,yBAAyB,KAAK;AAKtC,EAAC,SAAU,wBAAwB;AAC/B,yBAAuB,uBAAuB,WAAW,KAAK;AAC9D,yBAAuB,uBAAuB,gBAAgB,KAAK;IAC3C,QAAQ,2BAA2B,QAAQ,yBAAyB,EAAE,EAAE"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/ConsoleMetricExporter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConsoleMetricExporter.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/ConsoleMetricExporter.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ConsoleMetricExporter = void 0;\nconst core_1 = require(\"@opentelemetry/core\");\nconst AggregationSelector_1 = require(\"./AggregationSelector\");\n/**\n * This is an implementation of {@link PushMetricExporter} that prints metrics to the\n * console. This class can be used for diagnostic purposes.\n *\n * NOTE: This {@link PushMetricExporter} is intended for diagnostics use only, output rendered to the console may change at any time.\n */\n/* eslint-disable no-console */\nclass ConsoleMetricExporter {\n    _shutdown = false;\n    _temporalitySelector;\n    constructor(options) {\n        this._temporalitySelector =\n            options?.temporalitySelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;\n    }\n    export(metrics, resultCallback) {\n        if (this._shutdown) {\n            // If the exporter is shutting down, by spec, we need to return FAILED as export result\n            resultCallback({ code: core_1.ExportResultCode.FAILED });\n            return;\n        }\n        return ConsoleMetricExporter._sendMetrics(metrics, resultCallback);\n    }\n    forceFlush() {\n        return Promise.resolve();\n    }\n    selectAggregationTemporality(_instrumentType) {\n        return this._temporalitySelector(_instrumentType);\n    }\n    shutdown() {\n        this._shutdown = true;\n        return Promise.resolve();\n    }\n    static _sendMetrics(metrics, done) {\n        for (const scopeMetrics of metrics.scopeMetrics) {\n            for (const metric of scopeMetrics.metrics) {\n                console.dir({\n                    descriptor: metric.descriptor,\n                    dataPointType: metric.dataPointType,\n                    dataPoints: metric.dataPoints,\n                }, { depth: null });\n            }\n        }\n        done({ code: core_1.ExportResultCode.SUCCESS });\n    }\n}\nexports.ConsoleMetricExporter = ConsoleMetricExporter;\n//# sourceMappingURL=ConsoleMetricExporter.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB,KAAK;CACrC,MAAM,SAAS,QAAQ,sBAAsB;CAC7C,MAAM,wBAAA,8BAAA;AA8CN,SAAQ,wBAAwB,MAtC1B,sBAAsB;EACxB,YAAY;EACZ;EACA,YAAY,SAAS;AACjB,QAAK,uBACD,SAAS,uBAAuB,sBAAsB;;EAE9D,OAAO,SAAS,gBAAgB;AAC5B,OAAI,KAAK,WAAW;AAEhB,mBAAe,EAAE,MAAM,OAAO,iBAAiB,QAAQ,CAAC;AACxD;;AAEJ,UAAO,sBAAsB,aAAa,SAAS,eAAe;;EAEtE,aAAa;AACT,UAAO,QAAQ,SAAS;;EAE5B,6BAA6B,iBAAiB;AAC1C,UAAO,KAAK,qBAAqB,gBAAgB;;EAErD,WAAW;AACP,QAAK,YAAY;AACjB,UAAO,QAAQ,SAAS;;EAE5B,OAAO,aAAa,SAAS,MAAM;AAC/B,QAAK,MAAM,gBAAgB,QAAQ,aAC/B,MAAK,MAAM,UAAU,aAAa,QAC9B,SAAQ,IAAI;IACR,YAAY,OAAO;IACnB,eAAe,OAAO;IACtB,YAAY,OAAO;IACtB,EAAE,EAAE,OAAO,MAAM,CAAC;AAG3B,QAAK,EAAE,MAAM,OAAO,iBAAiB,SAAS,CAAC"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/InMemoryMetricExporter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"InMemoryMetricExporter.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/InMemoryMetricExporter.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InMemoryMetricExporter = void 0;\nconst core_1 = require(\"@opentelemetry/core\");\n/**\n * In-memory Metrics Exporter is a Push Metric Exporter\n * which accumulates metrics data in the local memory and\n * allows to inspect it (useful for e.g. unit tests).\n */\nclass InMemoryMetricExporter {\n    _shutdown = false;\n    _aggregationTemporality;\n    _metrics = [];\n    constructor(aggregationTemporality) {\n        this._aggregationTemporality = aggregationTemporality;\n    }\n    /**\n     * @inheritedDoc\n     */\n    export(metrics, resultCallback) {\n        // Avoid storing metrics when exporter is shutdown\n        if (this._shutdown) {\n            setTimeout(() => resultCallback({ code: core_1.ExportResultCode.FAILED }), 0);\n            return;\n        }\n        this._metrics.push(metrics);\n        setTimeout(() => resultCallback({ code: core_1.ExportResultCode.SUCCESS }), 0);\n    }\n    /**\n     * Returns all the collected resource metrics\n     * @returns ResourceMetrics[]\n     */\n    getMetrics() {\n        return this._metrics;\n    }\n    forceFlush() {\n        return Promise.resolve();\n    }\n    reset() {\n        this._metrics = [];\n    }\n    selectAggregationTemporality(_instrumentType) {\n        return this._aggregationTemporality;\n    }\n    shutdown() {\n        this._shutdown = true;\n        return Promise.resolve();\n    }\n}\nexports.InMemoryMetricExporter = InMemoryMetricExporter;\n//# sourceMappingURL=InMemoryMetricExporter.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,yBAAyB,KAAK;CACtC,MAAM,SAAS,QAAQ,sBAAsB;;;;;;CAM7C,IAAM,yBAAN,MAA6B;EACzB,YAAY;EACZ;EACA,WAAW,EAAE;EACb,YAAY,wBAAwB;AAChC,QAAK,0BAA0B;;;;;EAKnC,OAAO,SAAS,gBAAgB;AAE5B,OAAI,KAAK,WAAW;AAChB,qBAAiB,eAAe,EAAE,MAAM,OAAO,iBAAiB,QAAQ,CAAC,EAAE,EAAE;AAC7E;;AAEJ,QAAK,SAAS,KAAK,QAAQ;AAC3B,oBAAiB,eAAe,EAAE,MAAM,OAAO,iBAAiB,SAAS,CAAC,EAAE,EAAE;;;;;;EAMlF,aAAa;AACT,UAAO,KAAK;;EAEhB,aAAa;AACT,UAAO,QAAQ,SAAS;;EAE5B,QAAQ;AACJ,QAAK,WAAW,EAAE;;EAEtB,6BAA6B,iBAAiB;AAC1C,UAAO,KAAK;;EAEhB,WAAW;AACP,QAAK,YAAY;AACjB,UAAO,QAAQ,SAAS;;;AAGhC,SAAQ,yBAAyB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricData.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetricData.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricData.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DataPointType = exports.InstrumentType = void 0;\n/**\n * Supported types of metric instruments.\n */\nvar InstrumentType;\n(function (InstrumentType) {\n    InstrumentType[\"COUNTER\"] = \"COUNTER\";\n    InstrumentType[\"GAUGE\"] = \"GAUGE\";\n    InstrumentType[\"HISTOGRAM\"] = \"HISTOGRAM\";\n    InstrumentType[\"UP_DOWN_COUNTER\"] = \"UP_DOWN_COUNTER\";\n    InstrumentType[\"OBSERVABLE_COUNTER\"] = \"OBSERVABLE_COUNTER\";\n    InstrumentType[\"OBSERVABLE_GAUGE\"] = \"OBSERVABLE_GAUGE\";\n    InstrumentType[\"OBSERVABLE_UP_DOWN_COUNTER\"] = \"OBSERVABLE_UP_DOWN_COUNTER\";\n})(InstrumentType = exports.InstrumentType || (exports.InstrumentType = {}));\n/**\n * The aggregated point data type.\n */\nvar DataPointType;\n(function (DataPointType) {\n    /**\n     * A histogram data point contains a histogram statistics of collected\n     * values with a list of explicit bucket boundaries and statistics such\n     * as min, max, count, and sum of all collected values.\n     */\n    DataPointType[DataPointType[\"HISTOGRAM\"] = 0] = \"HISTOGRAM\";\n    /**\n     * An exponential histogram data point contains a histogram statistics of\n     * collected values where bucket boundaries are automatically calculated\n     * using an exponential function, and statistics such as min, max, count,\n     * and sum of all collected values.\n     */\n    DataPointType[DataPointType[\"EXPONENTIAL_HISTOGRAM\"] = 1] = \"EXPONENTIAL_HISTOGRAM\";\n    /**\n     * A gauge metric data point has only a single numeric value.\n     */\n    DataPointType[DataPointType[\"GAUGE\"] = 2] = \"GAUGE\";\n    /**\n     * A sum metric data point has a single numeric value and a\n     * monotonicity-indicator.\n     */\n    DataPointType[DataPointType[\"SUM\"] = 3] = \"SUM\";\n})(DataPointType = exports.DataPointType || (exports.DataPointType = {}));\n//# sourceMappingURL=MetricData.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,QAAQ,iBAAiB,KAAK;AAKtD,EAAC,SAAU,gBAAgB;AACvB,iBAAe,aAAa;AAC5B,iBAAe,WAAW;AAC1B,iBAAe,eAAe;AAC9B,iBAAe,qBAAqB;AACpC,iBAAe,wBAAwB;AACvC,iBAAe,sBAAsB;AACrC,iBAAe,gCAAgC;IAC/B,QAAQ,mBAAmB,QAAQ,iBAAiB,EAAE,EAAE;AAK5E,EAAC,SAAU,eAAe;;;;;;AAMtB,gBAAc,cAAc,eAAe,KAAK;;;;;;;AAOhD,gBAAc,cAAc,2BAA2B,KAAK;;;;AAI5D,gBAAc,cAAc,WAAW,KAAK;;;;;AAK5C,gBAAc,cAAc,SAAS,KAAK;IAC3B,QAAQ,kBAAkB,QAAQ,gBAAgB,EAAE,EAAE"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetricReader.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MetricReader = void 0;\nconst api = require(\"@opentelemetry/api\");\nconst utils_1 = require(\"../utils\");\nconst AggregationSelector_1 = require(\"./AggregationSelector\");\n/**\n * A registered reader of metrics that, when linked to a {@link MetricProducer}, offers global\n * control over metrics.\n */\nclass MetricReader {\n    // Tracks the shutdown state.\n    // TODO: use BindOncePromise here once a new version of @opentelemetry/core is available.\n    _shutdown = false;\n    // Additional MetricProducers which will be combined with the SDK's output\n    _metricProducers;\n    // MetricProducer used by this instance which produces metrics from the SDK\n    _sdkMetricProducer;\n    _aggregationTemporalitySelector;\n    _aggregationSelector;\n    _cardinalitySelector;\n    constructor(options) {\n        this._aggregationSelector =\n            options?.aggregationSelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_SELECTOR;\n        this._aggregationTemporalitySelector =\n            options?.aggregationTemporalitySelector ??\n                AggregationSelector_1.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;\n        this._metricProducers = options?.metricProducers ?? [];\n        this._cardinalitySelector = options?.cardinalitySelector;\n    }\n    setMetricProducer(metricProducer) {\n        if (this._sdkMetricProducer) {\n            // This check ensures the following requirement from the spec\n            // (https://opentelemetry.io/docs/specs/otel/metrics/sdk/#metricreader):\n            // > The SDK MUST NOT allow a `MetricReader` instance to be registered\n            // > on more than one `MeterProvider` instance.\n            //\n            // So while the argument is a `MetricProducer`, the relevant user-level\n            // error message is about the **MeterProvider**.\n            throw new Error('MetricReader can not be bound to a MeterProvider again.');\n        }\n        this._sdkMetricProducer = metricProducer;\n        this.onInitialized();\n    }\n    selectAggregation(instrumentType) {\n        return this._aggregationSelector(instrumentType);\n    }\n    selectAggregationTemporality(instrumentType) {\n        return this._aggregationTemporalitySelector(instrumentType);\n    }\n    selectCardinalityLimit(instrumentType) {\n        return this._cardinalitySelector\n            ? this._cardinalitySelector(instrumentType)\n            : 2000; // default value if no selector is provided\n    }\n    /**\n     * Handle once the SDK has initialized this {@link MetricReader}\n     * Overriding this method is optional.\n     */\n    onInitialized() {\n        // Default implementation is empty.\n    }\n    async collect(options) {\n        if (this._sdkMetricProducer === undefined) {\n            throw new Error('MetricReader is not bound to a MetricProducer');\n        }\n        // Subsequent invocations to collect are not allowed. SDKs SHOULD return some failure for these calls.\n        if (this._shutdown) {\n            throw new Error('MetricReader is shutdown');\n        }\n        const [sdkCollectionResults, ...additionalCollectionResults] = await Promise.all([\n            this._sdkMetricProducer.collect({\n                timeoutMillis: options?.timeoutMillis,\n            }),\n            ...this._metricProducers.map(producer => producer.collect({\n                timeoutMillis: options?.timeoutMillis,\n            })),\n        ]);\n        // Merge the results, keeping the SDK's Resource\n        const errors = sdkCollectionResults.errors.concat(additionalCollectionResults.flatMap(result => result.errors));\n        const resource = sdkCollectionResults.resourceMetrics.resource;\n        const scopeMetrics = sdkCollectionResults.resourceMetrics.scopeMetrics.concat(additionalCollectionResults.flatMap(result => result.resourceMetrics.scopeMetrics));\n        return {\n            resourceMetrics: {\n                resource,\n                scopeMetrics,\n            },\n            errors,\n        };\n    }\n    async shutdown(options) {\n        // Do not call shutdown again if it has already been called.\n        if (this._shutdown) {\n            api.diag.error('Cannot call shutdown twice.');\n            return;\n        }\n        // No timeout if timeoutMillis is undefined or null.\n        if (options?.timeoutMillis == null) {\n            await this.onShutdown();\n        }\n        else {\n            await (0, utils_1.callWithTimeout)(this.onShutdown(), options.timeoutMillis);\n        }\n        this._shutdown = true;\n    }\n    async forceFlush(options) {\n        if (this._shutdown) {\n            api.diag.warn('Cannot forceFlush on already shutdown MetricReader.');\n            return;\n        }\n        // No timeout if timeoutMillis is undefined or null.\n        if (options?.timeoutMillis == null) {\n            await this.onForceFlush();\n            return;\n        }\n        await (0, utils_1.callWithTimeout)(this.onForceFlush(), options.timeoutMillis);\n    }\n}\nexports.MetricReader = MetricReader;\n//# sourceMappingURL=MetricReader.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,eAAe,KAAK;CAC5B,MAAM,MAAM,QAAQ,qBAAqB;CACzC,MAAM,UAAA,gBAAA;CACN,MAAM,wBAAA,8BAAA;;;;;CAKN,IAAM,eAAN,MAAmB;EAGf,YAAY;EAEZ;EAEA;EACA;EACA;EACA;EACA,YAAY,SAAS;AACjB,QAAK,uBACD,SAAS,uBAAuB,sBAAsB;AAC1D,QAAK,kCACD,SAAS,kCACL,sBAAsB;AAC9B,QAAK,mBAAmB,SAAS,mBAAmB,EAAE;AACtD,QAAK,uBAAuB,SAAS;;EAEzC,kBAAkB,gBAAgB;AAC9B,OAAI,KAAK,mBAQL,OAAM,IAAI,MAAM,0DAA0D;AAE9E,QAAK,qBAAqB;AAC1B,QAAK,eAAe;;EAExB,kBAAkB,gBAAgB;AAC9B,UAAO,KAAK,qBAAqB,eAAe;;EAEpD,6BAA6B,gBAAgB;AACzC,UAAO,KAAK,gCAAgC,eAAe;;EAE/D,uBAAuB,gBAAgB;AACnC,UAAO,KAAK,uBACN,KAAK,qBAAqB,eAAe,GACzC;;;;;;EAMV,gBAAgB;EAGhB,MAAM,QAAQ,SAAS;AACnB,OAAI,KAAK,uBAAuB,KAAA,EAC5B,OAAM,IAAI,MAAM,gDAAgD;AAGpE,OAAI,KAAK,UACL,OAAM,IAAI,MAAM,2BAA2B;GAE/C,MAAM,CAAC,sBAAsB,GAAG,+BAA+B,MAAM,QAAQ,IAAI,CAC7E,KAAK,mBAAmB,QAAQ,EAC5B,eAAe,SAAS,eAC3B,CAAC,EACF,GAAG,KAAK,iBAAiB,KAAI,aAAY,SAAS,QAAQ,EACtD,eAAe,SAAS,eAC3B,CAAC,CAAC,CACN,CAAC;GAEF,MAAM,SAAS,qBAAqB,OAAO,OAAO,4BAA4B,SAAQ,WAAU,OAAO,OAAO,CAAC;AAG/G,UAAO;IACH,iBAAiB;KACb,UAJS,qBAAqB,gBAAgB;KAK9C,cAJa,qBAAqB,gBAAgB,aAAa,OAAO,4BAA4B,SAAQ,WAAU,OAAO,gBAAgB,aAAa,CAI5I;KACf;IACD;IACH;;EAEL,MAAM,SAAS,SAAS;AAEpB,OAAI,KAAK,WAAW;AAChB,QAAI,KAAK,MAAM,8BAA8B;AAC7C;;AAGJ,OAAI,SAAS,iBAAiB,KAC1B,OAAM,KAAK,YAAY;OAGvB,QAAO,GAAG,QAAQ,iBAAiB,KAAK,YAAY,EAAE,QAAQ,cAAc;AAEhF,QAAK,YAAY;;EAErB,MAAM,WAAW,SAAS;AACtB,OAAI,KAAK,WAAW;AAChB,QAAI,KAAK,KAAK,sDAAsD;AACpE;;AAGJ,OAAI,SAAS,iBAAiB,MAAM;AAChC,UAAM,KAAK,cAAc;AACzB;;AAEJ,UAAO,GAAG,QAAQ,iBAAiB,KAAK,cAAc,EAAE,QAAQ,cAAc;;;AAGtF,SAAQ,eAAe"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PeriodicExportingMetricReader.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PeriodicExportingMetricReader = void 0;\nconst api = require(\"@opentelemetry/api\");\nconst core_1 = require(\"@opentelemetry/core\");\nconst MetricReader_1 = require(\"./MetricReader\");\nconst utils_1 = require(\"../utils\");\nconst MetricData_1 = require(\"./MetricData\");\n/**\n * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to\n * the configured {@link PushMetricExporter}\n */\nclass PeriodicExportingMetricReader extends MetricReader_1.MetricReader {\n    _interval;\n    _exporter;\n    _exportInterval;\n    _exportTimeout;\n    constructor(options) {\n        const { exporter, exportIntervalMillis = 60000, metricProducers, cardinalityLimits, } = options;\n        let { exportTimeoutMillis = 30000 } = options;\n        super({\n            aggregationSelector: exporter.selectAggregation?.bind(exporter),\n            aggregationTemporalitySelector: exporter.selectAggregationTemporality?.bind(exporter),\n            metricProducers,\n            cardinalitySelector: (instrumentType) => {\n                const limits = {\n                    default: 2000,\n                    ...cardinalityLimits,\n                };\n                switch (instrumentType) {\n                    case MetricData_1.InstrumentType.COUNTER:\n                        return limits.counter ?? limits.default;\n                    case MetricData_1.InstrumentType.GAUGE:\n                        return limits.gauge ?? limits.default;\n                    case MetricData_1.InstrumentType.HISTOGRAM:\n                        return limits.histogram ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:\n                        return limits.observableCounter ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:\n                        return limits.observableUpDownCounter ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_GAUGE:\n                        return limits.observableGauge ?? limits.default;\n                    case MetricData_1.InstrumentType.UP_DOWN_COUNTER:\n                        return limits.upDownCounter ?? limits.default;\n                    default:\n                        return limits.default;\n                }\n            },\n        });\n        if (exportIntervalMillis <= 0) {\n            throw Error('exportIntervalMillis must be greater than 0');\n        }\n        if (exportTimeoutMillis <= 0) {\n            throw Error('exportTimeoutMillis must be greater than 0');\n        }\n        if (exportIntervalMillis < exportTimeoutMillis) {\n            if ('exportIntervalMillis' in options &&\n                'exportTimeoutMillis' in options) {\n                // An invalid combination of values was explicitly provided.\n                throw Error('exportIntervalMillis must be greater than or equal to exportTimeoutMillis');\n            }\n            else {\n                // An invalid combination of value was implicitly provided.\n                api.diag.info(`Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`);\n                exportTimeoutMillis = exportIntervalMillis;\n            }\n        }\n        this._exportInterval = exportIntervalMillis;\n        this._exportTimeout = exportTimeoutMillis;\n        this._exporter = exporter;\n    }\n    async _runOnce() {\n        try {\n            await (0, utils_1.callWithTimeout)(this._doRun(), this._exportTimeout);\n        }\n        catch (err) {\n            if (err instanceof utils_1.TimeoutError) {\n                api.diag.error('Export took longer than %s milliseconds and timed out.', this._exportTimeout);\n                return;\n            }\n            (0, core_1.globalErrorHandler)(err);\n        }\n    }\n    async _doRun() {\n        const { resourceMetrics, errors } = await this.collect({\n            timeoutMillis: this._exportTimeout,\n        });\n        if (errors.length > 0) {\n            api.diag.error('PeriodicExportingMetricReader: metrics collection errors', ...errors);\n        }\n        if (resourceMetrics.resource.asyncAttributesPending) {\n            try {\n                await resourceMetrics.resource.waitForAsyncAttributes?.();\n            }\n            catch (e) {\n                api.diag.debug('Error while resolving async portion of resource: ', e);\n                (0, core_1.globalErrorHandler)(e);\n            }\n        }\n        if (resourceMetrics.scopeMetrics.length === 0) {\n            return;\n        }\n        const result = await core_1.internal._export(this._exporter, resourceMetrics);\n        if (result.code !== core_1.ExportResultCode.SUCCESS) {\n            throw new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`);\n        }\n    }\n    onInitialized() {\n        // start running the interval as soon as this reader is initialized and keep handle for shutdown.\n        this._interval = setInterval(() => {\n            // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.\n            void this._runOnce();\n        }, this._exportInterval);\n        // depending on runtime, this may be a 'number' or NodeJS.Timeout\n        if (typeof this._interval !== 'number') {\n            this._interval.unref();\n        }\n    }\n    async onForceFlush() {\n        await this._runOnce();\n        await this._exporter.forceFlush();\n    }\n    async onShutdown() {\n        if (this._interval) {\n            clearInterval(this._interval);\n        }\n        await this.onForceFlush();\n        await this._exporter.shutdown();\n    }\n}\nexports.PeriodicExportingMetricReader = PeriodicExportingMetricReader;\n//# sourceMappingURL=PeriodicExportingMetricReader.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/index.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TimeoutError = exports.createDenyListAttributesProcessor = exports.createAllowListAttributesProcessor = exports.AggregationType = exports.MeterProvider = exports.ConsoleMetricExporter = exports.InMemoryMetricExporter = exports.PeriodicExportingMetricReader = exports.MetricReader = exports.InstrumentType = exports.DataPointType = exports.AggregationTemporality = void 0;\nvar AggregationTemporality_1 = require(\"./export/AggregationTemporality\");\nObject.defineProperty(exports, \"AggregationTemporality\", { enumerable: true, get: function () { return AggregationTemporality_1.AggregationTemporality; } });\nvar MetricData_1 = require(\"./export/MetricData\");\nObject.defineProperty(exports, \"DataPointType\", { enumerable: true, get: function () { return MetricData_1.DataPointType; } });\nObject.defineProperty(exports, \"InstrumentType\", { enumerable: true, get: function () { return MetricData_1.InstrumentType; } });\nvar MetricReader_1 = require(\"./export/MetricReader\");\nObject.defineProperty(exports, \"MetricReader\", { enumerable: true, get: function () { return MetricReader_1.MetricReader; } });\nvar PeriodicExportingMetricReader_1 = require(\"./export/PeriodicExportingMetricReader\");\nObject.defineProperty(exports, \"PeriodicExportingMetricReader\", { enumerable: true, get: function () { return PeriodicExportingMetricReader_1.PeriodicExportingMetricReader; } });\nvar InMemoryMetricExporter_1 = require(\"./export/InMemoryMetricExporter\");\nObject.defineProperty(exports, \"InMemoryMetricExporter\", { enumerable: true, get: function () { return InMemoryMetricExporter_1.InMemoryMetricExporter; } });\nvar ConsoleMetricExporter_1 = require(\"./export/ConsoleMetricExporter\");\nObject.defineProperty(exports, \"ConsoleMetricExporter\", { enumerable: true, get: function () { return ConsoleMetricExporter_1.ConsoleMetricExporter; } });\nvar MeterProvider_1 = require(\"./MeterProvider\");\nObject.defineProperty(exports, \"MeterProvider\", { enumerable: true, get: function () { return MeterProvider_1.MeterProvider; } });\nvar AggregationOption_1 = require(\"./view/AggregationOption\");\nObject.defineProperty(exports, \"AggregationType\", { enumerable: true, get: function () { return AggregationOption_1.AggregationType; } });\nvar AttributesProcessor_1 = require(\"./view/AttributesProcessor\");\nObject.defineProperty(exports, \"createAllowListAttributesProcessor\", { enumerable: true, get: function () { return AttributesProcessor_1.createAllowListAttributesProcessor; } });\nObject.defineProperty(exports, \"createDenyListAttributesProcessor\", { enumerable: true, get: function () { return AttributesProcessor_1.createDenyListAttributesProcessor; } });\nvar utils_1 = require(\"./utils\");\nObject.defineProperty(exports, \"TimeoutError\", { enumerable: true, get: function () { return utils_1.TimeoutError; } });\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,eAAe,QAAQ,oCAAoC,QAAQ,qCAAqC,QAAQ,kBAAkB,QAAQ,gBAAgB,QAAQ,wBAAwB,QAAQ,yBAAyB,QAAQ,gCAAgC,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,gBAAgB,QAAQ,yBAAyB,KAAK;CACzX,IAAI,2BAAA,iCAAA;AACJ,QAAO,eAAe,SAAS,0BAA0B;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,yBAAyB;;EAA2B,CAAC;CAC5J,IAAI,eAAA,qBAAA;AACJ,QAAO,eAAe,SAAS,iBAAiB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,aAAa;;EAAkB,CAAC;AAC9H,QAAO,eAAe,SAAS,kBAAkB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,aAAa;;EAAmB,CAAC;CAChI,IAAI,iBAAA,uBAAA;AACJ,QAAO,eAAe,SAAS,gBAAgB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,eAAe;;EAAiB,CAAC;CAC9H,IAAI,kCAAA,wCAAA;AACJ,QAAO,eAAe,SAAS,iCAAiC;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gCAAgC;;EAAkC,CAAC;CACjL,IAAI,2BAAA,iCAAA;AACJ,QAAO,eAAe,SAAS,0BAA0B;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,yBAAyB;;EAA2B,CAAC;CAC5J,IAAI,0BAAA,gCAAA;AACJ,QAAO,eAAe,SAAS,yBAAyB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,wBAAwB;;EAA0B,CAAC;CACzJ,IAAI,kBAAA,wBAAA;AACJ,QAAO,eAAe,SAAS,iBAAiB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,gBAAgB;;EAAkB,CAAC;CACjI,IAAI,sBAAA,4BAAA;AACJ,QAAO,eAAe,SAAS,mBAAmB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,oBAAoB;;EAAoB,CAAC;CACzI,IAAI,wBAAA,8BAAA;AACJ,QAAO,eAAe,SAAS,sCAAsC;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,sBAAsB;;EAAuC,CAAC;AACjL,QAAO,eAAe,SAAS,qCAAqC;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,sBAAsB;;EAAsC,CAAC;CAC/K,IAAI,UAAA,gBAAA;AACJ,QAAO,eAAe,SAAS,gBAAgB;EAAE,YAAY;EAAM,KAAK,WAAY;AAAE,UAAO,QAAQ;;EAAiB,CAAC"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AsyncMetricStorage.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AsyncMetricStorage = void 0;\nconst MetricStorage_1 = require(\"./MetricStorage\");\nconst DeltaMetricProcessor_1 = require(\"./DeltaMetricProcessor\");\nconst TemporalMetricProcessor_1 = require(\"./TemporalMetricProcessor\");\nconst HashMap_1 = require(\"./HashMap\");\n/**\n * Internal interface.\n *\n * Stores and aggregates {@link MetricData} for asynchronous instruments.\n */\nclass AsyncMetricStorage extends MetricStorage_1.MetricStorage {\n    _aggregationCardinalityLimit;\n    _deltaMetricStorage;\n    _temporalMetricStorage;\n    _attributesProcessor;\n    constructor(_instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {\n        super(_instrumentDescriptor);\n        this._aggregationCardinalityLimit = aggregationCardinalityLimit;\n        this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);\n        this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles);\n        this._attributesProcessor = attributesProcessor;\n    }\n    record(measurements, observationTime) {\n        const processed = new HashMap_1.AttributeHashMap();\n        for (const [attributes, value] of measurements.entries()) {\n            processed.set(this._attributesProcessor.process(attributes), value);\n        }\n        this._deltaMetricStorage.batchCumulate(processed, observationTime);\n    }\n    /**\n     * Collects the metrics from this storage. The ObservableCallback is invoked\n     * during the collection.\n     *\n     * Note: This is a stateful operation and may reset any interval-related\n     * state for the MetricCollector.\n     */\n    collect(collector, collectionTime) {\n        const accumulations = this._deltaMetricStorage.collect();\n        return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);\n    }\n}\nexports.AsyncMetricStorage = AsyncMetricStorage;\n//# sourceMappingURL=AsyncMetricStorage.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,qBAAqB,KAAK;CAClC,MAAM,kBAAA,wBAAA;CACN,MAAM,yBAAA,+BAAA;CACN,MAAM,4BAAA,kCAAA;CACN,MAAM,YAAA,kBAAA;;;;;;CAMN,IAAM,qBAAN,cAAiC,gBAAgB,cAAc;EAC3D;EACA;EACA;EACA;EACA,YAAY,uBAAuB,YAAY,qBAAqB,kBAAkB,6BAA6B;AAC/G,SAAM,sBAAsB;AAC5B,QAAK,+BAA+B;AACpC,QAAK,sBAAsB,IAAI,uBAAuB,qBAAqB,YAAY,KAAK,6BAA6B;AACzH,QAAK,yBAAyB,IAAI,0BAA0B,wBAAwB,YAAY,iBAAiB;AACjH,QAAK,uBAAuB;;EAEhC,OAAO,cAAc,iBAAiB;GAClC,MAAM,YAAY,IAAI,UAAU,kBAAkB;AAClD,QAAK,MAAM,CAAC,YAAY,UAAU,aAAa,SAAS,CACpD,WAAU,IAAI,KAAK,qBAAqB,QAAQ,WAAW,EAAE,MAAM;AAEvE,QAAK,oBAAoB,cAAc,WAAW,gBAAgB;;;;;;;;;EAStE,QAAQ,WAAW,gBAAgB;GAC/B,MAAM,gBAAgB,KAAK,oBAAoB,SAAS;AACxD,UAAO,KAAK,uBAAuB,aAAa,WAAW,KAAK,uBAAuB,eAAe,eAAe;;;AAG7H,SAAQ,qBAAqB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/DeltaMetricProcessor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeltaMetricProcessor.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/DeltaMetricProcessor.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DeltaMetricProcessor = void 0;\nconst utils_1 = require(\"../utils\");\nconst HashMap_1 = require(\"./HashMap\");\n/**\n * Internal interface.\n *\n * Allows synchronous collection of metrics. This processor should allow\n * allocation of new aggregation cells for metrics and convert cumulative\n * recording to delta data points.\n */\nclass DeltaMetricProcessor {\n    _activeCollectionStorage = new HashMap_1.AttributeHashMap();\n    // TODO: find a reasonable mean to clean the memo;\n    // https://github.com/open-telemetry/opentelemetry-specification/pull/2208\n    _cumulativeMemoStorage = new HashMap_1.AttributeHashMap();\n    _cardinalityLimit;\n    _overflowAttributes = { 'otel.metric.overflow': true };\n    _overflowHashCode;\n    _aggregator;\n    constructor(aggregator, aggregationCardinalityLimit) {\n        this._aggregator = aggregator;\n        this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1;\n        this._overflowHashCode = (0, utils_1.hashAttributes)(this._overflowAttributes);\n    }\n    record(value, attributes, _context, collectionTime) {\n        let accumulation = this._activeCollectionStorage.get(attributes);\n        if (!accumulation) {\n            if (this._activeCollectionStorage.size >= this._cardinalityLimit) {\n                const overflowAccumulation = this._activeCollectionStorage.getOrDefault(this._overflowAttributes, () => this._aggregator.createAccumulation(collectionTime));\n                overflowAccumulation?.record(value);\n                return;\n            }\n            accumulation = this._aggregator.createAccumulation(collectionTime);\n            this._activeCollectionStorage.set(attributes, accumulation);\n        }\n        accumulation?.record(value);\n    }\n    batchCumulate(measurements, collectionTime) {\n        for (const [originalAttributes, value, originalHashCode,] of measurements.entries()) {\n            let attributes = originalAttributes;\n            let hashCode = originalHashCode;\n            const accumulation = this._aggregator.createAccumulation(collectionTime);\n            accumulation?.record(value);\n            let delta = accumulation;\n            // Diff with recorded cumulative memo.\n            if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n                // has() returned true, previous is present.\n                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                const previous = this._cumulativeMemoStorage.get(attributes, hashCode);\n                delta = this._aggregator.diff(previous, accumulation);\n            }\n            else {\n                // If the cardinality limit is reached, we need to change the attributes\n                if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) {\n                    attributes = this._overflowAttributes;\n                    hashCode = this._overflowHashCode;\n                    if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n                        // has() returned true, previous is present.\n                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                        const previous = this._cumulativeMemoStorage.get(attributes, hashCode);\n                        delta = this._aggregator.diff(previous, accumulation);\n                    }\n                }\n            }\n            // Merge with uncollected active delta.\n            if (this._activeCollectionStorage.has(attributes, hashCode)) {\n                // has() returned true, active is present.\n                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                const active = this._activeCollectionStorage.get(attributes, hashCode);\n                delta = this._aggregator.merge(active, delta);\n            }\n            // Save the current record and the delta record.\n            this._cumulativeMemoStorage.set(attributes, accumulation, hashCode);\n            this._activeCollectionStorage.set(attributes, delta, hashCode);\n        }\n    }\n    /**\n     * Returns a collection of delta metrics. Start time is the when first\n     * time event collected.\n     */\n    collect() {\n        const unreportedDelta = this._activeCollectionStorage;\n        this._activeCollectionStorage = new HashMap_1.AttributeHashMap();\n        return unreportedDelta;\n    }\n}\nexports.DeltaMetricProcessor = DeltaMetricProcessor;\n//# sourceMappingURL=DeltaMetricProcessor.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,uBAAuB,KAAK;CACpC,MAAM,UAAA,gBAAA;CACN,MAAM,YAAA,kBAAA;;;;;;;;CAQN,IAAM,uBAAN,MAA2B;EACvB,2BAA2B,IAAI,UAAU,kBAAkB;EAG3D,yBAAyB,IAAI,UAAU,kBAAkB;EACzD;EACA,sBAAsB,EAAE,wBAAwB,MAAM;EACtD;EACA;EACA,YAAY,YAAY,6BAA6B;AACjD,QAAK,cAAc;AACnB,QAAK,qBAAqB,+BAA+B,OAAQ;AACjE,QAAK,qBAAqB,GAAG,QAAQ,gBAAgB,KAAK,oBAAoB;;EAElF,OAAO,OAAO,YAAY,UAAU,gBAAgB;GAChD,IAAI,eAAe,KAAK,yBAAyB,IAAI,WAAW;AAChE,OAAI,CAAC,cAAc;AACf,QAAI,KAAK,yBAAyB,QAAQ,KAAK,mBAAmB;AACjC,UAAK,yBAAyB,aAAa,KAAK,2BAA2B,KAAK,YAAY,mBAAmB,eAAe,CACvI,EAAE,OAAO,MAAM;AACnC;;AAEJ,mBAAe,KAAK,YAAY,mBAAmB,eAAe;AAClE,SAAK,yBAAyB,IAAI,YAAY,aAAa;;AAE/D,iBAAc,OAAO,MAAM;;EAE/B,cAAc,cAAc,gBAAgB;AACxC,QAAK,MAAM,CAAC,oBAAoB,OAAO,qBAAsB,aAAa,SAAS,EAAE;IACjF,IAAI,aAAa;IACjB,IAAI,WAAW;IACf,MAAM,eAAe,KAAK,YAAY,mBAAmB,eAAe;AACxE,kBAAc,OAAO,MAAM;IAC3B,IAAI,QAAQ;AAEZ,QAAI,KAAK,uBAAuB,IAAI,YAAY,SAAS,EAAE;KAGvD,MAAM,WAAW,KAAK,uBAAuB,IAAI,YAAY,SAAS;AACtE,aAAQ,KAAK,YAAY,KAAK,UAAU,aAAa;eAIjD,KAAK,uBAAuB,QAAQ,KAAK,mBAAmB;AAC5D,kBAAa,KAAK;AAClB,gBAAW,KAAK;AAChB,SAAI,KAAK,uBAAuB,IAAI,YAAY,SAAS,EAAE;MAGvD,MAAM,WAAW,KAAK,uBAAuB,IAAI,YAAY,SAAS;AACtE,cAAQ,KAAK,YAAY,KAAK,UAAU,aAAa;;;AAKjE,QAAI,KAAK,yBAAyB,IAAI,YAAY,SAAS,EAAE;KAGzD,MAAM,SAAS,KAAK,yBAAyB,IAAI,YAAY,SAAS;AACtE,aAAQ,KAAK,YAAY,MAAM,QAAQ,MAAM;;AAGjD,SAAK,uBAAuB,IAAI,YAAY,cAAc,SAAS;AACnE,SAAK,yBAAyB,IAAI,YAAY,OAAO,SAAS;;;;;;;EAOtE,UAAU;GACN,MAAM,kBAAkB,KAAK;AAC7B,QAAK,2BAA2B,IAAI,UAAU,kBAAkB;AAChE,UAAO;;;AAGf,SAAQ,uBAAuB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/HashMap.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"HashMap.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/HashMap.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AttributeHashMap = exports.HashMap = void 0;\nconst utils_1 = require(\"../utils\");\nclass HashMap {\n    _valueMap = new Map();\n    _keyMap = new Map();\n    _hash;\n    constructor(hash) {\n        this._hash = hash;\n    }\n    get(key, hashCode) {\n        hashCode ??= this._hash(key);\n        return this._valueMap.get(hashCode);\n    }\n    getOrDefault(key, defaultFactory) {\n        const hash = this._hash(key);\n        if (this._valueMap.has(hash)) {\n            return this._valueMap.get(hash);\n        }\n        const val = defaultFactory();\n        if (!this._keyMap.has(hash)) {\n            this._keyMap.set(hash, key);\n        }\n        this._valueMap.set(hash, val);\n        return val;\n    }\n    set(key, value, hashCode) {\n        hashCode ??= this._hash(key);\n        if (!this._keyMap.has(hashCode)) {\n            this._keyMap.set(hashCode, key);\n        }\n        this._valueMap.set(hashCode, value);\n    }\n    has(key, hashCode) {\n        hashCode ??= this._hash(key);\n        return this._valueMap.has(hashCode);\n    }\n    *keys() {\n        const keyIterator = this._keyMap.entries();\n        let next = keyIterator.next();\n        while (next.done !== true) {\n            yield [next.value[1], next.value[0]];\n            next = keyIterator.next();\n        }\n    }\n    *entries() {\n        const valueIterator = this._valueMap.entries();\n        let next = valueIterator.next();\n        while (next.done !== true) {\n            // next.value[0] here can not be undefined\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            yield [this._keyMap.get(next.value[0]), next.value[1], next.value[0]];\n            next = valueIterator.next();\n        }\n    }\n    get size() {\n        return this._valueMap.size;\n    }\n}\nexports.HashMap = HashMap;\nclass AttributeHashMap extends HashMap {\n    constructor() {\n        super(utils_1.hashAttributes);\n    }\n}\nexports.AttributeHashMap = AttributeHashMap;\n//# sourceMappingURL=HashMap.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,mBAAmB,QAAQ,UAAU,KAAK;CAClD,MAAM,UAAA,gBAAA;CACN,IAAM,UAAN,MAAc;EACV,4BAAY,IAAI,KAAK;EACrB,0BAAU,IAAI,KAAK;EACnB;EACA,YAAY,MAAM;AACd,QAAK,QAAQ;;EAEjB,IAAI,KAAK,UAAU;AACf,gBAAa,KAAK,MAAM,IAAI;AAC5B,UAAO,KAAK,UAAU,IAAI,SAAS;;EAEvC,aAAa,KAAK,gBAAgB;GAC9B,MAAM,OAAO,KAAK,MAAM,IAAI;AAC5B,OAAI,KAAK,UAAU,IAAI,KAAK,CACxB,QAAO,KAAK,UAAU,IAAI,KAAK;GAEnC,MAAM,MAAM,gBAAgB;AAC5B,OAAI,CAAC,KAAK,QAAQ,IAAI,KAAK,CACvB,MAAK,QAAQ,IAAI,MAAM,IAAI;AAE/B,QAAK,UAAU,IAAI,MAAM,IAAI;AAC7B,UAAO;;EAEX,IAAI,KAAK,OAAO,UAAU;AACtB,gBAAa,KAAK,MAAM,IAAI;AAC5B,OAAI,CAAC,KAAK,QAAQ,IAAI,SAAS,CAC3B,MAAK,QAAQ,IAAI,UAAU,IAAI;AAEnC,QAAK,UAAU,IAAI,UAAU,MAAM;;EAEvC,IAAI,KAAK,UAAU;AACf,gBAAa,KAAK,MAAM,IAAI;AAC5B,UAAO,KAAK,UAAU,IAAI,SAAS;;EAEvC,CAAC,OAAO;GACJ,MAAM,cAAc,KAAK,QAAQ,SAAS;GAC1C,IAAI,OAAO,YAAY,MAAM;AAC7B,UAAO,KAAK,SAAS,MAAM;AACvB,UAAM,CAAC,KAAK,MAAM,IAAI,KAAK,MAAM,GAAG;AACpC,WAAO,YAAY,MAAM;;;EAGjC,CAAC,UAAU;GACP,MAAM,gBAAgB,KAAK,UAAU,SAAS;GAC9C,IAAI,OAAO,cAAc,MAAM;AAC/B,UAAO,KAAK,SAAS,MAAM;AAGvB,UAAM;KAAC,KAAK,QAAQ,IAAI,KAAK,MAAM,GAAG;KAAE,KAAK,MAAM;KAAI,KAAK,MAAM;KAAG;AACrE,WAAO,cAAc,MAAM;;;EAGnC,IAAI,OAAO;AACP,UAAO,KAAK,UAAU;;;AAG9B,SAAQ,UAAU;CAClB,IAAM,mBAAN,cAA+B,QAAQ;EACnC,cAAc;AACV,SAAM,QAAQ,eAAe;;;AAGrC,SAAQ,mBAAmB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterProviderSharedState.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MeterProviderSharedState.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterProviderSharedState.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MeterProviderSharedState = void 0;\nconst utils_1 = require(\"../utils\");\nconst ViewRegistry_1 = require(\"../view/ViewRegistry\");\nconst MeterSharedState_1 = require(\"./MeterSharedState\");\nconst AggregationOption_1 = require(\"../view/AggregationOption\");\n/**\n * An internal record for shared meter provider states.\n */\nclass MeterProviderSharedState {\n    viewRegistry = new ViewRegistry_1.ViewRegistry();\n    metricCollectors = [];\n    meterSharedStates = new Map();\n    resource;\n    constructor(resource) {\n        this.resource = resource;\n    }\n    getMeterSharedState(instrumentationScope) {\n        const id = (0, utils_1.instrumentationScopeId)(instrumentationScope);\n        let meterSharedState = this.meterSharedStates.get(id);\n        if (meterSharedState == null) {\n            meterSharedState = new MeterSharedState_1.MeterSharedState(this, instrumentationScope);\n            this.meterSharedStates.set(id, meterSharedState);\n        }\n        return meterSharedState;\n    }\n    selectAggregations(instrumentType) {\n        const result = [];\n        for (const collector of this.metricCollectors) {\n            result.push([\n                collector,\n                (0, AggregationOption_1.toAggregation)(collector.selectAggregation(instrumentType)),\n            ]);\n        }\n        return result;\n    }\n}\nexports.MeterProviderSharedState = MeterProviderSharedState;\n//# sourceMappingURL=MeterProviderSharedState.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,2BAA2B,KAAK;CACxC,MAAM,UAAA,gBAAA;CACN,MAAM,iBAAA,uBAAA;CACN,MAAM,qBAAA,2BAAA;CACN,MAAM,sBAAA,4BAAA;;;;CAIN,IAAM,2BAAN,MAA+B;EAC3B,eAAe,IAAI,eAAe,cAAc;EAChD,mBAAmB,EAAE;EACrB,oCAAoB,IAAI,KAAK;EAC7B;EACA,YAAY,UAAU;AAClB,QAAK,WAAW;;EAEpB,oBAAoB,sBAAsB;GACtC,MAAM,MAAM,GAAG,QAAQ,wBAAwB,qBAAqB;GACpE,IAAI,mBAAmB,KAAK,kBAAkB,IAAI,GAAG;AACrD,OAAI,oBAAoB,MAAM;AAC1B,uBAAmB,IAAI,mBAAmB,iBAAiB,MAAM,qBAAqB;AACtF,SAAK,kBAAkB,IAAI,IAAI,iBAAiB;;AAEpD,UAAO;;EAEX,mBAAmB,gBAAgB;GAC/B,MAAM,SAAS,EAAE;AACjB,QAAK,MAAM,aAAa,KAAK,iBACzB,QAAO,KAAK,CACR,YACC,GAAG,oBAAoB,eAAe,UAAU,kBAAkB,eAAe,CAAC,CACtF,CAAC;AAEN,UAAO;;;AAGf,SAAQ,2BAA2B"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterSharedState.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MeterSharedState.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterSharedState.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MeterSharedState = void 0;\nconst InstrumentDescriptor_1 = require(\"../InstrumentDescriptor\");\nconst Meter_1 = require(\"../Meter\");\nconst AsyncMetricStorage_1 = require(\"./AsyncMetricStorage\");\nconst MetricStorageRegistry_1 = require(\"./MetricStorageRegistry\");\nconst MultiWritableMetricStorage_1 = require(\"./MultiWritableMetricStorage\");\nconst ObservableRegistry_1 = require(\"./ObservableRegistry\");\nconst SyncMetricStorage_1 = require(\"./SyncMetricStorage\");\nconst AttributesProcessor_1 = require(\"../view/AttributesProcessor\");\n/**\n * An internal record for shared meter provider states.\n */\nclass MeterSharedState {\n    metricStorageRegistry = new MetricStorageRegistry_1.MetricStorageRegistry();\n    observableRegistry = new ObservableRegistry_1.ObservableRegistry();\n    meter;\n    _meterProviderSharedState;\n    _instrumentationScope;\n    constructor(meterProviderSharedState, instrumentationScope) {\n        this.meter = new Meter_1.Meter(this);\n        this._meterProviderSharedState = meterProviderSharedState;\n        this._instrumentationScope = instrumentationScope;\n    }\n    registerMetricStorage(descriptor) {\n        const storages = this._registerMetricStorage(descriptor, SyncMetricStorage_1.SyncMetricStorage);\n        if (storages.length === 1) {\n            return storages[0];\n        }\n        return new MultiWritableMetricStorage_1.MultiMetricStorage(storages);\n    }\n    registerAsyncMetricStorage(descriptor) {\n        const storages = this._registerMetricStorage(descriptor, AsyncMetricStorage_1.AsyncMetricStorage);\n        return storages;\n    }\n    /**\n     * @param collector opaque handle of {@link MetricCollector} which initiated the collection.\n     * @param collectionTime the HrTime at which the collection was initiated.\n     * @param options options for collection.\n     * @returns the list of metric data collected.\n     */\n    async collect(collector, collectionTime, options) {\n        /**\n         * 1. Call all observable callbacks first.\n         * 2. Collect metric result for the collector.\n         */\n        const errors = await this.observableRegistry.observe(collectionTime, options?.timeoutMillis);\n        const storages = this.metricStorageRegistry.getStorages(collector);\n        // prevent more allocations if there are no storages.\n        if (storages.length === 0) {\n            return null;\n        }\n        const metricDataList = [];\n        storages.forEach(metricStorage => {\n            const metricData = metricStorage.collect(collector, collectionTime);\n            if (metricData != null) {\n                metricDataList.push(metricData);\n            }\n        });\n        // skip this scope if no data was collected (storage created, but no data observed)\n        if (metricDataList.length === 0) {\n            return { errors };\n        }\n        return {\n            scopeMetrics: {\n                scope: this._instrumentationScope,\n                metrics: metricDataList,\n            },\n            errors,\n        };\n    }\n    _registerMetricStorage(descriptor, MetricStorageType) {\n        const views = this._meterProviderSharedState.viewRegistry.findViews(descriptor, this._instrumentationScope);\n        let storages = views.map(view => {\n            const viewDescriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptorWithView)(view, descriptor);\n            const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleStorage(viewDescriptor);\n            if (compatibleStorage != null) {\n                return compatibleStorage;\n            }\n            const aggregator = view.aggregation.createAggregator(viewDescriptor);\n            const viewStorage = new MetricStorageType(viewDescriptor, aggregator, view.attributesProcessor, this._meterProviderSharedState.metricCollectors, view.aggregationCardinalityLimit);\n            this.metricStorageRegistry.register(viewStorage);\n            return viewStorage;\n        });\n        // Fallback to the per-collector aggregations if no view is configured for the instrument.\n        if (storages.length === 0) {\n            const perCollectorAggregations = this._meterProviderSharedState.selectAggregations(descriptor.type);\n            const collectorStorages = perCollectorAggregations.map(([collector, aggregation]) => {\n                const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleCollectorStorage(collector, descriptor);\n                if (compatibleStorage != null) {\n                    return compatibleStorage;\n                }\n                const aggregator = aggregation.createAggregator(descriptor);\n                const cardinalityLimit = collector.selectCardinalityLimit(descriptor.type);\n                const storage = new MetricStorageType(descriptor, aggregator, (0, AttributesProcessor_1.createNoopAttributesProcessor)(), [collector], cardinalityLimit);\n                this.metricStorageRegistry.registerForCollector(collector, storage);\n                return storage;\n            });\n            storages = storages.concat(collectorStorages);\n        }\n        return storages;\n    }\n}\nexports.MeterSharedState = MeterSharedState;\n//# sourceMappingURL=MeterSharedState.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,mBAAmB,KAAK;CAChC,MAAM,yBAAA,+BAAA;CACN,MAAM,UAAA,gBAAA;CACN,MAAM,uBAAA,6BAAA;CACN,MAAM,0BAAA,gCAAA;CACN,MAAM,+BAAA,qCAAA;CACN,MAAM,uBAAA,6BAAA;CACN,MAAM,sBAAA,4BAAA;CACN,MAAM,wBAAA,8BAAA;;;;CAIN,IAAM,mBAAN,MAAuB;EACnB,wBAAwB,IAAI,wBAAwB,uBAAuB;EAC3E,qBAAqB,IAAI,qBAAqB,oBAAoB;EAClE;EACA;EACA;EACA,YAAY,0BAA0B,sBAAsB;AACxD,QAAK,QAAQ,IAAI,QAAQ,MAAM,KAAK;AACpC,QAAK,4BAA4B;AACjC,QAAK,wBAAwB;;EAEjC,sBAAsB,YAAY;GAC9B,MAAM,WAAW,KAAK,uBAAuB,YAAY,oBAAoB,kBAAkB;AAC/F,OAAI,SAAS,WAAW,EACpB,QAAO,SAAS;AAEpB,UAAO,IAAI,6BAA6B,mBAAmB,SAAS;;EAExE,2BAA2B,YAAY;AAEnC,UADiB,KAAK,uBAAuB,YAAY,qBAAqB,mBAC/D;;;;;;;;EAQnB,MAAM,QAAQ,WAAW,gBAAgB,SAAS;;;;;GAK9C,MAAM,SAAS,MAAM,KAAK,mBAAmB,QAAQ,gBAAgB,SAAS,cAAc;GAC5F,MAAM,WAAW,KAAK,sBAAsB,YAAY,UAAU;AAElE,OAAI,SAAS,WAAW,EACpB,QAAO;GAEX,MAAM,iBAAiB,EAAE;AACzB,YAAS,SAAQ,kBAAiB;IAC9B,MAAM,aAAa,cAAc,QAAQ,WAAW,eAAe;AACnE,QAAI,cAAc,KACd,gBAAe,KAAK,WAAW;KAErC;AAEF,OAAI,eAAe,WAAW,EAC1B,QAAO,EAAE,QAAQ;AAErB,UAAO;IACH,cAAc;KACV,OAAO,KAAK;KACZ,SAAS;KACZ;IACD;IACH;;EAEL,uBAAuB,YAAY,mBAAmB;GAElD,IAAI,WADU,KAAK,0BAA0B,aAAa,UAAU,YAAY,KAAK,sBACjE,CAAC,KAAI,SAAQ;IAC7B,MAAM,kBAAkB,GAAG,uBAAuB,oCAAoC,MAAM,WAAW;IACvG,MAAM,oBAAoB,KAAK,sBAAsB,8BAA8B,eAAe;AAClG,QAAI,qBAAqB,KACrB,QAAO;IAGX,MAAM,cAAc,IAAI,kBAAkB,gBADvB,KAAK,YAAY,iBAAiB,eACe,EAAE,KAAK,qBAAqB,KAAK,0BAA0B,kBAAkB,KAAK,4BAA4B;AAClL,SAAK,sBAAsB,SAAS,YAAY;AAChD,WAAO;KACT;AAEF,OAAI,SAAS,WAAW,GAAG;IAEvB,MAAM,oBAD2B,KAAK,0BAA0B,mBAAmB,WAAW,KAC5C,CAAC,KAAK,CAAC,WAAW,iBAAiB;KACjF,MAAM,oBAAoB,KAAK,sBAAsB,uCAAuC,WAAW,WAAW;AAClH,SAAI,qBAAqB,KACrB,QAAO;KAEX,MAAM,aAAa,YAAY,iBAAiB,WAAW;KAC3D,MAAM,mBAAmB,UAAU,uBAAuB,WAAW,KAAK;KAC1E,MAAM,UAAU,IAAI,kBAAkB,YAAY,aAAa,GAAG,sBAAsB,gCAAgC,EAAE,CAAC,UAAU,EAAE,iBAAiB;AACxJ,UAAK,sBAAsB,qBAAqB,WAAW,QAAQ;AACnE,YAAO;MACT;AACF,eAAW,SAAS,OAAO,kBAAkB;;AAEjD,UAAO;;;AAGf,SAAQ,mBAAmB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricCollector.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetricCollector.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricCollector.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MetricCollector = void 0;\nconst core_1 = require(\"@opentelemetry/core\");\n/**\n * An internal opaque interface that the MetricReader receives as\n * MetricProducer. It acts as the storage key to the internal metric stream\n * state for each MetricReader.\n */\nclass MetricCollector {\n    _sharedState;\n    _metricReader;\n    constructor(sharedState, metricReader) {\n        this._sharedState = sharedState;\n        this._metricReader = metricReader;\n    }\n    async collect(options) {\n        const collectionTime = (0, core_1.millisToHrTime)(Date.now());\n        const scopeMetrics = [];\n        const errors = [];\n        const meterCollectionPromises = Array.from(this._sharedState.meterSharedStates.values()).map(async (meterSharedState) => {\n            const current = await meterSharedState.collect(this, collectionTime, options);\n            // only add scope metrics if available\n            if (current?.scopeMetrics != null) {\n                scopeMetrics.push(current.scopeMetrics);\n            }\n            // only add errors if available\n            if (current?.errors != null) {\n                errors.push(...current.errors);\n            }\n        });\n        await Promise.all(meterCollectionPromises);\n        return {\n            resourceMetrics: {\n                resource: this._sharedState.resource,\n                scopeMetrics: scopeMetrics,\n            },\n            errors: errors,\n        };\n    }\n    /**\n     * Delegates for MetricReader.forceFlush.\n     */\n    async forceFlush(options) {\n        await this._metricReader.forceFlush(options);\n    }\n    /**\n     * Delegates for MetricReader.shutdown.\n     */\n    async shutdown(options) {\n        await this._metricReader.shutdown(options);\n    }\n    selectAggregationTemporality(instrumentType) {\n        return this._metricReader.selectAggregationTemporality(instrumentType);\n    }\n    selectAggregation(instrumentType) {\n        return this._metricReader.selectAggregation(instrumentType);\n    }\n    /**\n     * Select the cardinality limit for the given {@link InstrumentType} for this\n     * collector.\n     */\n    selectCardinalityLimit(instrumentType) {\n        return this._metricReader.selectCardinalityLimit?.(instrumentType) ?? 2000;\n    }\n}\nexports.MetricCollector = MetricCollector;\n//# sourceMappingURL=MetricCollector.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,kBAAkB,KAAK;CAC/B,MAAM,SAAS,QAAQ,sBAAsB;;;;;;CAM7C,IAAM,kBAAN,MAAsB;EAClB;EACA;EACA,YAAY,aAAa,cAAc;AACnC,QAAK,eAAe;AACpB,QAAK,gBAAgB;;EAEzB,MAAM,QAAQ,SAAS;GACnB,MAAM,kBAAkB,GAAG,OAAO,gBAAgB,KAAK,KAAK,CAAC;GAC7D,MAAM,eAAe,EAAE;GACvB,MAAM,SAAS,EAAE;GACjB,MAAM,0BAA0B,MAAM,KAAK,KAAK,aAAa,kBAAkB,QAAQ,CAAC,CAAC,IAAI,OAAO,qBAAqB;IACrH,MAAM,UAAU,MAAM,iBAAiB,QAAQ,MAAM,gBAAgB,QAAQ;AAE7E,QAAI,SAAS,gBAAgB,KACzB,cAAa,KAAK,QAAQ,aAAa;AAG3C,QAAI,SAAS,UAAU,KACnB,QAAO,KAAK,GAAG,QAAQ,OAAO;KAEpC;AACF,SAAM,QAAQ,IAAI,wBAAwB;AAC1C,UAAO;IACH,iBAAiB;KACb,UAAU,KAAK,aAAa;KACd;KACjB;IACO;IACX;;;;;EAKL,MAAM,WAAW,SAAS;AACtB,SAAM,KAAK,cAAc,WAAW,QAAQ;;;;;EAKhD,MAAM,SAAS,SAAS;AACpB,SAAM,KAAK,cAAc,SAAS,QAAQ;;EAE9C,6BAA6B,gBAAgB;AACzC,UAAO,KAAK,cAAc,6BAA6B,eAAe;;EAE1E,kBAAkB,gBAAgB;AAC9B,UAAO,KAAK,cAAc,kBAAkB,eAAe;;;;;;EAM/D,uBAAuB,gBAAgB;AACnC,UAAO,KAAK,cAAc,yBAAyB,eAAe,IAAI;;;AAG9E,SAAQ,kBAAkB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorage.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetricStorage.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorage.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MetricStorage = void 0;\nconst InstrumentDescriptor_1 = require(\"../InstrumentDescriptor\");\n/**\n * Internal interface.\n *\n * Represents a storage from which we can collect metrics.\n */\nclass MetricStorage {\n    _instrumentDescriptor;\n    constructor(instrumentDescriptor) {\n        this._instrumentDescriptor = instrumentDescriptor;\n    }\n    getInstrumentDescriptor() {\n        return this._instrumentDescriptor;\n    }\n    updateDescription(description) {\n        this._instrumentDescriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(this._instrumentDescriptor.name, this._instrumentDescriptor.type, {\n            description: description,\n            valueType: this._instrumentDescriptor.valueType,\n            unit: this._instrumentDescriptor.unit,\n            advice: this._instrumentDescriptor.advice,\n        });\n    }\n}\nexports.MetricStorage = MetricStorage;\n//# sourceMappingURL=MetricStorage.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,KAAK;CAC7B,MAAM,yBAAA,+BAAA;;;;;;CAMN,IAAM,gBAAN,MAAoB;EAChB;EACA,YAAY,sBAAsB;AAC9B,QAAK,wBAAwB;;EAEjC,0BAA0B;AACtB,UAAO,KAAK;;EAEhB,kBAAkB,aAAa;AAC3B,QAAK,yBAAyB,GAAG,uBAAuB,4BAA4B,KAAK,sBAAsB,MAAM,KAAK,sBAAsB,MAAM;IACrI;IACb,WAAW,KAAK,sBAAsB;IACtC,MAAM,KAAK,sBAAsB;IACjC,QAAQ,KAAK,sBAAsB;IACtC,CAAC;;;AAGV,SAAQ,gBAAgB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorageRegistry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetricStorageRegistry.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorageRegistry.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MetricStorageRegistry = void 0;\nconst InstrumentDescriptor_1 = require(\"../InstrumentDescriptor\");\nconst api = require(\"@opentelemetry/api\");\nconst RegistrationConflicts_1 = require(\"../view/RegistrationConflicts\");\n/**\n * Internal class for storing {@link MetricStorage}\n */\nclass MetricStorageRegistry {\n    _sharedRegistry = new Map();\n    _perCollectorRegistry = new Map();\n    static create() {\n        return new MetricStorageRegistry();\n    }\n    getStorages(collector) {\n        let storages = [];\n        for (const metricStorages of this._sharedRegistry.values()) {\n            storages = storages.concat(metricStorages);\n        }\n        const perCollectorStorages = this._perCollectorRegistry.get(collector);\n        if (perCollectorStorages != null) {\n            for (const metricStorages of perCollectorStorages.values()) {\n                storages = storages.concat(metricStorages);\n            }\n        }\n        return storages;\n    }\n    register(storage) {\n        this._registerStorage(storage, this._sharedRegistry);\n    }\n    registerForCollector(collector, storage) {\n        let storageMap = this._perCollectorRegistry.get(collector);\n        if (storageMap == null) {\n            storageMap = new Map();\n            this._perCollectorRegistry.set(collector, storageMap);\n        }\n        this._registerStorage(storage, storageMap);\n    }\n    findOrUpdateCompatibleStorage(expectedDescriptor) {\n        const storages = this._sharedRegistry.get(expectedDescriptor.name);\n        if (storages === undefined) {\n            return null;\n        }\n        // If the descriptor is compatible, the type of their metric storage\n        // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.\n        return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);\n    }\n    findOrUpdateCompatibleCollectorStorage(collector, expectedDescriptor) {\n        const storageMap = this._perCollectorRegistry.get(collector);\n        if (storageMap === undefined) {\n            return null;\n        }\n        const storages = storageMap.get(expectedDescriptor.name);\n        if (storages === undefined) {\n            return null;\n        }\n        // If the descriptor is compatible, the type of their metric storage\n        // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.\n        return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);\n    }\n    _registerStorage(storage, storageMap) {\n        const descriptor = storage.getInstrumentDescriptor();\n        const storages = storageMap.get(descriptor.name);\n        if (storages === undefined) {\n            storageMap.set(descriptor.name, [storage]);\n            return;\n        }\n        storages.push(storage);\n    }\n    _findOrUpdateCompatibleStorage(expectedDescriptor, existingStorages) {\n        let compatibleStorage = null;\n        for (const existingStorage of existingStorages) {\n            const existingDescriptor = existingStorage.getInstrumentDescriptor();\n            if ((0, InstrumentDescriptor_1.isDescriptorCompatibleWith)(existingDescriptor, expectedDescriptor)) {\n                // Use the longer description if it does not match.\n                if (existingDescriptor.description !== expectedDescriptor.description) {\n                    if (expectedDescriptor.description.length >\n                        existingDescriptor.description.length) {\n                        existingStorage.updateDescription(expectedDescriptor.description);\n                    }\n                    api.diag.warn('A view or instrument with the name ', expectedDescriptor.name, ' has already been registered, but has a different description and is incompatible with another registered view.\\n', 'Details:\\n', (0, RegistrationConflicts_1.getIncompatibilityDetails)(existingDescriptor, expectedDescriptor), 'The longer description will be used.\\nTo resolve the conflict:', (0, RegistrationConflicts_1.getConflictResolutionRecipe)(existingDescriptor, expectedDescriptor));\n                }\n                // Storage is fully compatible. There will never be more than one pre-existing fully compatible storage.\n                compatibleStorage = existingStorage;\n            }\n            else {\n                // The implementation SHOULD warn about duplicate instrument registration\n                // conflicts after applying View configuration.\n                api.diag.warn('A view or instrument with the name ', expectedDescriptor.name, ' has already been registered and is incompatible with another registered view.\\n', 'Details:\\n', (0, RegistrationConflicts_1.getIncompatibilityDetails)(existingDescriptor, expectedDescriptor), 'To resolve the conflict:\\n', (0, RegistrationConflicts_1.getConflictResolutionRecipe)(existingDescriptor, expectedDescriptor));\n            }\n        }\n        return compatibleStorage;\n    }\n}\nexports.MetricStorageRegistry = MetricStorageRegistry;\n//# sourceMappingURL=MetricStorageRegistry.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB,KAAK;CACrC,MAAM,yBAAA,+BAAA;CACN,MAAM,MAAM,QAAQ,qBAAqB;CACzC,MAAM,0BAAA,gCAAA;AA0FN,SAAQ,wBAAwB,MAtF1B,sBAAsB;EACxB,kCAAkB,IAAI,KAAK;EAC3B,wCAAwB,IAAI,KAAK;EACjC,OAAO,SAAS;AACZ,UAAO,IAAI,uBAAuB;;EAEtC,YAAY,WAAW;GACnB,IAAI,WAAW,EAAE;AACjB,QAAK,MAAM,kBAAkB,KAAK,gBAAgB,QAAQ,CACtD,YAAW,SAAS,OAAO,eAAe;GAE9C,MAAM,uBAAuB,KAAK,sBAAsB,IAAI,UAAU;AACtE,OAAI,wBAAwB,KACxB,MAAK,MAAM,kBAAkB,qBAAqB,QAAQ,CACtD,YAAW,SAAS,OAAO,eAAe;AAGlD,UAAO;;EAEX,SAAS,SAAS;AACd,QAAK,iBAAiB,SAAS,KAAK,gBAAgB;;EAExD,qBAAqB,WAAW,SAAS;GACrC,IAAI,aAAa,KAAK,sBAAsB,IAAI,UAAU;AAC1D,OAAI,cAAc,MAAM;AACpB,iCAAa,IAAI,KAAK;AACtB,SAAK,sBAAsB,IAAI,WAAW,WAAW;;AAEzD,QAAK,iBAAiB,SAAS,WAAW;;EAE9C,8BAA8B,oBAAoB;GAC9C,MAAM,WAAW,KAAK,gBAAgB,IAAI,mBAAmB,KAAK;AAClE,OAAI,aAAa,KAAA,EACb,QAAO;AAIX,UAAO,KAAK,+BAA+B,oBAAoB,SAAS;;EAE5E,uCAAuC,WAAW,oBAAoB;GAClE,MAAM,aAAa,KAAK,sBAAsB,IAAI,UAAU;AAC5D,OAAI,eAAe,KAAA,EACf,QAAO;GAEX,MAAM,WAAW,WAAW,IAAI,mBAAmB,KAAK;AACxD,OAAI,aAAa,KAAA,EACb,QAAO;AAIX,UAAO,KAAK,+BAA+B,oBAAoB,SAAS;;EAE5E,iBAAiB,SAAS,YAAY;GAClC,MAAM,aAAa,QAAQ,yBAAyB;GACpD,MAAM,WAAW,WAAW,IAAI,WAAW,KAAK;AAChD,OAAI,aAAa,KAAA,GAAW;AACxB,eAAW,IAAI,WAAW,MAAM,CAAC,QAAQ,CAAC;AAC1C;;AAEJ,YAAS,KAAK,QAAQ;;EAE1B,+BAA+B,oBAAoB,kBAAkB;GACjE,IAAI,oBAAoB;AACxB,QAAK,MAAM,mBAAmB,kBAAkB;IAC5C,MAAM,qBAAqB,gBAAgB,yBAAyB;AACpE,SAAK,GAAG,uBAAuB,4BAA4B,oBAAoB,mBAAmB,EAAE;AAEhG,SAAI,mBAAmB,gBAAgB,mBAAmB,aAAa;AACnE,UAAI,mBAAmB,YAAY,SAC/B,mBAAmB,YAAY,OAC/B,iBAAgB,kBAAkB,mBAAmB,YAAY;AAErE,UAAI,KAAK,KAAK,uCAAuC,mBAAmB,MAAM,qHAAqH,eAAe,GAAG,wBAAwB,2BAA2B,oBAAoB,mBAAmB,EAAE,mEAAmE,GAAG,wBAAwB,6BAA6B,oBAAoB,mBAAmB,CAAC;;AAGxd,yBAAoB;UAKpB,KAAI,KAAK,KAAK,uCAAuC,mBAAmB,MAAM,oFAAoF,eAAe,GAAG,wBAAwB,2BAA2B,oBAAoB,mBAAmB,EAAE,+BAA+B,GAAG,wBAAwB,6BAA6B,oBAAoB,mBAAmB,CAAC;;AAGvZ,UAAO"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/MultiWritableMetricStorage.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MultiWritableMetricStorage.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/MultiWritableMetricStorage.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MultiMetricStorage = void 0;\n/**\n * Internal interface.\n */\nclass MultiMetricStorage {\n    _backingStorages;\n    constructor(backingStorages) {\n        this._backingStorages = backingStorages;\n    }\n    record(value, attributes, context, recordTime) {\n        const storages = this._backingStorages;\n        for (let i = 0; i < storages.length; i++) {\n            storages[i].record(value, attributes, context, recordTime);\n        }\n    }\n}\nexports.MultiMetricStorage = MultiMetricStorage;\n//# sourceMappingURL=MultiWritableMetricStorage.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,qBAAqB,KAAK;;;;CAIlC,IAAM,qBAAN,MAAyB;EACrB;EACA,YAAY,iBAAiB;AACzB,QAAK,mBAAmB;;EAE5B,OAAO,OAAO,YAAY,SAAS,YAAY;GAC3C,MAAM,WAAW,KAAK;AACtB,QAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,IACjC,UAAS,GAAG,OAAO,OAAO,YAAY,SAAS,WAAW;;;AAItE,SAAQ,qBAAqB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/ObservableRegistry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObservableRegistry.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/ObservableRegistry.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ObservableRegistry = void 0;\nconst api_1 = require(\"@opentelemetry/api\");\nconst Instruments_1 = require(\"../Instruments\");\nconst ObservableResult_1 = require(\"../ObservableResult\");\nconst utils_1 = require(\"../utils\");\n/**\n * An internal interface for managing ObservableCallbacks.\n *\n * Every registered callback associated with a set of instruments are be evaluated\n * exactly once during collection prior to reading data for that instrument.\n */\nclass ObservableRegistry {\n    _callbacks = [];\n    _batchCallbacks = [];\n    addCallback(callback, instrument) {\n        const idx = this._findCallback(callback, instrument);\n        if (idx >= 0) {\n            return;\n        }\n        this._callbacks.push({ callback, instrument });\n    }\n    removeCallback(callback, instrument) {\n        const idx = this._findCallback(callback, instrument);\n        if (idx < 0) {\n            return;\n        }\n        this._callbacks.splice(idx, 1);\n    }\n    addBatchCallback(callback, instruments) {\n        // Create a set of unique instruments.\n        const observableInstruments = new Set(instruments.filter(Instruments_1.isObservableInstrument));\n        if (observableInstruments.size === 0) {\n            api_1.diag.error('BatchObservableCallback is not associated with valid instruments', instruments);\n            return;\n        }\n        const idx = this._findBatchCallback(callback, observableInstruments);\n        if (idx >= 0) {\n            return;\n        }\n        this._batchCallbacks.push({ callback, instruments: observableInstruments });\n    }\n    removeBatchCallback(callback, instruments) {\n        // Create a set of unique instruments.\n        const observableInstruments = new Set(instruments.filter(Instruments_1.isObservableInstrument));\n        const idx = this._findBatchCallback(callback, observableInstruments);\n        if (idx < 0) {\n            return;\n        }\n        this._batchCallbacks.splice(idx, 1);\n    }\n    /**\n     * @returns a promise of rejected reasons for invoking callbacks.\n     */\n    async observe(collectionTime, timeoutMillis) {\n        const callbackFutures = this._observeCallbacks(collectionTime, timeoutMillis);\n        const batchCallbackFutures = this._observeBatchCallbacks(collectionTime, timeoutMillis);\n        const results = await Promise.allSettled([\n            ...callbackFutures,\n            ...batchCallbackFutures,\n        ]);\n        const rejections = results\n            .filter(result => result.status === 'rejected')\n            .map(result => result.reason);\n        return rejections;\n    }\n    _observeCallbacks(observationTime, timeoutMillis) {\n        return this._callbacks.map(async ({ callback, instrument }) => {\n            const observableResult = new ObservableResult_1.ObservableResultImpl(instrument._descriptor.name, instrument._descriptor.valueType);\n            let callPromise = Promise.resolve(callback(observableResult));\n            if (timeoutMillis != null) {\n                callPromise = (0, utils_1.callWithTimeout)(callPromise, timeoutMillis);\n            }\n            await callPromise;\n            instrument._metricStorages.forEach(metricStorage => {\n                metricStorage.record(observableResult._buffer, observationTime);\n            });\n        });\n    }\n    _observeBatchCallbacks(observationTime, timeoutMillis) {\n        return this._batchCallbacks.map(async ({ callback, instruments }) => {\n            const observableResult = new ObservableResult_1.BatchObservableResultImpl();\n            let callPromise = Promise.resolve(callback(observableResult));\n            if (timeoutMillis != null) {\n                callPromise = (0, utils_1.callWithTimeout)(callPromise, timeoutMillis);\n            }\n            await callPromise;\n            instruments.forEach(instrument => {\n                const buffer = observableResult._buffer.get(instrument);\n                if (buffer == null) {\n                    return;\n                }\n                instrument._metricStorages.forEach(metricStorage => {\n                    metricStorage.record(buffer, observationTime);\n                });\n            });\n        });\n    }\n    _findCallback(callback, instrument) {\n        return this._callbacks.findIndex(record => {\n            return record.callback === callback && record.instrument === instrument;\n        });\n    }\n    _findBatchCallback(callback, instruments) {\n        return this._batchCallbacks.findIndex(record => {\n            return (record.callback === callback &&\n                (0, utils_1.setEquals)(record.instruments, instruments));\n        });\n    }\n}\nexports.ObservableRegistry = ObservableRegistry;\n//# sourceMappingURL=ObservableRegistry.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/SyncMetricStorage.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyncMetricStorage.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/SyncMetricStorage.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SyncMetricStorage = void 0;\nconst MetricStorage_1 = require(\"./MetricStorage\");\nconst DeltaMetricProcessor_1 = require(\"./DeltaMetricProcessor\");\nconst TemporalMetricProcessor_1 = require(\"./TemporalMetricProcessor\");\n/**\n * Internal interface.\n *\n * Stores and aggregates {@link MetricData} for synchronous instruments.\n */\nclass SyncMetricStorage extends MetricStorage_1.MetricStorage {\n    _aggregationCardinalityLimit;\n    _deltaMetricStorage;\n    _temporalMetricStorage;\n    _attributesProcessor;\n    constructor(instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {\n        super(instrumentDescriptor);\n        this._aggregationCardinalityLimit = aggregationCardinalityLimit;\n        this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);\n        this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles);\n        this._attributesProcessor = attributesProcessor;\n    }\n    record(value, attributes, context, recordTime) {\n        attributes = this._attributesProcessor.process(attributes, context);\n        this._deltaMetricStorage.record(value, attributes, context, recordTime);\n    }\n    /**\n     * Collects the metrics from this storage.\n     *\n     * Note: This is a stateful operation and may reset any interval-related\n     * state for the MetricCollector.\n     */\n    collect(collector, collectionTime) {\n        const accumulations = this._deltaMetricStorage.collect();\n        return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);\n    }\n}\nexports.SyncMetricStorage = SyncMetricStorage;\n//# sourceMappingURL=SyncMetricStorage.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,oBAAoB,KAAK;CACjC,MAAM,kBAAA,wBAAA;CACN,MAAM,yBAAA,+BAAA;CACN,MAAM,4BAAA,kCAAA;;;;;;CAMN,IAAM,oBAAN,cAAgC,gBAAgB,cAAc;EAC1D;EACA;EACA;EACA;EACA,YAAY,sBAAsB,YAAY,qBAAqB,kBAAkB,6BAA6B;AAC9G,SAAM,qBAAqB;AAC3B,QAAK,+BAA+B;AACpC,QAAK,sBAAsB,IAAI,uBAAuB,qBAAqB,YAAY,KAAK,6BAA6B;AACzH,QAAK,yBAAyB,IAAI,0BAA0B,wBAAwB,YAAY,iBAAiB;AACjH,QAAK,uBAAuB;;EAEhC,OAAO,OAAO,YAAY,SAAS,YAAY;AAC3C,gBAAa,KAAK,qBAAqB,QAAQ,YAAY,QAAQ;AACnE,QAAK,oBAAoB,OAAO,OAAO,YAAY,SAAS,WAAW;;;;;;;;EAQ3E,QAAQ,WAAW,gBAAgB;GAC/B,MAAM,gBAAgB,KAAK,oBAAoB,SAAS;AACxD,UAAO,KAAK,uBAAuB,aAAa,WAAW,KAAK,uBAAuB,eAAe,eAAe;;;AAG7H,SAAQ,oBAAoB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/state/TemporalMetricProcessor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"TemporalMetricProcessor.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/state/TemporalMetricProcessor.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TemporalMetricProcessor = void 0;\nconst AggregationTemporality_1 = require(\"../export/AggregationTemporality\");\nconst HashMap_1 = require(\"./HashMap\");\n/**\n * Internal interface.\n *\n * Provides unique reporting for each collector. Allows synchronous collection\n * of metrics and reports given temporality values.\n */\nclass TemporalMetricProcessor {\n    _aggregator;\n    _unreportedAccumulations = new Map();\n    _reportHistory = new Map();\n    constructor(aggregator, collectorHandles) {\n        this._aggregator = aggregator;\n        collectorHandles.forEach(handle => {\n            this._unreportedAccumulations.set(handle, []);\n        });\n    }\n    /**\n     * Builds the {@link MetricData} streams to report against a specific MetricCollector.\n     * @param collector The information of the MetricCollector.\n     * @param collectors The registered collectors.\n     * @param instrumentDescriptor The instrumentation descriptor that these metrics generated with.\n     * @param currentAccumulations The current accumulation of metric data from instruments.\n     * @param collectionTime The current collection timestamp.\n     * @returns The {@link MetricData} points or `null`.\n     */\n    buildMetrics(collector, instrumentDescriptor, currentAccumulations, collectionTime) {\n        this._stashAccumulations(currentAccumulations);\n        const unreportedAccumulations = this._getMergedUnreportedAccumulations(collector);\n        let result = unreportedAccumulations;\n        let aggregationTemporality;\n        // Check our last report time.\n        if (this._reportHistory.has(collector)) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const last = this._reportHistory.get(collector);\n            const lastCollectionTime = last.collectionTime;\n            aggregationTemporality = last.aggregationTemporality;\n            // Use aggregation temporality + instrument to determine if we do a merge or a diff of\n            // previous. We have the following four scenarios:\n            // 1. Cumulative Aggregation (temporality) + Delta recording (sync instrument).\n            //    Here we merge with our last record to get a cumulative aggregation.\n            // 2. Cumulative Aggregation + Cumulative recording (async instrument).\n            //    Cumulative records are converted to delta recording with DeltaMetricProcessor.\n            //    Here we merge with our last record to get a cumulative aggregation.\n            // 3. Delta Aggregation + Delta recording\n            //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.\n            // 4. Delta Aggregation + Cumulative recording.\n            //    Cumulative records are converted to delta recording with DeltaMetricProcessor.\n            //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.\n            if (aggregationTemporality === AggregationTemporality_1.AggregationTemporality.CUMULATIVE) {\n                // We need to make sure the current delta recording gets merged into the previous cumulative\n                // for the next cumulative recording.\n                result = TemporalMetricProcessor.merge(last.accumulations, unreportedAccumulations, this._aggregator);\n            }\n            else {\n                result = TemporalMetricProcessor.calibrateStartTime(last.accumulations, unreportedAccumulations, lastCollectionTime);\n            }\n        }\n        else {\n            // Call into user code to select aggregation temporality for the instrument.\n            aggregationTemporality = collector.selectAggregationTemporality(instrumentDescriptor.type);\n        }\n        // Update last reported (cumulative) accumulation.\n        this._reportHistory.set(collector, {\n            accumulations: result,\n            collectionTime,\n            aggregationTemporality,\n        });\n        const accumulationRecords = AttributesMapToAccumulationRecords(result);\n        // do not convert to metric data if there is nothing to convert.\n        if (accumulationRecords.length === 0) {\n            return undefined;\n        }\n        return this._aggregator.toMetricData(instrumentDescriptor, aggregationTemporality, accumulationRecords, \n        /* endTime */ collectionTime);\n    }\n    _stashAccumulations(currentAccumulation) {\n        const registeredCollectors = this._unreportedAccumulations.keys();\n        for (const collector of registeredCollectors) {\n            let stash = this._unreportedAccumulations.get(collector);\n            if (stash === undefined) {\n                stash = [];\n                this._unreportedAccumulations.set(collector, stash);\n            }\n            stash.push(currentAccumulation);\n        }\n    }\n    _getMergedUnreportedAccumulations(collector) {\n        let result = new HashMap_1.AttributeHashMap();\n        const unreportedList = this._unreportedAccumulations.get(collector);\n        this._unreportedAccumulations.set(collector, []);\n        if (unreportedList === undefined) {\n            return result;\n        }\n        for (const it of unreportedList) {\n            result = TemporalMetricProcessor.merge(result, it, this._aggregator);\n        }\n        return result;\n    }\n    static merge(last, current, aggregator) {\n        const result = last;\n        const iterator = current.entries();\n        let next = iterator.next();\n        while (next.done !== true) {\n            const [key, record, hash] = next.value;\n            if (last.has(key, hash)) {\n                const lastAccumulation = last.get(key, hash);\n                // last.has() returned true, lastAccumulation is present.\n                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                const accumulation = aggregator.merge(lastAccumulation, record);\n                result.set(key, accumulation, hash);\n            }\n            else {\n                result.set(key, record, hash);\n            }\n            next = iterator.next();\n        }\n        return result;\n    }\n    /**\n     * Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves\n     * the new stream to be the initial observation time unchanged.\n     */\n    static calibrateStartTime(last, current, lastCollectionTime) {\n        for (const [key, hash] of last.keys()) {\n            const currentAccumulation = current.get(key, hash);\n            currentAccumulation?.setStartTime(lastCollectionTime);\n        }\n        return current;\n    }\n}\nexports.TemporalMetricProcessor = TemporalMetricProcessor;\n// TypeScript complains about converting 3 elements tuple to AccumulationRecord<T>.\nfunction AttributesMapToAccumulationRecords(map) {\n    return Array.from(map.entries());\n}\n//# sourceMappingURL=TemporalMetricProcessor.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,0BAA0B,KAAK;CACvC,MAAM,2BAAA,iCAAA;CACN,MAAM,YAAA,kBAAA;AAmIN,SAAQ,0BAA0B,MA5H5B,wBAAwB;EAC1B;EACA,2CAA2B,IAAI,KAAK;EACpC,iCAAiB,IAAI,KAAK;EAC1B,YAAY,YAAY,kBAAkB;AACtC,QAAK,cAAc;AACnB,oBAAiB,SAAQ,WAAU;AAC/B,SAAK,yBAAyB,IAAI,QAAQ,EAAE,CAAC;KAC/C;;;;;;;;;;;EAWN,aAAa,WAAW,sBAAsB,sBAAsB,gBAAgB;AAChF,QAAK,oBAAoB,qBAAqB;GAC9C,MAAM,0BAA0B,KAAK,kCAAkC,UAAU;GACjF,IAAI,SAAS;GACb,IAAI;AAEJ,OAAI,KAAK,eAAe,IAAI,UAAU,EAAE;IAEpC,MAAM,OAAO,KAAK,eAAe,IAAI,UAAU;IAC/C,MAAM,qBAAqB,KAAK;AAChC,6BAAyB,KAAK;AAa9B,QAAI,2BAA2B,yBAAyB,uBAAuB,WAG3E,UAAS,wBAAwB,MAAM,KAAK,eAAe,yBAAyB,KAAK,YAAY;QAGrG,UAAS,wBAAwB,mBAAmB,KAAK,eAAe,yBAAyB,mBAAmB;SAKxH,0BAAyB,UAAU,6BAA6B,qBAAqB,KAAK;AAG9F,QAAK,eAAe,IAAI,WAAW;IAC/B,eAAe;IACf;IACA;IACH,CAAC;GACF,MAAM,sBAAsB,mCAAmC,OAAO;AAEtE,OAAI,oBAAoB,WAAW,EAC/B;AAEJ,UAAO,KAAK,YAAY,aAAa,sBAAsB,wBAAwB,qBACrE,eAAe;;EAEjC,oBAAoB,qBAAqB;GACrC,MAAM,uBAAuB,KAAK,yBAAyB,MAAM;AACjE,QAAK,MAAM,aAAa,sBAAsB;IAC1C,IAAI,QAAQ,KAAK,yBAAyB,IAAI,UAAU;AACxD,QAAI,UAAU,KAAA,GAAW;AACrB,aAAQ,EAAE;AACV,UAAK,yBAAyB,IAAI,WAAW,MAAM;;AAEvD,UAAM,KAAK,oBAAoB;;;EAGvC,kCAAkC,WAAW;GACzC,IAAI,SAAS,IAAI,UAAU,kBAAkB;GAC7C,MAAM,iBAAiB,KAAK,yBAAyB,IAAI,UAAU;AACnE,QAAK,yBAAyB,IAAI,WAAW,EAAE,CAAC;AAChD,OAAI,mBAAmB,KAAA,EACnB,QAAO;AAEX,QAAK,MAAM,MAAM,eACb,UAAS,wBAAwB,MAAM,QAAQ,IAAI,KAAK,YAAY;AAExE,UAAO;;EAEX,OAAO,MAAM,MAAM,SAAS,YAAY;GACpC,MAAM,SAAS;GACf,MAAM,WAAW,QAAQ,SAAS;GAClC,IAAI,OAAO,SAAS,MAAM;AAC1B,UAAO,KAAK,SAAS,MAAM;IACvB,MAAM,CAAC,KAAK,QAAQ,QAAQ,KAAK;AACjC,QAAI,KAAK,IAAI,KAAK,KAAK,EAAE;KACrB,MAAM,mBAAmB,KAAK,IAAI,KAAK,KAAK;KAG5C,MAAM,eAAe,WAAW,MAAM,kBAAkB,OAAO;AAC/D,YAAO,IAAI,KAAK,cAAc,KAAK;UAGnC,QAAO,IAAI,KAAK,QAAQ,KAAK;AAEjC,WAAO,SAAS,MAAM;;AAE1B,UAAO;;;;;;EAMX,OAAO,mBAAmB,MAAM,SAAS,oBAAoB;AACzD,QAAK,MAAM,CAAC,KAAK,SAAS,KAAK,MAAM,CACL,SAAQ,IAAI,KAAK,KAC1B,EAAE,aAAa,mBAAmB;AAEzD,UAAO;;;CAKf,SAAS,mCAAmC,KAAK;AAC7C,SAAO,MAAM,KAAK,IAAI,SAAS,CAAC"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/utils.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.equalsCaseInsensitive = exports.binarySearchUB = exports.setEquals = exports.callWithTimeout = exports.TimeoutError = exports.instrumentationScopeId = exports.hashAttributes = void 0;\n/**\n * Converting the unordered attributes into unique identifier string.\n * @param attributes user provided unordered Attributes.\n */\nfunction hashAttributes(attributes) {\n    let keys = Object.keys(attributes);\n    if (keys.length === 0)\n        return '';\n    // Return a string that is stable on key orders.\n    keys = keys.sort();\n    return JSON.stringify(keys.map(key => [key, attributes[key]]));\n}\nexports.hashAttributes = hashAttributes;\n/**\n * Converting the instrumentation scope object to a unique identifier string.\n * @param instrumentationScope\n */\nfunction instrumentationScopeId(instrumentationScope) {\n    return `${instrumentationScope.name}:${instrumentationScope.version ?? ''}:${instrumentationScope.schemaUrl ?? ''}`;\n}\nexports.instrumentationScopeId = instrumentationScopeId;\n/**\n * Error that is thrown on timeouts.\n */\nclass TimeoutError extends Error {\n    constructor(message) {\n        super(message);\n        // manually adjust prototype to retain `instanceof` functionality when targeting ES5, see:\n        // https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n        Object.setPrototypeOf(this, TimeoutError.prototype);\n    }\n}\nexports.TimeoutError = TimeoutError;\n/**\n * Adds a timeout to a promise and rejects if the specified timeout has elapsed. Also rejects if the specified promise\n * rejects, and resolves if the specified promise resolves.\n *\n * <p> NOTE: this operation will continue even after it throws a {@link TimeoutError}.\n *\n * @param promise promise to use with timeout.\n * @param timeout the timeout in milliseconds until the returned promise is rejected.\n */\nfunction callWithTimeout(promise, timeout) {\n    let timeoutHandle;\n    const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {\n        timeoutHandle = setTimeout(function timeoutHandler() {\n            reject(new TimeoutError('Operation timed out.'));\n        }, timeout);\n    });\n    return Promise.race([promise, timeoutPromise]).then(result => {\n        clearTimeout(timeoutHandle);\n        return result;\n    }, reason => {\n        clearTimeout(timeoutHandle);\n        throw reason;\n    });\n}\nexports.callWithTimeout = callWithTimeout;\nfunction setEquals(lhs, rhs) {\n    if (lhs.size !== rhs.size) {\n        return false;\n    }\n    for (const item of lhs) {\n        if (!rhs.has(item)) {\n            return false;\n        }\n    }\n    return true;\n}\nexports.setEquals = setEquals;\n/**\n * Binary search the sorted array to the find upper bound for the value.\n * @param arr\n * @param value\n * @returns\n */\nfunction binarySearchUB(arr, value) {\n    let lo = 0;\n    let hi = arr.length - 1;\n    let ret = arr.length;\n    while (hi >= lo) {\n        const mid = lo + Math.trunc((hi - lo) / 2);\n        if (arr[mid] < value) {\n            lo = mid + 1;\n        }\n        else {\n            ret = mid;\n            hi = mid - 1;\n        }\n    }\n    return ret;\n}\nexports.binarySearchUB = binarySearchUB;\nfunction equalsCaseInsensitive(lhs, rhs) {\n    return lhs.toLowerCase() === rhs.toLowerCase();\n}\nexports.equalsCaseInsensitive = equalsCaseInsensitive;\n//# sourceMappingURL=utils.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,wBAAwB,QAAQ,iBAAiB,QAAQ,YAAY,QAAQ,kBAAkB,QAAQ,eAAe,QAAQ,yBAAyB,QAAQ,iBAAiB,KAAK;;;;;CAK7L,SAAS,eAAe,YAAY;EAChC,IAAI,OAAO,OAAO,KAAK,WAAW;AAClC,MAAI,KAAK,WAAW,EAChB,QAAO;AAEX,SAAO,KAAK,MAAM;AAClB,SAAO,KAAK,UAAU,KAAK,KAAI,QAAO,CAAC,KAAK,WAAW,KAAK,CAAC,CAAC;;AAElE,SAAQ,iBAAiB;;;;;CAKzB,SAAS,uBAAuB,sBAAsB;AAClD,SAAO,GAAG,qBAAqB,KAAK,GAAG,qBAAqB,WAAW,GAAG,GAAG,qBAAqB,aAAa;;AAEnH,SAAQ,yBAAyB;;;;CAIjC,IAAM,eAAN,MAAM,qBAAqB,MAAM;EAC7B,YAAY,SAAS;AACjB,SAAM,QAAQ;AAGd,UAAO,eAAe,MAAM,aAAa,UAAU;;;AAG3D,SAAQ,eAAe;;;;;;;;;;CAUvB,SAAS,gBAAgB,SAAS,SAAS;EACvC,IAAI;EACJ,MAAM,iBAAiB,IAAI,QAAQ,SAAS,gBAAgB,UAAU,QAAQ;AAC1E,mBAAgB,WAAW,SAAS,iBAAiB;AACjD,WAAO,IAAI,aAAa,uBAAuB,CAAC;MACjD,QAAQ;IACb;AACF,SAAO,QAAQ,KAAK,CAAC,SAAS,eAAe,CAAC,CAAC,MAAK,WAAU;AAC1D,gBAAa,cAAc;AAC3B,UAAO;MACR,WAAU;AACT,gBAAa,cAAc;AAC3B,SAAM;IACR;;AAEN,SAAQ,kBAAkB;CAC1B,SAAS,UAAU,KAAK,KAAK;AACzB,MAAI,IAAI,SAAS,IAAI,KACjB,QAAO;AAEX,OAAK,MAAM,QAAQ,IACf,KAAI,CAAC,IAAI,IAAI,KAAK,CACd,QAAO;AAGf,SAAO;;AAEX,SAAQ,YAAY;;;;;;;CAOpB,SAAS,eAAe,KAAK,OAAO;EAChC,IAAI,KAAK;EACT,IAAI,KAAK,IAAI,SAAS;EACtB,IAAI,MAAM,IAAI;AACd,SAAO,MAAM,IAAI;GACb,MAAM,MAAM,KAAK,KAAK,OAAO,KAAK,MAAM,EAAE;AAC1C,OAAI,IAAI,OAAO,MACX,MAAK,MAAM;QAEV;AACD,UAAM;AACN,SAAK,MAAM;;;AAGnB,SAAO;;AAEX,SAAQ,iBAAiB;CACzB,SAAS,sBAAsB,KAAK,KAAK;AACrC,SAAO,IAAI,aAAa,KAAK,IAAI,aAAa;;AAElD,SAAQ,wBAAwB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Aggregation.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DEFAULT_AGGREGATION = exports.EXPONENTIAL_HISTOGRAM_AGGREGATION = exports.HISTOGRAM_AGGREGATION = exports.LAST_VALUE_AGGREGATION = exports.SUM_AGGREGATION = exports.DROP_AGGREGATION = exports.DefaultAggregation = exports.ExponentialHistogramAggregation = exports.ExplicitBucketHistogramAggregation = exports.HistogramAggregation = exports.LastValueAggregation = exports.SumAggregation = exports.DropAggregation = void 0;\nconst api = require(\"@opentelemetry/api\");\nconst aggregator_1 = require(\"../aggregator\");\nconst MetricData_1 = require(\"../export/MetricData\");\n/**\n * The default drop aggregation.\n */\nclass DropAggregation {\n    static DEFAULT_INSTANCE = new aggregator_1.DropAggregator();\n    createAggregator(_instrument) {\n        return DropAggregation.DEFAULT_INSTANCE;\n    }\n}\nexports.DropAggregation = DropAggregation;\n/**\n * The default sum aggregation.\n */\nclass SumAggregation {\n    static MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(true);\n    static NON_MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(false);\n    createAggregator(instrument) {\n        switch (instrument.type) {\n            case MetricData_1.InstrumentType.COUNTER:\n            case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:\n            case MetricData_1.InstrumentType.HISTOGRAM: {\n                return SumAggregation.MONOTONIC_INSTANCE;\n            }\n            default: {\n                return SumAggregation.NON_MONOTONIC_INSTANCE;\n            }\n        }\n    }\n}\nexports.SumAggregation = SumAggregation;\n/**\n * The default last value aggregation.\n */\nclass LastValueAggregation {\n    static DEFAULT_INSTANCE = new aggregator_1.LastValueAggregator();\n    createAggregator(_instrument) {\n        return LastValueAggregation.DEFAULT_INSTANCE;\n    }\n}\nexports.LastValueAggregation = LastValueAggregation;\n/**\n * The default histogram aggregation.\n\n */\nclass HistogramAggregation {\n    static DEFAULT_INSTANCE = new aggregator_1.HistogramAggregator([0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000], true);\n    createAggregator(_instrument) {\n        return HistogramAggregation.DEFAULT_INSTANCE;\n    }\n}\nexports.HistogramAggregation = HistogramAggregation;\n/**\n * The explicit bucket histogram aggregation.\n */\nclass ExplicitBucketHistogramAggregation {\n    _boundaries;\n    _recordMinMax;\n    /**\n     * @param boundaries the bucket boundaries of the histogram aggregation\n     * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded.\n     */\n    constructor(boundaries, recordMinMax = true) {\n        if (boundaries == null) {\n            throw new Error('ExplicitBucketHistogramAggregation should be created with explicit boundaries, if a single bucket histogram is required, please pass an empty array');\n        }\n        // Copy the boundaries array for modification.\n        boundaries = boundaries.concat();\n        // We need to an ordered set to be able to correctly compute count for each\n        // boundary since we'll iterate on each in order.\n        boundaries = boundaries.sort((a, b) => a - b);\n        // Remove all Infinity from the boundaries.\n        const minusInfinityIndex = boundaries.lastIndexOf(-Infinity);\n        let infinityIndex = boundaries.indexOf(Infinity);\n        if (infinityIndex === -1) {\n            infinityIndex = undefined;\n        }\n        this._boundaries = boundaries.slice(minusInfinityIndex + 1, infinityIndex);\n        this._recordMinMax = recordMinMax;\n    }\n    createAggregator(_instrument) {\n        return new aggregator_1.HistogramAggregator(this._boundaries, this._recordMinMax);\n    }\n}\nexports.ExplicitBucketHistogramAggregation = ExplicitBucketHistogramAggregation;\nclass ExponentialHistogramAggregation {\n    _maxSize;\n    _recordMinMax;\n    constructor(maxSize = 160, recordMinMax = true) {\n        this._maxSize = maxSize;\n        this._recordMinMax = recordMinMax;\n    }\n    createAggregator(_instrument) {\n        return new aggregator_1.ExponentialHistogramAggregator(this._maxSize, this._recordMinMax);\n    }\n}\nexports.ExponentialHistogramAggregation = ExponentialHistogramAggregation;\n/**\n * The default aggregation.\n */\nclass DefaultAggregation {\n    _resolve(instrument) {\n        // cast to unknown to disable complaints on the (unreachable) fallback.\n        switch (instrument.type) {\n            case MetricData_1.InstrumentType.COUNTER:\n            case MetricData_1.InstrumentType.UP_DOWN_COUNTER:\n            case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:\n            case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER: {\n                return exports.SUM_AGGREGATION;\n            }\n            case MetricData_1.InstrumentType.GAUGE:\n            case MetricData_1.InstrumentType.OBSERVABLE_GAUGE: {\n                return exports.LAST_VALUE_AGGREGATION;\n            }\n            case MetricData_1.InstrumentType.HISTOGRAM: {\n                if (instrument.advice.explicitBucketBoundaries) {\n                    return new ExplicitBucketHistogramAggregation(instrument.advice.explicitBucketBoundaries);\n                }\n                return exports.HISTOGRAM_AGGREGATION;\n            }\n        }\n        api.diag.warn(`Unable to recognize instrument type: ${instrument.type}`);\n        return exports.DROP_AGGREGATION;\n    }\n    createAggregator(instrument) {\n        return this._resolve(instrument).createAggregator(instrument);\n    }\n}\nexports.DefaultAggregation = DefaultAggregation;\nexports.DROP_AGGREGATION = new DropAggregation();\nexports.SUM_AGGREGATION = new SumAggregation();\nexports.LAST_VALUE_AGGREGATION = new LastValueAggregation();\nexports.HISTOGRAM_AGGREGATION = new HistogramAggregation();\nexports.EXPONENTIAL_HISTOGRAM_AGGREGATION = new ExponentialHistogramAggregation();\nexports.DEFAULT_AGGREGATION = new DefaultAggregation();\n//# sourceMappingURL=Aggregation.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AggregationOption.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.toAggregation = exports.AggregationType = void 0;\nconst Aggregation_1 = require(\"./Aggregation\");\nvar AggregationType;\n(function (AggregationType) {\n    AggregationType[AggregationType[\"DEFAULT\"] = 0] = \"DEFAULT\";\n    AggregationType[AggregationType[\"DROP\"] = 1] = \"DROP\";\n    AggregationType[AggregationType[\"SUM\"] = 2] = \"SUM\";\n    AggregationType[AggregationType[\"LAST_VALUE\"] = 3] = \"LAST_VALUE\";\n    AggregationType[AggregationType[\"EXPLICIT_BUCKET_HISTOGRAM\"] = 4] = \"EXPLICIT_BUCKET_HISTOGRAM\";\n    AggregationType[AggregationType[\"EXPONENTIAL_HISTOGRAM\"] = 5] = \"EXPONENTIAL_HISTOGRAM\";\n})(AggregationType = exports.AggregationType || (exports.AggregationType = {}));\nfunction toAggregation(option) {\n    switch (option.type) {\n        case AggregationType.DEFAULT:\n            return Aggregation_1.DEFAULT_AGGREGATION;\n        case AggregationType.DROP:\n            return Aggregation_1.DROP_AGGREGATION;\n        case AggregationType.SUM:\n            return Aggregation_1.SUM_AGGREGATION;\n        case AggregationType.LAST_VALUE:\n            return Aggregation_1.LAST_VALUE_AGGREGATION;\n        case AggregationType.EXPONENTIAL_HISTOGRAM: {\n            const expOption = option;\n            return new Aggregation_1.ExponentialHistogramAggregation(expOption.options?.maxSize, expOption.options?.recordMinMax);\n        }\n        case AggregationType.EXPLICIT_BUCKET_HISTOGRAM: {\n            const expOption = option;\n            if (expOption.options == null) {\n                return Aggregation_1.HISTOGRAM_AGGREGATION;\n            }\n            else {\n                return new Aggregation_1.ExplicitBucketHistogramAggregation(expOption.options?.boundaries, expOption.options?.recordMinMax);\n            }\n        }\n        default:\n            throw new Error('Unsupported Aggregation');\n    }\n}\nexports.toAggregation = toAggregation;\n//# sourceMappingURL=AggregationOption.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,QAAQ,kBAAkB,KAAK;CACvD,MAAM,gBAAA,sBAAA;CACN,IAAI;AACJ,EAAC,SAAU,iBAAiB;AACxB,kBAAgB,gBAAgB,aAAa,KAAK;AAClD,kBAAgB,gBAAgB,UAAU,KAAK;AAC/C,kBAAgB,gBAAgB,SAAS,KAAK;AAC9C,kBAAgB,gBAAgB,gBAAgB,KAAK;AACrD,kBAAgB,gBAAgB,+BAA+B,KAAK;AACpE,kBAAgB,gBAAgB,2BAA2B,KAAK;IACjE,kBAAkB,QAAQ,oBAAoB,QAAQ,kBAAkB,EAAE,EAAE;CAC/E,SAAS,cAAc,QAAQ;AAC3B,UAAQ,OAAO,MAAf;GACI,KAAK,gBAAgB,QACjB,QAAO,cAAc;GACzB,KAAK,gBAAgB,KACjB,QAAO,cAAc;GACzB,KAAK,gBAAgB,IACjB,QAAO,cAAc;GACzB,KAAK,gBAAgB,WACjB,QAAO,cAAc;GACzB,KAAK,gBAAgB,uBAAuB;IACxC,MAAM,YAAY;AAClB,WAAO,IAAI,cAAc,gCAAgC,UAAU,SAAS,SAAS,UAAU,SAAS,aAAa;;GAEzH,KAAK,gBAAgB,2BAA2B;IAC5C,MAAM,YAAY;AAClB,QAAI,UAAU,WAAW,KACrB,QAAO,cAAc;QAGrB,QAAO,IAAI,cAAc,mCAAmC,UAAU,SAAS,YAAY,UAAU,SAAS,aAAa;;GAGnI,QACI,OAAM,IAAI,MAAM,0BAA0B;;;AAGtD,SAAQ,gBAAgB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/AttributesProcessor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttributesProcessor.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/AttributesProcessor.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createDenyListAttributesProcessor = exports.createAllowListAttributesProcessor = exports.createMultiAttributesProcessor = exports.createNoopAttributesProcessor = void 0;\nclass NoopAttributesProcessor {\n    process(incoming, _context) {\n        return incoming;\n    }\n}\nclass MultiAttributesProcessor {\n    _processors;\n    constructor(processors) {\n        this._processors = processors;\n    }\n    process(incoming, context) {\n        let filteredAttributes = incoming;\n        for (const processor of this._processors) {\n            filteredAttributes = processor.process(filteredAttributes, context);\n        }\n        return filteredAttributes;\n    }\n}\nclass AllowListProcessor {\n    _allowedAttributeNames;\n    constructor(allowedAttributeNames) {\n        this._allowedAttributeNames = new Set(allowedAttributeNames);\n    }\n    process(incoming, _context) {\n        const filteredAttributes = {};\n        for (const attributeName in incoming) {\n            if (Object.prototype.hasOwnProperty.call(incoming, attributeName) &&\n                this._allowedAttributeNames.has(attributeName)) {\n                filteredAttributes[attributeName] = incoming[attributeName];\n            }\n        }\n        return filteredAttributes;\n    }\n}\nclass DenyListProcessor {\n    _deniedAttributeNames;\n    constructor(deniedAttributeNames) {\n        this._deniedAttributeNames = new Set(deniedAttributeNames);\n    }\n    process(incoming, _context) {\n        const filteredAttributes = {};\n        for (const attributeName in incoming) {\n            if (Object.prototype.hasOwnProperty.call(incoming, attributeName) &&\n                !this._deniedAttributeNames.has(attributeName)) {\n                filteredAttributes[attributeName] = incoming[attributeName];\n            }\n        }\n        return filteredAttributes;\n    }\n}\n/**\n * @internal\n *\n * Create an {@link IAttributesProcessor} that acts as a simple pass-through for attributes.\n */\nfunction createNoopAttributesProcessor() {\n    return NOOP;\n}\nexports.createNoopAttributesProcessor = createNoopAttributesProcessor;\n/**\n * @internal\n *\n * Create an {@link IAttributesProcessor} that applies all processors from the provided list in order.\n *\n * @param processors Processors to apply in order.\n */\nfunction createMultiAttributesProcessor(processors) {\n    return new MultiAttributesProcessor(processors);\n}\nexports.createMultiAttributesProcessor = createMultiAttributesProcessor;\n/**\n * Create an {@link IAttributesProcessor} that filters by allowed attribute names and drops any names that are not in the\n * allow list.\n */\nfunction createAllowListAttributesProcessor(attributeAllowList) {\n    return new AllowListProcessor(attributeAllowList);\n}\nexports.createAllowListAttributesProcessor = createAllowListAttributesProcessor;\n/**\n * Create an {@link IAttributesProcessor} that drops attributes based on the names provided in the deny list\n */\nfunction createDenyListAttributesProcessor(attributeDenyList) {\n    return new DenyListProcessor(attributeDenyList);\n}\nexports.createDenyListAttributesProcessor = createDenyListAttributesProcessor;\nconst NOOP = new NoopAttributesProcessor();\n//# sourceMappingURL=AttributesProcessor.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,oCAAoC,QAAQ,qCAAqC,QAAQ,iCAAiC,QAAQ,gCAAgC,KAAK;CAC/K,IAAM,0BAAN,MAA8B;EAC1B,QAAQ,UAAU,UAAU;AACxB,UAAO;;;CAGf,IAAM,2BAAN,MAA+B;EAC3B;EACA,YAAY,YAAY;AACpB,QAAK,cAAc;;EAEvB,QAAQ,UAAU,SAAS;GACvB,IAAI,qBAAqB;AACzB,QAAK,MAAM,aAAa,KAAK,YACzB,sBAAqB,UAAU,QAAQ,oBAAoB,QAAQ;AAEvE,UAAO;;;CAGf,IAAM,qBAAN,MAAyB;EACrB;EACA,YAAY,uBAAuB;AAC/B,QAAK,yBAAyB,IAAI,IAAI,sBAAsB;;EAEhE,QAAQ,UAAU,UAAU;GACxB,MAAM,qBAAqB,EAAE;AAC7B,QAAK,MAAM,iBAAiB,SACxB,KAAI,OAAO,UAAU,eAAe,KAAK,UAAU,cAAc,IAC7D,KAAK,uBAAuB,IAAI,cAAc,CAC9C,oBAAmB,iBAAiB,SAAS;AAGrD,UAAO;;;CAGf,IAAM,oBAAN,MAAwB;EACpB;EACA,YAAY,sBAAsB;AAC9B,QAAK,wBAAwB,IAAI,IAAI,qBAAqB;;EAE9D,QAAQ,UAAU,UAAU;GACxB,MAAM,qBAAqB,EAAE;AAC7B,QAAK,MAAM,iBAAiB,SACxB,KAAI,OAAO,UAAU,eAAe,KAAK,UAAU,cAAc,IAC7D,CAAC,KAAK,sBAAsB,IAAI,cAAc,CAC9C,oBAAmB,iBAAiB,SAAS;AAGrD,UAAO;;;;;;;;CAQf,SAAS,gCAAgC;AACrC,SAAO;;AAEX,SAAQ,gCAAgC;;;;;;;;CAQxC,SAAS,+BAA+B,YAAY;AAChD,SAAO,IAAI,yBAAyB,WAAW;;AAEnD,SAAQ,iCAAiC;;;;;CAKzC,SAAS,mCAAmC,oBAAoB;AAC5D,SAAO,IAAI,mBAAmB,mBAAmB;;AAErD,SAAQ,qCAAqC;;;;CAI7C,SAAS,kCAAkC,mBAAmB;AAC1D,SAAO,IAAI,kBAAkB,kBAAkB;;AAEnD,SAAQ,oCAAoC;CAC5C,MAAM,OAAO,IAAI,yBAAyB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/InstrumentSelector.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"InstrumentSelector.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/InstrumentSelector.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.InstrumentSelector = void 0;\nconst Predicate_1 = require(\"./Predicate\");\nclass InstrumentSelector {\n    _nameFilter;\n    _type;\n    _unitFilter;\n    constructor(criteria) {\n        this._nameFilter = new Predicate_1.PatternPredicate(criteria?.name ?? '*');\n        this._type = criteria?.type;\n        this._unitFilter = new Predicate_1.ExactPredicate(criteria?.unit);\n    }\n    getType() {\n        return this._type;\n    }\n    getNameFilter() {\n        return this._nameFilter;\n    }\n    getUnitFilter() {\n        return this._unitFilter;\n    }\n}\nexports.InstrumentSelector = InstrumentSelector;\n//# sourceMappingURL=InstrumentSelector.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,qBAAqB,KAAK;CAClC,MAAM,cAAA,oBAAA;CACN,IAAM,qBAAN,MAAyB;EACrB;EACA;EACA;EACA,YAAY,UAAU;AAClB,QAAK,cAAc,IAAI,YAAY,iBAAiB,UAAU,QAAQ,IAAI;AAC1E,QAAK,QAAQ,UAAU;AACvB,QAAK,cAAc,IAAI,YAAY,eAAe,UAAU,KAAK;;EAErE,UAAU;AACN,UAAO,KAAK;;EAEhB,gBAAgB;AACZ,UAAO,KAAK;;EAEhB,gBAAgB;AACZ,UAAO,KAAK;;;AAGpB,SAAQ,qBAAqB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/MeterSelector.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MeterSelector.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/MeterSelector.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MeterSelector = void 0;\nconst Predicate_1 = require(\"./Predicate\");\nclass MeterSelector {\n    _nameFilter;\n    _versionFilter;\n    _schemaUrlFilter;\n    constructor(criteria) {\n        this._nameFilter = new Predicate_1.ExactPredicate(criteria?.name);\n        this._versionFilter = new Predicate_1.ExactPredicate(criteria?.version);\n        this._schemaUrlFilter = new Predicate_1.ExactPredicate(criteria?.schemaUrl);\n    }\n    getNameFilter() {\n        return this._nameFilter;\n    }\n    /**\n     * TODO: semver filter? no spec yet.\n     */\n    getVersionFilter() {\n        return this._versionFilter;\n    }\n    getSchemaUrlFilter() {\n        return this._schemaUrlFilter;\n    }\n}\nexports.MeterSelector = MeterSelector;\n//# sourceMappingURL=MeterSelector.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,KAAK;CAC7B,MAAM,cAAA,oBAAA;CACN,IAAM,gBAAN,MAAoB;EAChB;EACA;EACA;EACA,YAAY,UAAU;AAClB,QAAK,cAAc,IAAI,YAAY,eAAe,UAAU,KAAK;AACjE,QAAK,iBAAiB,IAAI,YAAY,eAAe,UAAU,QAAQ;AACvE,QAAK,mBAAmB,IAAI,YAAY,eAAe,UAAU,UAAU;;EAE/E,gBAAgB;AACZ,UAAO,KAAK;;;;;EAKhB,mBAAmB;AACf,UAAO,KAAK;;EAEhB,qBAAqB;AACjB,UAAO,KAAK;;;AAGpB,SAAQ,gBAAgB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/Predicate.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Predicate.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/Predicate.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExactPredicate = exports.PatternPredicate = void 0;\n// https://tc39.es/proposal-regex-escaping\n// escape ^ $ \\ .  + ? ( ) [ ] { } |\n// do not need to escape * as we interpret it as wildcard\nconst ESCAPE = /[\\^$\\\\.+?()[\\]{}|]/g;\n/**\n * Wildcard pattern predicate, supports patterns like `*`, `foo*`, `*bar`.\n */\nclass PatternPredicate {\n    _matchAll;\n    _regexp;\n    constructor(pattern) {\n        if (pattern === '*') {\n            this._matchAll = true;\n            this._regexp = /.*/;\n        }\n        else {\n            this._matchAll = false;\n            this._regexp = new RegExp(PatternPredicate.escapePattern(pattern));\n        }\n    }\n    match(str) {\n        if (this._matchAll) {\n            return true;\n        }\n        return this._regexp.test(str);\n    }\n    static escapePattern(pattern) {\n        return `^${pattern.replace(ESCAPE, '\\\\$&').replace('*', '.*')}$`;\n    }\n    static hasWildcard(pattern) {\n        return pattern.includes('*');\n    }\n}\nexports.PatternPredicate = PatternPredicate;\nclass ExactPredicate {\n    _matchAll;\n    _pattern;\n    constructor(pattern) {\n        this._matchAll = pattern === undefined;\n        this._pattern = pattern;\n    }\n    match(str) {\n        if (this._matchAll) {\n            return true;\n        }\n        if (str === this._pattern) {\n            return true;\n        }\n        return false;\n    }\n}\nexports.ExactPredicate = ExactPredicate;\n//# sourceMappingURL=Predicate.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,iBAAiB,QAAQ,mBAAmB,KAAK;CAIzD,MAAM,SAAS;AA8Bf,SAAQ,mBAAmB,MA1BrB,iBAAiB;EACnB;EACA;EACA,YAAY,SAAS;AACjB,OAAI,YAAY,KAAK;AACjB,SAAK,YAAY;AACjB,SAAK,UAAU;UAEd;AACD,SAAK,YAAY;AACjB,SAAK,UAAU,IAAI,OAAO,iBAAiB,cAAc,QAAQ,CAAC;;;EAG1E,MAAM,KAAK;AACP,OAAI,KAAK,UACL,QAAO;AAEX,UAAO,KAAK,QAAQ,KAAK,IAAI;;EAEjC,OAAO,cAAc,SAAS;AAC1B,UAAO,IAAI,QAAQ,QAAQ,QAAQ,OAAO,CAAC,QAAQ,KAAK,KAAK,CAAC;;EAElE,OAAO,YAAY,SAAS;AACxB,UAAO,QAAQ,SAAS,IAAI;;;CAIpC,IAAM,iBAAN,MAAqB;EACjB;EACA;EACA,YAAY,SAAS;AACjB,QAAK,YAAY,YAAY,KAAA;AAC7B,QAAK,WAAW;;EAEpB,MAAM,KAAK;AACP,OAAI,KAAK,UACL,QAAO;AAEX,OAAI,QAAQ,KAAK,SACb,QAAO;AAEX,UAAO;;;AAGf,SAAQ,iBAAiB"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/RegistrationConflicts.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RegistrationConflicts.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/RegistrationConflicts.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getConflictResolutionRecipe = exports.getDescriptionResolutionRecipe = exports.getTypeConflictResolutionRecipe = exports.getUnitConflictResolutionRecipe = exports.getValueTypeConflictResolutionRecipe = exports.getIncompatibilityDetails = void 0;\nfunction getIncompatibilityDetails(existing, otherDescriptor) {\n    let incompatibility = '';\n    if (existing.unit !== otherDescriptor.unit) {\n        incompatibility += `\\t- Unit '${existing.unit}' does not match '${otherDescriptor.unit}'\\n`;\n    }\n    if (existing.type !== otherDescriptor.type) {\n        incompatibility += `\\t- Type '${existing.type}' does not match '${otherDescriptor.type}'\\n`;\n    }\n    if (existing.valueType !== otherDescriptor.valueType) {\n        incompatibility += `\\t- Value Type '${existing.valueType}' does not match '${otherDescriptor.valueType}'\\n`;\n    }\n    if (existing.description !== otherDescriptor.description) {\n        incompatibility += `\\t- Description '${existing.description}' does not match '${otherDescriptor.description}'\\n`;\n    }\n    return incompatibility;\n}\nexports.getIncompatibilityDetails = getIncompatibilityDetails;\nfunction getValueTypeConflictResolutionRecipe(existing, otherDescriptor) {\n    return `\\t- use valueType '${existing.valueType}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`;\n}\nexports.getValueTypeConflictResolutionRecipe = getValueTypeConflictResolutionRecipe;\nfunction getUnitConflictResolutionRecipe(existing, otherDescriptor) {\n    return `\\t- use unit '${existing.unit}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`;\n}\nexports.getUnitConflictResolutionRecipe = getUnitConflictResolutionRecipe;\nfunction getTypeConflictResolutionRecipe(existing, otherDescriptor) {\n    const selector = {\n        name: otherDescriptor.name,\n        type: otherDescriptor.type,\n        unit: otherDescriptor.unit,\n    };\n    const selectorString = JSON.stringify(selector);\n    return `\\t- create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}'`;\n}\nexports.getTypeConflictResolutionRecipe = getTypeConflictResolutionRecipe;\nfunction getDescriptionResolutionRecipe(existing, otherDescriptor) {\n    const selector = {\n        name: otherDescriptor.name,\n        type: otherDescriptor.type,\n        unit: otherDescriptor.unit,\n    };\n    const selectorString = JSON.stringify(selector);\n    return `\\t- create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}'\n    \\t- OR - create a new view with the name ${existing.name} and description '${existing.description}' and InstrumentSelector ${selectorString}\n    \\t- OR - create a new view with the name ${otherDescriptor.name} and description '${existing.description}' and InstrumentSelector ${selectorString}`;\n}\nexports.getDescriptionResolutionRecipe = getDescriptionResolutionRecipe;\nfunction getConflictResolutionRecipe(existing, otherDescriptor) {\n    // Conflicts that cannot be solved via views.\n    if (existing.valueType !== otherDescriptor.valueType) {\n        return getValueTypeConflictResolutionRecipe(existing, otherDescriptor);\n    }\n    if (existing.unit !== otherDescriptor.unit) {\n        return getUnitConflictResolutionRecipe(existing, otherDescriptor);\n    }\n    // Conflicts that can be solved via views.\n    if (existing.type !== otherDescriptor.type) {\n        // this will automatically solve possible description conflicts.\n        return getTypeConflictResolutionRecipe(existing, otherDescriptor);\n    }\n    if (existing.description !== otherDescriptor.description) {\n        return getDescriptionResolutionRecipe(existing, otherDescriptor);\n    }\n    return '';\n}\nexports.getConflictResolutionRecipe = getConflictResolutionRecipe;\n//# sourceMappingURL=RegistrationConflicts.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,8BAA8B,QAAQ,iCAAiC,QAAQ,kCAAkC,QAAQ,kCAAkC,QAAQ,uCAAuC,QAAQ,4BAA4B,KAAK;CAC3P,SAAS,0BAA0B,UAAU,iBAAiB;EAC1D,IAAI,kBAAkB;AACtB,MAAI,SAAS,SAAS,gBAAgB,KAClC,oBAAmB,aAAa,SAAS,KAAK,oBAAoB,gBAAgB,KAAK;AAE3F,MAAI,SAAS,SAAS,gBAAgB,KAClC,oBAAmB,aAAa,SAAS,KAAK,oBAAoB,gBAAgB,KAAK;AAE3F,MAAI,SAAS,cAAc,gBAAgB,UACvC,oBAAmB,mBAAmB,SAAS,UAAU,oBAAoB,gBAAgB,UAAU;AAE3G,MAAI,SAAS,gBAAgB,gBAAgB,YACzC,oBAAmB,oBAAoB,SAAS,YAAY,oBAAoB,gBAAgB,YAAY;AAEhH,SAAO;;AAEX,SAAQ,4BAA4B;CACpC,SAAS,qCAAqC,UAAU,iBAAiB;AACrE,SAAO,sBAAsB,SAAS,UAAU,iEAAiE,gBAAgB,KAAK;;AAE1I,SAAQ,uCAAuC;CAC/C,SAAS,gCAAgC,UAAU,iBAAiB;AAChE,SAAO,iBAAiB,SAAS,KAAK,iEAAiE,gBAAgB,KAAK;;AAEhI,SAAQ,kCAAkC;CAC1C,SAAS,gCAAgC,UAAU,iBAAiB;EAChE,MAAM,WAAW;GACb,MAAM,gBAAgB;GACtB,MAAM,gBAAgB;GACtB,MAAM,gBAAgB;GACzB;EACD,MAAM,iBAAiB,KAAK,UAAU,SAAS;AAC/C,SAAO,iDAAiD,SAAS,KAAK,4BAA4B,eAAe;;AAErH,SAAQ,kCAAkC;CAC1C,SAAS,+BAA+B,UAAU,iBAAiB;EAC/D,MAAM,WAAW;GACb,MAAM,gBAAgB;GACtB,MAAM,gBAAgB;GACtB,MAAM,gBAAgB;GACzB;EACD,MAAM,iBAAiB,KAAK,UAAU,SAAS;AAC/C,SAAO,iDAAiD,SAAS,KAAK,4BAA4B,eAAe;+CACtE,SAAS,KAAK,oBAAoB,SAAS,YAAY,2BAA2B,eAAe;+CACjG,gBAAgB,KAAK,oBAAoB,SAAS,YAAY,2BAA2B;;AAExI,SAAQ,iCAAiC;CACzC,SAAS,4BAA4B,UAAU,iBAAiB;AAE5D,MAAI,SAAS,cAAc,gBAAgB,UACvC,QAAO,qCAAqC,UAAU,gBAAgB;AAE1E,MAAI,SAAS,SAAS,gBAAgB,KAClC,QAAO,gCAAgC,UAAU,gBAAgB;AAGrE,MAAI,SAAS,SAAS,gBAAgB,KAElC,QAAO,gCAAgC,UAAU,gBAAgB;AAErE,MAAI,SAAS,gBAAgB,gBAAgB,YACzC,QAAO,+BAA+B,UAAU,gBAAgB;AAEpE,SAAO;;AAEX,SAAQ,8BAA8B"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/View.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"View.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/View.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.View = void 0;\nconst Predicate_1 = require(\"./Predicate\");\nconst AttributesProcessor_1 = require(\"./AttributesProcessor\");\nconst InstrumentSelector_1 = require(\"./InstrumentSelector\");\nconst MeterSelector_1 = require(\"./MeterSelector\");\nconst AggregationOption_1 = require(\"./AggregationOption\");\nfunction isSelectorNotProvided(options) {\n    return (options.instrumentName == null &&\n        options.instrumentType == null &&\n        options.instrumentUnit == null &&\n        options.meterName == null &&\n        options.meterVersion == null &&\n        options.meterSchemaUrl == null);\n}\nfunction validateViewOptions(viewOptions) {\n    // If no criteria is provided, the SDK SHOULD treat it as an error.\n    // It is recommended that the SDK implementations fail fast.\n    if (isSelectorNotProvided(viewOptions)) {\n        throw new Error('Cannot create view with no selector arguments supplied');\n    }\n    // the SDK SHOULD NOT allow Views with a specified name to be declared with instrument selectors that\n    // may select more than one instrument (e.g. wild card instrument name) in the same Meter.\n    if (viewOptions.name != null &&\n        (viewOptions?.instrumentName == null ||\n            Predicate_1.PatternPredicate.hasWildcard(viewOptions.instrumentName))) {\n        throw new Error('Views with a specified name must be declared with an instrument selector that selects at most one instrument per meter.');\n    }\n}\n/**\n * Can be passed to a {@link MeterProvider} to select instruments and alter their metric stream.\n */\nclass View {\n    name;\n    description;\n    aggregation;\n    attributesProcessor;\n    instrumentSelector;\n    meterSelector;\n    aggregationCardinalityLimit;\n    /**\n     * Create a new {@link View} instance.\n     *\n     * Parameters can be categorized as two types:\n     *  Instrument selection criteria: Used to describe the instrument(s) this view will be applied to.\n     *  Will be treated as additive (the Instrument has to meet all the provided criteria to be selected).\n     *\n     *  Metric stream altering: Alter the metric stream of instruments selected by instrument selection criteria.\n     *\n     * @param viewOptions {@link ViewOptions} for altering the metric stream and instrument selection.\n     * @param viewOptions.name\n     * Alters the metric stream:\n     *  This will be used as the name of the metrics stream.\n     *  If not provided, the original Instrument name will be used.\n     * @param viewOptions.description\n     * Alters the metric stream:\n     *  This will be used as the description of the metrics stream.\n     *  If not provided, the original Instrument description will be used by default.\n     * @param viewOptions.attributesProcessors\n     * Alters the metric stream:\n     *  If provided, the attributes will be modified as defined by the added processors.\n     *  If not provided, all attribute keys will be used by default.\n     * @param viewOptions.aggregationCardinalityLimit\n     * Alters the metric stream:\n     *  Sets a limit on the number of unique attribute combinations (cardinality) that can be aggregated.\n     *  If not provided, the default limit of 2000 will be used.\n     * @param viewOptions.aggregation\n     * Alters the metric stream:\n     *  Alters the {@link Aggregation} of the metric stream.\n     * @param viewOptions.instrumentName\n     * Instrument selection criteria:\n     *  Original name of the Instrument(s) with wildcard support.\n     * @param viewOptions.instrumentType\n     * Instrument selection criteria:\n     *  The original type of the Instrument(s).\n     * @param viewOptions.instrumentUnit\n     * Instrument selection criteria:\n     *  The unit of the Instrument(s).\n     * @param viewOptions.meterName\n     * Instrument selection criteria:\n     *  The name of the Meter. No wildcard support, name must match the meter exactly.\n     * @param viewOptions.meterVersion\n     * Instrument selection criteria:\n     *  The version of the Meter. No wildcard support, version must match exactly.\n     * @param viewOptions.meterSchemaUrl\n     * Instrument selection criteria:\n     *  The schema URL of the Meter. No wildcard support, schema URL must match exactly.\n     *\n     * @example\n     * // Create a view that changes the Instrument 'my.instrument' to use to an\n     * // ExplicitBucketHistogramAggregation with the boundaries [20, 30, 40]\n     * new View({\n     *   aggregation: new ExplicitBucketHistogramAggregation([20, 30, 40]),\n     *   instrumentName: 'my.instrument'\n     * })\n     */\n    constructor(viewOptions) {\n        validateViewOptions(viewOptions);\n        // Create multi-processor if attributesProcessors are defined.\n        if (viewOptions.attributesProcessors != null) {\n            this.attributesProcessor = (0, AttributesProcessor_1.createMultiAttributesProcessor)(viewOptions.attributesProcessors);\n        }\n        else {\n            this.attributesProcessor = (0, AttributesProcessor_1.createNoopAttributesProcessor)();\n        }\n        this.name = viewOptions.name;\n        this.description = viewOptions.description;\n        this.aggregation = (0, AggregationOption_1.toAggregation)(viewOptions.aggregation ?? { type: AggregationOption_1.AggregationType.DEFAULT });\n        this.instrumentSelector = new InstrumentSelector_1.InstrumentSelector({\n            name: viewOptions.instrumentName,\n            type: viewOptions.instrumentType,\n            unit: viewOptions.instrumentUnit,\n        });\n        this.meterSelector = new MeterSelector_1.MeterSelector({\n            name: viewOptions.meterName,\n            version: viewOptions.meterVersion,\n            schemaUrl: viewOptions.meterSchemaUrl,\n        });\n        this.aggregationCardinalityLimit = viewOptions.aggregationCardinalityLimit;\n    }\n}\nexports.View = View;\n//# sourceMappingURL=View.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,OAAO,KAAK;CACpB,MAAM,cAAA,oBAAA;CACN,MAAM,wBAAA,8BAAA;CACN,MAAM,uBAAA,6BAAA;CACN,MAAM,kBAAA,wBAAA;CACN,MAAM,sBAAA,4BAAA;CACN,SAAS,sBAAsB,SAAS;AACpC,SAAQ,QAAQ,kBAAkB,QAC9B,QAAQ,kBAAkB,QAC1B,QAAQ,kBAAkB,QAC1B,QAAQ,aAAa,QACrB,QAAQ,gBAAgB,QACxB,QAAQ,kBAAkB;;CAElC,SAAS,oBAAoB,aAAa;AAGtC,MAAI,sBAAsB,YAAY,CAClC,OAAM,IAAI,MAAM,yDAAyD;AAI7E,MAAI,YAAY,QAAQ,SACnB,aAAa,kBAAkB,QAC5B,YAAY,iBAAiB,YAAY,YAAY,eAAe,EACxE,OAAM,IAAI,MAAM,0HAA0H;;;;;CAMlJ,IAAM,OAAN,MAAW;EACP;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDA,YAAY,aAAa;AACrB,uBAAoB,YAAY;AAEhC,OAAI,YAAY,wBAAwB,KACpC,MAAK,uBAAuB,GAAG,sBAAsB,gCAAgC,YAAY,qBAAqB;OAGtH,MAAK,uBAAuB,GAAG,sBAAsB,gCAAgC;AAEzF,QAAK,OAAO,YAAY;AACxB,QAAK,cAAc,YAAY;AAC/B,QAAK,eAAe,GAAG,oBAAoB,eAAe,YAAY,eAAe,EAAE,MAAM,oBAAoB,gBAAgB,SAAS,CAAC;AAC3I,QAAK,qBAAqB,IAAI,qBAAqB,mBAAmB;IAClE,MAAM,YAAY;IAClB,MAAM,YAAY;IAClB,MAAM,YAAY;IACrB,CAAC;AACF,QAAK,gBAAgB,IAAI,gBAAgB,cAAc;IACnD,MAAM,YAAY;IAClB,SAAS,YAAY;IACrB,WAAW,YAAY;IAC1B,CAAC;AACF,QAAK,8BAA8B,YAAY;;;AAGvD,SAAQ,OAAO"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/ViewRegistry.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ViewRegistry.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/view/ViewRegistry.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ViewRegistry = void 0;\nclass ViewRegistry {\n    _registeredViews = [];\n    addView(view) {\n        this._registeredViews.push(view);\n    }\n    findViews(instrument, meter) {\n        const views = this._registeredViews.filter(registeredView => {\n            return (this._matchInstrument(registeredView.instrumentSelector, instrument) &&\n                this._matchMeter(registeredView.meterSelector, meter));\n        });\n        return views;\n    }\n    _matchInstrument(selector, instrument) {\n        return ((selector.getType() === undefined ||\n            instrument.type === selector.getType()) &&\n            selector.getNameFilter().match(instrument.name) &&\n            selector.getUnitFilter().match(instrument.unit));\n    }\n    _matchMeter(selector, meter) {\n        return (selector.getNameFilter().match(meter.name) &&\n            (meter.version === undefined ||\n                selector.getVersionFilter().match(meter.version)) &&\n            (meter.schemaUrl === undefined ||\n                selector.getSchemaUrlFilter().match(meter.schemaUrl)));\n    }\n}\nexports.ViewRegistry = ViewRegistry;\n//# sourceMappingURL=ViewRegistry.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,eAAe,KAAK;CAC5B,IAAM,eAAN,MAAmB;EACf,mBAAmB,EAAE;EACrB,QAAQ,MAAM;AACV,QAAK,iBAAiB,KAAK,KAAK;;EAEpC,UAAU,YAAY,OAAO;AAKzB,UAJc,KAAK,iBAAiB,QAAO,mBAAkB;AACzD,WAAQ,KAAK,iBAAiB,eAAe,oBAAoB,WAAW,IACxE,KAAK,YAAY,eAAe,eAAe,MAAM;KAEjD;;EAEhB,iBAAiB,UAAU,YAAY;AACnC,WAAS,SAAS,SAAS,KAAK,KAAA,KAC5B,WAAW,SAAS,SAAS,SAAS,KACtC,SAAS,eAAe,CAAC,MAAM,WAAW,KAAK,IAC/C,SAAS,eAAe,CAAC,MAAM,WAAW,KAAK;;EAEvD,YAAY,UAAU,OAAO;AACzB,UAAQ,SAAS,eAAe,CAAC,MAAM,MAAM,KAAK,KAC7C,MAAM,YAAY,KAAA,KACf,SAAS,kBAAkB,CAAC,MAAM,MAAM,QAAQ,MACnD,MAAM,cAAc,KAAA,KACjB,SAAS,oBAAoB,CAAC,MAAM,MAAM,UAAU;;;AAGpE,SAAQ,eAAe"}

package/dist/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hoist-non-react-statics.cjs.cjs","names":[],"sources":["../../../../../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js"],"sourcesContent":["'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n"],"x_google_ignoreList":[0],"mappings":";;;;;CAEA,IAAI,UAAA,cAAA;;;;;CAMJ,IAAI,gBAAgB;EAClB,mBAAmB;EACnB,aAAa;EACb,cAAc;EACd,cAAc;EACd,aAAa;EACb,iBAAiB;EACjB,0BAA0B;EAC1B,0BAA0B;EAC1B,QAAQ;EACR,WAAW;EACX,MAAM;EACP;CACD,IAAI,gBAAgB;EAClB,MAAM;EACN,QAAQ;EACR,WAAW;EACX,QAAQ;EACR,QAAQ;EACR,WAAW;EACX,OAAO;EACR;CACD,IAAI,sBAAsB;EACxB,YAAY;EACZ,QAAQ;EACR,cAAc;EACd,aAAa;EACb,WAAW;EACZ;CACD,IAAI,eAAe;EACjB,YAAY;EACZ,SAAS;EACT,cAAc;EACd,aAAa;EACb,WAAW;EACX,MAAM;EACP;CACD,IAAI,eAAe,EAAE;AACrB,cAAa,QAAQ,cAAc;AACnC,cAAa,QAAQ,QAAQ;CAE7B,SAAS,WAAW,WAAW;AAE7B,MAAI,QAAQ,OAAO,UAAU,CAC3B,QAAO;AAIT,SAAO,aAAa,UAAU,gBAAgB;;CAGhD,IAAI,iBAAiB,OAAO;CAC5B,IAAI,sBAAsB,OAAO;CACjC,IAAI,wBAAwB,OAAO;CACnC,IAAI,2BAA2B,OAAO;CACtC,IAAI,iBAAiB,OAAO;CAC5B,IAAI,kBAAkB,OAAO;CAC7B,SAAS,qBAAqB,iBAAiB,iBAAiB,WAAW;AACzE,MAAI,OAAO,oBAAoB,UAAU;AAEvC,OAAI,iBAAiB;IACnB,IAAI,qBAAqB,eAAe,gBAAgB;AAExD,QAAI,sBAAsB,uBAAuB,gBAC/C,sBAAqB,iBAAiB,oBAAoB,UAAU;;GAIxE,IAAI,OAAO,oBAAoB,gBAAgB;AAE/C,OAAI,sBACF,QAAO,KAAK,OAAO,sBAAsB,gBAAgB,CAAC;GAG5D,IAAI,gBAAgB,WAAW,gBAAgB;GAC/C,IAAI,gBAAgB,WAAW,gBAAgB;AAE/C,QAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,EAAE,GAAG;IACpC,IAAI,MAAM,KAAK;AAEf,QAAI,CAAC,cAAc,QAAQ,EAAE,aAAa,UAAU,SAAS,EAAE,iBAAiB,cAAc,SAAS,EAAE,iBAAiB,cAAc,OAAO;KAC7I,IAAI,aAAa,yBAAyB,iBAAiB,IAAI;AAE/D,SAAI;AAEF,qBAAe,iBAAiB,KAAK,WAAW;cACzC,GAAG;;;;AAKlB,SAAO;;AAGT,QAAO,UAAU"}