@safaricom-mxl/web-sdk 0.0.17 → 0.0.19

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.d.cts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.d.ts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.cjs

@@ -0,0 +1,84 @@
+"use strict";
+const require_runtime = require("../../../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricData$1 = require("../export/MetricData.cjs");
+const require_types$1 = require("./types.cjs");
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.js
+var require_LastValue = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.LastValueAggregator = exports.LastValueAccumulation = void 0;
+	const types_1 = require_types$1.default;
+	const core_1 = require("@opentelemetry/core");
+	const MetricData_1 = require_MetricData$1.default;
+	var LastValueAccumulation = class {
+		startTime;
+		_current;
+		sampleTime;
+		constructor(startTime, current = 0, sampleTime = [0, 0]) {
+			this.startTime = startTime;
+			this._current = current;
+			this.sampleTime = sampleTime;
+		}
+		record(value) {
+			this._current = value;
+			this.sampleTime = (0, core_1.millisToHrTime)(Date.now());
+		}
+		setStartTime(startTime) {
+			this.startTime = startTime;
+		}
+		toPointValue() {
+			return this._current;
+		}
+	};
+	exports.LastValueAccumulation = LastValueAccumulation;
+	/** Basic aggregator which calculates a LastValue from individual measurements. */
+	var LastValueAggregator = class {
+		kind = types_1.AggregatorKind.LAST_VALUE;
+		createAccumulation(startTime) {
+			return new LastValueAccumulation(startTime);
+		}
+		/**
+		* Returns the result of the merge of the given accumulations.
+		*
+		* Return the newly captured (delta) accumulation for LastValueAggregator.
+		*/
+		merge(previous, delta) {
+			const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(delta.sampleTime) >= (0, core_1.hrTimeToMicroseconds)(previous.sampleTime) ? delta : previous;
+			return new LastValueAccumulation(previous.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+		}
+		/**
+		* Returns a new DELTA aggregation by comparing two cumulative measurements.
+		*
+		* A delta aggregation is not meaningful to LastValueAggregator, just return
+		* the newly captured (delta) accumulation for LastValueAggregator.
+		*/
+		diff(previous, current) {
+			const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(current.sampleTime) >= (0, core_1.hrTimeToMicroseconds)(previous.sampleTime) ? current : previous;
+			return new LastValueAccumulation(current.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+		}
+		toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+			return {
+				descriptor,
+				aggregationTemporality,
+				dataPointType: MetricData_1.DataPointType.GAUGE,
+				dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+					return {
+						attributes,
+						startTime: accumulation.startTime,
+						endTime,
+						value: accumulation.toPointValue()
+					};
+				})
+			};
+		}
+	};
+	exports.LastValueAggregator = LastValueAggregator;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_LastValue();
+	}
+});
+
+//# sourceMappingURL=LastValue.cjs.map

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LastValue.cjs","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/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/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.d.cts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.d.ts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.cjs

@@ -0,0 +1,94 @@
+"use strict";
+const require_runtime = require("../../../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricData$1 = require("../export/MetricData.cjs");
+const require_types$1 = require("./types.cjs");
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.js
+var require_Sum = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SumAggregator = exports.SumAccumulation = void 0;
+	const types_1 = require_types$1.default;
+	const MetricData_1 = require_MetricData$1.default;
+	var SumAccumulation = class {
+		startTime;
+		monotonic;
+		_current;
+		reset;
+		constructor(startTime, monotonic, current = 0, reset = false) {
+			this.startTime = startTime;
+			this.monotonic = monotonic;
+			this._current = current;
+			this.reset = reset;
+		}
+		record(value) {
+			if (this.monotonic && value < 0) return;
+			this._current += value;
+		}
+		setStartTime(startTime) {
+			this.startTime = startTime;
+		}
+		toPointValue() {
+			return this._current;
+		}
+	};
+	exports.SumAccumulation = SumAccumulation;
+	/** Basic aggregator which calculates a Sum from individual measurements. */
+	var SumAggregator = class {
+		kind = types_1.AggregatorKind.SUM;
+		monotonic;
+		constructor(monotonic) {
+			this.monotonic = monotonic;
+		}
+		createAccumulation(startTime) {
+			return new SumAccumulation(startTime, this.monotonic);
+		}
+		/**
+		* Returns the result of the merge of the given accumulations.
+		*/
+		merge(previous, delta) {
+			const prevPv = previous.toPointValue();
+			const deltaPv = delta.toPointValue();
+			if (delta.reset) return new SumAccumulation(delta.startTime, this.monotonic, deltaPv, delta.reset);
+			return new SumAccumulation(previous.startTime, this.monotonic, prevPv + deltaPv);
+		}
+		/**
+		* Returns a new DELTA aggregation by comparing two cumulative measurements.
+		*/
+		diff(previous, current) {
+			const prevPv = previous.toPointValue();
+			const currPv = current.toPointValue();
+			/**
+			* If the SumAggregator is a monotonic one and the previous point value is
+			* greater than the current one, a reset is deemed to be happened.
+			* Return the current point value to prevent the value from been reset.
+			*/
+			if (this.monotonic && prevPv > currPv) return new SumAccumulation(current.startTime, this.monotonic, currPv, true);
+			return new SumAccumulation(current.startTime, this.monotonic, currPv - prevPv);
+		}
+		toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+			return {
+				descriptor,
+				aggregationTemporality,
+				dataPointType: MetricData_1.DataPointType.SUM,
+				dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+					return {
+						attributes,
+						startTime: accumulation.startTime,
+						endTime,
+						value: accumulation.toPointValue()
+					};
+				}),
+				isMonotonic: this.monotonic
+			};
+		}
+	};
+	exports.SumAggregator = SumAggregator;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_Sum();
+	}
+});
+
+//# sourceMappingURL=Sum.cjs.map

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sum.cjs","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/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/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.d.cts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.d.ts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.cjs

@@ -0,0 +1,246 @@
+"use strict";
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.js
+var require_Buckets = /* @__PURE__ */ require("../../../../../../../../../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Buckets = void 0;
+	exports.Buckets = class Buckets {
+		backing;
+		indexBase;
+		indexStart;
+		indexEnd;
+		/**
+		* The term index refers to the number of the exponential histogram bucket
+		* used to determine its boundaries. The lower boundary of a bucket is
+		* determined by base ** index and the upper boundary of a bucket is
+		* determined by base ** (index + 1). index values are signed to account
+		* for values less than or equal to 1.
+		*
+		* indexBase is the index of the 0th position in the
+		* backing array, i.e., backing[0] is the count
+		* in the bucket with index `indexBase`.
+		*
+		* indexStart is the smallest index value represented
+		* in the backing array.
+		*
+		* indexEnd is the largest index value represented in
+		* the backing array.
+		*/
+		constructor(backing = new BucketsBacking(), indexBase = 0, indexStart = 0, indexEnd = 0) {
+			this.backing = backing;
+			this.indexBase = indexBase;
+			this.indexStart = indexStart;
+			this.indexEnd = indexEnd;
+		}
+		/**
+		* Offset is the bucket index of the smallest entry in the counts array
+		* @returns {number}
+		*/
+		get offset() {
+			return this.indexStart;
+		}
+		/**
+		* Buckets is a view into the backing array.
+		* @returns {number}
+		*/
+		get length() {
+			if (this.backing.length === 0) return 0;
+			if (this.indexEnd === this.indexStart && this.at(0) === 0) return 0;
+			return this.indexEnd - this.indexStart + 1;
+		}
+		/**
+		* An array of counts, where count[i] carries the count
+		* of the bucket at index (offset+i).  count[i] is the count of
+		* values greater than base^(offset+i) and less than or equal to
+		* base^(offset+i+1).
+		* @returns {number} The logical counts based on the backing array
+		*/
+		counts() {
+			return Array.from({ length: this.length }, (_, i) => this.at(i));
+		}
+		/**
+		* At returns the count of the bucket at a position in the logical
+		* array of counts.
+		* @param position
+		* @returns {number}
+		*/
+		at(position) {
+			const bias = this.indexBase - this.indexStart;
+			if (position < bias) position += this.backing.length;
+			position -= bias;
+			return this.backing.countAt(position);
+		}
+		/**
+		* incrementBucket increments the backing array index by `increment`
+		* @param bucketIndex
+		* @param increment
+		*/
+		incrementBucket(bucketIndex, increment) {
+			this.backing.increment(bucketIndex, increment);
+		}
+		/**
+		* decrementBucket decrements the backing array index by `decrement`
+		* if decrement is greater than the current value, it's set to 0.
+		* @param bucketIndex
+		* @param decrement
+		*/
+		decrementBucket(bucketIndex, decrement) {
+			this.backing.decrement(bucketIndex, decrement);
+		}
+		/**
+		* trim removes leading and / or trailing zero buckets (which can occur
+		* after diffing two histos) and rotates the backing array so that the
+		* smallest non-zero index is in the 0th position of the backing array
+		*/
+		trim() {
+			for (let i = 0; i < this.length; i++) if (this.at(i) !== 0) {
+				this.indexStart += i;
+				break;
+			} else if (i === this.length - 1) {
+				this.indexStart = this.indexEnd = this.indexBase = 0;
+				return;
+			}
+			for (let i = this.length - 1; i >= 0; i--) if (this.at(i) !== 0) {
+				this.indexEnd -= this.length - i - 1;
+				break;
+			}
+			this._rotate();
+		}
+		/**
+		* downscale first rotates, then collapses 2**`by`-to-1 buckets.
+		* @param by
+		*/
+		downscale(by) {
+			this._rotate();
+			const size = 1 + this.indexEnd - this.indexStart;
+			const each = 1 << by;
+			let inpos = 0;
+			let outpos = 0;
+			for (let pos = this.indexStart; pos <= this.indexEnd;) {
+				let mod = pos % each;
+				if (mod < 0) mod += each;
+				for (let i = mod; i < each && inpos < size; i++) {
+					this._relocateBucket(outpos, inpos);
+					inpos++;
+					pos++;
+				}
+				outpos++;
+			}
+			this.indexStart >>= by;
+			this.indexEnd >>= by;
+			this.indexBase = this.indexStart;
+		}
+		/**
+		* Clone returns a deep copy of Buckets
+		* @returns {Buckets}
+		*/
+		clone() {
+			return new Buckets(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd);
+		}
+		/**
+		* _rotate shifts the backing array contents so that indexStart ==
+		* indexBase to simplify the downscale logic.
+		*/
+		_rotate() {
+			const bias = this.indexBase - this.indexStart;
+			if (bias === 0) return;
+			else if (bias > 0) {
+				this.backing.reverse(0, this.backing.length);
+				this.backing.reverse(0, bias);
+				this.backing.reverse(bias, this.backing.length);
+			} else {
+				this.backing.reverse(0, this.backing.length);
+				this.backing.reverse(0, this.backing.length + bias);
+			}
+			this.indexBase = this.indexStart;
+		}
+		/**
+		* _relocateBucket adds the count in counts[src] to counts[dest] and
+		* resets count[src] to zero.
+		*/
+		_relocateBucket(dest, src) {
+			if (dest === src) return;
+			this.incrementBucket(dest, this.backing.emptyBucket(src));
+		}
+	};
+	/**
+	* BucketsBacking holds the raw buckets and some utility methods to
+	* manage them.
+	*/
+	var BucketsBacking = class BucketsBacking {
+		_counts;
+		constructor(counts = [0]) {
+			this._counts = counts;
+		}
+		/**
+		* length returns the physical size of the backing array, which
+		* is >= buckets.length()
+		*/
+		get length() {
+			return this._counts.length;
+		}
+		/**
+		* countAt returns the count in a specific bucket
+		*/
+		countAt(pos) {
+			return this._counts[pos];
+		}
+		/**
+		* growTo grows a backing array and copies old entries
+		* into their correct new positions.
+		*/
+		growTo(newSize, oldPositiveLimit, newPositiveLimit) {
+			const tmp = new Array(newSize).fill(0);
+			tmp.splice(newPositiveLimit, this._counts.length - oldPositiveLimit, ...this._counts.slice(oldPositiveLimit));
+			tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit));
+			this._counts = tmp;
+		}
+		/**
+		* reverse the items in the backing array in the range [from, limit).
+		*/
+		reverse(from, limit) {
+			const num = Math.floor((from + limit) / 2) - from;
+			for (let i = 0; i < num; i++) {
+				const tmp = this._counts[from + i];
+				this._counts[from + i] = this._counts[limit - i - 1];
+				this._counts[limit - i - 1] = tmp;
+			}
+		}
+		/**
+		* emptyBucket empties the count from a bucket, for
+		* moving into another.
+		*/
+		emptyBucket(src) {
+			const tmp = this._counts[src];
+			this._counts[src] = 0;
+			return tmp;
+		}
+		/**
+		* increments a bucket by `increment`
+		*/
+		increment(bucketIndex, increment) {
+			this._counts[bucketIndex] += increment;
+		}
+		/**
+		* decrements a bucket by `decrement`
+		*/
+		decrement(bucketIndex, decrement) {
+			if (this._counts[bucketIndex] >= decrement) this._counts[bucketIndex] -= decrement;
+			else this._counts[bucketIndex] = 0;
+		}
+		/**
+		* clone returns a deep copy of BucketsBacking
+		*/
+		clone() {
+			return new BucketsBacking([...this._counts]);
+		}
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_Buckets();
+	}
+});
+
+//# sourceMappingURL=Buckets.cjs.map

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Buckets.cjs","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/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":";;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,UAAU,KAAK;AAwLvB,SAAQ,UAAU,MAnLZ,QAAQ;EACV;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;EAkBA,YAAY,UAAU,IAAI,gBAAgB,EAAE,YAAY,GAAG,aAAa,GAAG,WAAW,GAAG;AACrF,QAAK,UAAU;AACf,QAAK,YAAY;AACjB,QAAK,aAAa;AAClB,QAAK,WAAW;;;;;;EAMpB,IAAI,SAAS;AACT,UAAO,KAAK;;;;;;EAMhB,IAAI,SAAS;AACT,OAAI,KAAK,QAAQ,WAAW,EACxB,QAAO;AAEX,OAAI,KAAK,aAAa,KAAK,cAAc,KAAK,GAAG,EAAE,KAAK,EACpD,QAAO;AAEX,UAAO,KAAK,WAAW,KAAK,aAAa;;;;;;;;;EAS7C,SAAS;AACL,UAAO,MAAM,KAAK,EAAE,QAAQ,KAAK,QAAQ,GAAG,GAAG,MAAM,KAAK,GAAG,EAAE,CAAC;;;;;;;;EAQpE,GAAG,UAAU;GACT,MAAM,OAAO,KAAK,YAAY,KAAK;AACnC,OAAI,WAAW,KACX,aAAY,KAAK,QAAQ;AAE7B,eAAY;AACZ,UAAO,KAAK,QAAQ,QAAQ,SAAS;;;;;;;EAOzC,gBAAgB,aAAa,WAAW;AACpC,QAAK,QAAQ,UAAU,aAAa,UAAU;;;;;;;;EAQlD,gBAAgB,aAAa,WAAW;AACpC,QAAK,QAAQ,UAAU,aAAa,UAAU;;;;;;;EAOlD,OAAO;AACH,QAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC7B,KAAI,KAAK,GAAG,EAAE,KAAK,GAAG;AAClB,SAAK,cAAc;AACnB;cAEK,MAAM,KAAK,SAAS,GAAG;AAE5B,SAAK,aAAa,KAAK,WAAW,KAAK,YAAY;AACnD;;AAGR,QAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,GAAG,IAClC,KAAI,KAAK,GAAG,EAAE,KAAK,GAAG;AAClB,SAAK,YAAY,KAAK,SAAS,IAAI;AACnC;;AAGR,QAAK,SAAS;;;;;;EAMlB,UAAU,IAAI;AACV,QAAK,SAAS;GACd,MAAM,OAAO,IAAI,KAAK,WAAW,KAAK;GACtC,MAAM,OAAO,KAAK;GAClB,IAAI,QAAQ;GACZ,IAAI,SAAS;AACb,QAAK,IAAI,MAAM,KAAK,YAAY,OAAO,KAAK,WAAW;IACnD,IAAI,MAAM,MAAM;AAChB,QAAI,MAAM,EACN,QAAO;AAEX,SAAK,IAAI,IAAI,KAAK,IAAI,QAAQ,QAAQ,MAAM,KAAK;AAC7C,UAAK,gBAAgB,QAAQ,MAAM;AACnC;AACA;;AAEJ;;AAEJ,QAAK,eAAe;AACpB,QAAK,aAAa;AAClB,QAAK,YAAY,KAAK;;;;;;EAM1B,QAAQ;AACJ,UAAO,IAAI,QAAQ,KAAK,QAAQ,OAAO,EAAE,KAAK,WAAW,KAAK,YAAY,KAAK,SAAS;;;;;;EAM5F,UAAU;GACN,MAAM,OAAO,KAAK,YAAY,KAAK;AACnC,OAAI,SAAS,EACT;YAEK,OAAO,GAAG;AACf,SAAK,QAAQ,QAAQ,GAAG,KAAK,QAAQ,OAAO;AAC5C,SAAK,QAAQ,QAAQ,GAAG,KAAK;AAC7B,SAAK,QAAQ,QAAQ,MAAM,KAAK,QAAQ,OAAO;UAE9C;AAED,SAAK,QAAQ,QAAQ,GAAG,KAAK,QAAQ,OAAO;AAC5C,SAAK,QAAQ,QAAQ,GAAG,KAAK,QAAQ,SAAS,KAAK;;AAEvD,QAAK,YAAY,KAAK;;;;;;EAM1B,gBAAgB,MAAM,KAAK;AACvB,OAAI,SAAS,IACT;AAEJ,QAAK,gBAAgB,MAAM,KAAK,QAAQ,YAAY,IAAI,CAAC;;;;;;;CAQjE,IAAM,iBAAN,MAAM,eAAe;EACjB;EACA,YAAY,SAAS,CAAC,EAAE,EAAE;AACtB,QAAK,UAAU;;;;;;EAMnB,IAAI,SAAS;AACT,UAAO,KAAK,QAAQ;;;;;EAKxB,QAAQ,KAAK;AACT,UAAO,KAAK,QAAQ;;;;;;EAMxB,OAAO,SAAS,kBAAkB,kBAAkB;GAChD,MAAM,MAAM,IAAI,MAAM,QAAQ,CAAC,KAAK,EAAE;AACtC,OAAI,OAAO,kBAAkB,KAAK,QAAQ,SAAS,kBAAkB,GAAG,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC7G,OAAI,OAAO,GAAG,kBAAkB,GAAG,KAAK,QAAQ,MAAM,GAAG,iBAAiB,CAAC;AAC3E,QAAK,UAAU;;;;;EAKnB,QAAQ,MAAM,OAAO;GACjB,MAAM,MAAM,KAAK,OAAO,OAAO,SAAS,EAAE,GAAG;AAC7C,QAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;IAC1B,MAAM,MAAM,KAAK,QAAQ,OAAO;AAChC,SAAK,QAAQ,OAAO,KAAK,KAAK,QAAQ,QAAQ,IAAI;AAClD,SAAK,QAAQ,QAAQ,IAAI,KAAK;;;;;;;EAOtC,YAAY,KAAK;GACb,MAAM,MAAM,KAAK,QAAQ;AACzB,QAAK,QAAQ,OAAO;AACpB,UAAO;;;;;EAKX,UAAU,aAAa,WAAW;AAC9B,QAAK,QAAQ,gBAAgB;;;;;EAKjC,UAAU,aAAa,WAAW;AAC9B,OAAI,KAAK,QAAQ,gBAAgB,UAC7B,MAAK,QAAQ,gBAAgB;OAK7B,MAAK,QAAQ,eAAe;;;;;EAMpC,QAAQ;AACJ,UAAO,IAAI,eAAe,CAAC,GAAG,KAAK,QAAQ,CAAC"}

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.cjs

@@ -0,0 +1,74 @@
+"use strict";
+const require_runtime = require("../../../../../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_ieee754$1 = require("./ieee754.cjs");
+const require_util$1 = require("../util.cjs");
+const require_types$1 = require("./types.cjs");
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.js
+var require_ExponentMapping = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ExponentMapping = void 0;
+	const ieee754 = require_ieee754$1.default;
+	const util = require_util$1.default;
+	const types_1 = require_types$1.default;
+	/**
+	* ExponentMapping implements exponential mapping functions for
+	* scales <=0. For scales > 0 LogarithmMapping should be used.
+	*/
+	var ExponentMapping = class {
+		_shift;
+		constructor(scale) {
+			this._shift = -scale;
+		}
+		/**
+		* Maps positive floating point values to indexes corresponding to scale
+		* @param value
+		* @returns {number} index for provided value at the current scale
+		*/
+		mapToIndex(value) {
+			if (value < ieee754.MIN_VALUE) return this._minNormalLowerBoundaryIndex();
+			return ieee754.getNormalBase2(value) + this._rightShift(ieee754.getSignificand(value) - 1, ieee754.SIGNIFICAND_WIDTH) >> this._shift;
+		}
+		/**
+		* Returns the lower bucket boundary for the given index for scale
+		*
+		* @param index
+		* @returns {number}
+		*/
+		lowerBoundary(index) {
+			const minIndex = this._minNormalLowerBoundaryIndex();
+			if (index < minIndex) throw new types_1.MappingError(`underflow: ${index} is < minimum lower boundary: ${minIndex}`);
+			const maxIndex = this._maxNormalLowerBoundaryIndex();
+			if (index > maxIndex) throw new types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+			return util.ldexp(1, index << this._shift);
+		}
+		/**
+		* The scale used by this mapping
+		* @returns {number}
+		*/
+		get scale() {
+			if (this._shift === 0) return 0;
+			return -this._shift;
+		}
+		_minNormalLowerBoundaryIndex() {
+			let index = ieee754.MIN_NORMAL_EXPONENT >> this._shift;
+			if (this._shift < 2) index--;
+			return index;
+		}
+		_maxNormalLowerBoundaryIndex() {
+			return ieee754.MAX_NORMAL_EXPONENT >> this._shift;
+		}
+		_rightShift(value, shift) {
+			return Math.floor(value * Math.pow(2, -shift));
+		}
+	};
+	exports.ExponentMapping = ExponentMapping;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_ExponentMapping();
+	}
+});
+
+//# sourceMappingURL=ExponentMapping.cjs.map

package/dist/node_modules/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExponentMapping.cjs","names":[],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/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/.pnpm/@opentelemetry_sdk-metrics@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.cjs

@@ -0,0 +1,83 @@
+"use strict";
+const require_runtime = require("../../../../../../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_ieee754$1 = require("./ieee754.cjs");
+const require_util$1 = require("../util.cjs");
+const require_types$1 = require("./types.cjs");
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.js
+var require_LogarithmMapping = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.LogarithmMapping = void 0;
+	const ieee754 = require_ieee754$1.default;
+	const util = require_util$1.default;
+	const types_1 = require_types$1.default;
+	/**
+	* LogarithmMapping implements exponential mapping functions for scale > 0.
+	* For scales <= 0 the exponent mapping should be used.
+	*/
+	var LogarithmMapping = class {
+		_scale;
+		_scaleFactor;
+		_inverseFactor;
+		constructor(scale) {
+			this._scale = scale;
+			this._scaleFactor = util.ldexp(Math.LOG2E, scale);
+			this._inverseFactor = util.ldexp(Math.LN2, -scale);
+		}
+		/**
+		* Maps positive floating point values to indexes corresponding to scale
+		* @param value
+		* @returns {number} index for provided value at the current scale
+		*/
+		mapToIndex(value) {
+			if (value <= ieee754.MIN_VALUE) return this._minNormalLowerBoundaryIndex() - 1;
+			if (ieee754.getSignificand(value) === 0) return (ieee754.getNormalBase2(value) << this._scale) - 1;
+			const index = Math.floor(Math.log(value) * this._scaleFactor);
+			const maxIndex = this._maxNormalLowerBoundaryIndex();
+			if (index >= maxIndex) return maxIndex;
+			return index;
+		}
+		/**
+		* Returns the lower bucket boundary for the given index for scale
+		*
+		* @param index
+		* @returns {number}
+		*/
+		lowerBoundary(index) {
+			const maxIndex = this._maxNormalLowerBoundaryIndex();
+			if (index >= maxIndex) {
+				if (index === maxIndex) return 2 * Math.exp((index - (1 << this._scale)) / this._scaleFactor);
+				throw new types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+			}
+			const minIndex = this._minNormalLowerBoundaryIndex();
+			if (index <= minIndex) {
+				if (index === minIndex) return ieee754.MIN_VALUE;
+				else if (index === minIndex - 1) return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2;
+				throw new types_1.MappingError(`overflow: ${index} is < minimum lower boundary: ${minIndex}`);
+			}
+			return Math.exp(index * this._inverseFactor);
+		}
+		/**
+		* The scale used by this mapping
+		* @returns {number}
+		*/
+		get scale() {
+			return this._scale;
+		}
+		_minNormalLowerBoundaryIndex() {
+			return ieee754.MIN_NORMAL_EXPONENT << this._scale;
+		}
+		_maxNormalLowerBoundaryIndex() {
+			return (ieee754.MAX_NORMAL_EXPONENT + 1 << this._scale) - 1;
+		}
+	};
+	exports.LogarithmMapping = LogarithmMapping;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_LogarithmMapping();
+	}
+});
+
+//# sourceMappingURL=LogarithmMapping.cjs.map