@safaricom-mxl/web-sdk 0.0.16 → 0.0.18

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

@@ -0,0 +1 @@
+{"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":";;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,qBAAqB,KAAK;CAClC,MAAM,QAAQ,QAAQ,qBAAqB;CAC3C,MAAM,gBAAA,sBAAA;CACN,MAAM,qBAAA,2BAAA;CACN,MAAM,UAAA,gBAAA;;;;;;;CAON,IAAM,qBAAN,MAAyB;EACrB,aAAa,EAAE;EACf,kBAAkB,EAAE;EACpB,YAAY,UAAU,YAAY;AAE9B,OADY,KAAK,cAAc,UAAU,WAClC,IAAI,EACP;AAEJ,QAAK,WAAW,KAAK;IAAE;IAAU;IAAY,CAAC;;EAElD,eAAe,UAAU,YAAY;GACjC,MAAM,MAAM,KAAK,cAAc,UAAU,WAAW;AACpD,OAAI,MAAM,EACN;AAEJ,QAAK,WAAW,OAAO,KAAK,EAAE;;EAElC,iBAAiB,UAAU,aAAa;GAEpC,MAAM,wBAAwB,IAAI,IAAI,YAAY,OAAO,cAAc,uBAAuB,CAAC;AAC/F,OAAI,sBAAsB,SAAS,GAAG;AAClC,UAAM,KAAK,MAAM,oEAAoE,YAAY;AACjG;;AAGJ,OADY,KAAK,mBAAmB,UAAU,sBACvC,IAAI,EACP;AAEJ,QAAK,gBAAgB,KAAK;IAAE;IAAU,aAAa;IAAuB,CAAC;;EAE/E,oBAAoB,UAAU,aAAa;GAEvC,MAAM,wBAAwB,IAAI,IAAI,YAAY,OAAO,cAAc,uBAAuB,CAAC;GAC/F,MAAM,MAAM,KAAK,mBAAmB,UAAU,sBAAsB;AACpE,OAAI,MAAM,EACN;AAEJ,QAAK,gBAAgB,OAAO,KAAK,EAAE;;;;;EAKvC,MAAM,QAAQ,gBAAgB,eAAe;GACzC,MAAM,kBAAkB,KAAK,kBAAkB,gBAAgB,cAAc;GAC7E,MAAM,uBAAuB,KAAK,uBAAuB,gBAAgB,cAAc;AAQvF,WAHmB,MAJG,QAAQ,WAAW,CACrC,GAAG,iBACH,GAAG,qBACN,CAAC,EAEG,QAAO,WAAU,OAAO,WAAW,WAAW,CAC9C,KAAI,WAAU,OAAO,OACT;;EAErB,kBAAkB,iBAAiB,eAAe;AAC9C,UAAO,KAAK,WAAW,IAAI,OAAO,EAAE,UAAU,iBAAiB;IAC3D,MAAM,mBAAmB,IAAI,mBAAmB,qBAAqB,WAAW,YAAY,MAAM,WAAW,YAAY,UAAU;IACnI,IAAI,cAAc,QAAQ,QAAQ,SAAS,iBAAiB,CAAC;AAC7D,QAAI,iBAAiB,KACjB,gBAAe,GAAG,QAAQ,iBAAiB,aAAa,cAAc;AAE1E,UAAM;AACN,eAAW,gBAAgB,SAAQ,kBAAiB;AAChD,mBAAc,OAAO,iBAAiB,SAAS,gBAAgB;MACjE;KACJ;;EAEN,uBAAuB,iBAAiB,eAAe;AACnD,UAAO,KAAK,gBAAgB,IAAI,OAAO,EAAE,UAAU,kBAAkB;IACjE,MAAM,mBAAmB,IAAI,mBAAmB,2BAA2B;IAC3E,IAAI,cAAc,QAAQ,QAAQ,SAAS,iBAAiB,CAAC;AAC7D,QAAI,iBAAiB,KACjB,gBAAe,GAAG,QAAQ,iBAAiB,aAAa,cAAc;AAE1E,UAAM;AACN,gBAAY,SAAQ,eAAc;KAC9B,MAAM,SAAS,iBAAiB,QAAQ,IAAI,WAAW;AACvD,SAAI,UAAU,KACV;AAEJ,gBAAW,gBAAgB,SAAQ,kBAAiB;AAChD,oBAAc,OAAO,QAAQ,gBAAgB;OAC/C;MACJ;KACJ;;EAEN,cAAc,UAAU,YAAY;AAChC,UAAO,KAAK,WAAW,WAAU,WAAU;AACvC,WAAO,OAAO,aAAa,YAAY,OAAO,eAAe;KAC/D;;EAEN,mBAAmB,UAAU,aAAa;AACtC,UAAO,KAAK,gBAAgB,WAAU,WAAU;AAC5C,WAAQ,OAAO,aAAa,aACvB,GAAG,QAAQ,WAAW,OAAO,aAAa,YAAY;KAC7D;;;AAGV,SAAQ,qBAAqB"}

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

@@ -0,0 +1,55 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricStorage$1 = require("./MetricStorage.cjs");
+const require_DeltaMetricProcessor$1 = require("./DeltaMetricProcessor.cjs");
+const require_TemporalMetricProcessor$1 = require("./TemporalMetricProcessor.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/state/SyncMetricStorage.js
+var require_SyncMetricStorage = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SyncMetricStorage = void 0;
+	const MetricStorage_1 = require_MetricStorage$1.default;
+	const DeltaMetricProcessor_1 = require_DeltaMetricProcessor$1.default;
+	const TemporalMetricProcessor_1 = require_TemporalMetricProcessor$1.default;
+	/**
+	* Internal interface.
+	*
+	* Stores and aggregates {@link MetricData} for synchronous instruments.
+	*/
+	var SyncMetricStorage = class extends MetricStorage_1.MetricStorage {
+		_aggregationCardinalityLimit;
+		_deltaMetricStorage;
+		_temporalMetricStorage;
+		_attributesProcessor;
+		constructor(instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {
+			super(instrumentDescriptor);
+			this._aggregationCardinalityLimit = aggregationCardinalityLimit;
+			this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);
+			this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles);
+			this._attributesProcessor = attributesProcessor;
+		}
+		record(value, attributes, context, recordTime) {
+			attributes = this._attributesProcessor.process(attributes, context);
+			this._deltaMetricStorage.record(value, attributes, context, recordTime);
+		}
+		/**
+		* Collects the metrics from this storage.
+		*
+		* Note: This is a stateful operation and may reset any interval-related
+		* state for the MetricCollector.
+		*/
+		collect(collector, collectionTime) {
+			const accumulations = this._deltaMetricStorage.collect();
+			return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+		}
+	};
+	exports.SyncMetricStorage = SyncMetricStorage;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_SyncMetricStorage();
+	}
+});
+
+//# sourceMappingURL=SyncMetricStorage.cjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,106 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_AggregationTemporality$1 = require("../export/AggregationTemporality.cjs");
+const require_HashMap$1 = require("./HashMap.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/state/TemporalMetricProcessor.js
+var require_TemporalMetricProcessor = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.TemporalMetricProcessor = void 0;
+	const AggregationTemporality_1 = require_AggregationTemporality$1.default;
+	const HashMap_1 = require_HashMap$1.default;
+	exports.TemporalMetricProcessor = class TemporalMetricProcessor {
+		_aggregator;
+		_unreportedAccumulations = /* @__PURE__ */ new Map();
+		_reportHistory = /* @__PURE__ */ new Map();
+		constructor(aggregator, collectorHandles) {
+			this._aggregator = aggregator;
+			collectorHandles.forEach((handle) => {
+				this._unreportedAccumulations.set(handle, []);
+			});
+		}
+		/**
+		* Builds the {@link MetricData} streams to report against a specific MetricCollector.
+		* @param collector The information of the MetricCollector.
+		* @param collectors The registered collectors.
+		* @param instrumentDescriptor The instrumentation descriptor that these metrics generated with.
+		* @param currentAccumulations The current accumulation of metric data from instruments.
+		* @param collectionTime The current collection timestamp.
+		* @returns The {@link MetricData} points or `null`.
+		*/
+		buildMetrics(collector, instrumentDescriptor, currentAccumulations, collectionTime) {
+			this._stashAccumulations(currentAccumulations);
+			const unreportedAccumulations = this._getMergedUnreportedAccumulations(collector);
+			let result = unreportedAccumulations;
+			let aggregationTemporality;
+			if (this._reportHistory.has(collector)) {
+				const last = this._reportHistory.get(collector);
+				const lastCollectionTime = last.collectionTime;
+				aggregationTemporality = last.aggregationTemporality;
+				if (aggregationTemporality === AggregationTemporality_1.AggregationTemporality.CUMULATIVE) result = TemporalMetricProcessor.merge(last.accumulations, unreportedAccumulations, this._aggregator);
+				else result = TemporalMetricProcessor.calibrateStartTime(last.accumulations, unreportedAccumulations, lastCollectionTime);
+			} else aggregationTemporality = collector.selectAggregationTemporality(instrumentDescriptor.type);
+			this._reportHistory.set(collector, {
+				accumulations: result,
+				collectionTime,
+				aggregationTemporality
+			});
+			const accumulationRecords = AttributesMapToAccumulationRecords(result);
+			if (accumulationRecords.length === 0) return;
+			return this._aggregator.toMetricData(instrumentDescriptor, aggregationTemporality, accumulationRecords, collectionTime);
+		}
+		_stashAccumulations(currentAccumulation) {
+			const registeredCollectors = this._unreportedAccumulations.keys();
+			for (const collector of registeredCollectors) {
+				let stash = this._unreportedAccumulations.get(collector);
+				if (stash === void 0) {
+					stash = [];
+					this._unreportedAccumulations.set(collector, stash);
+				}
+				stash.push(currentAccumulation);
+			}
+		}
+		_getMergedUnreportedAccumulations(collector) {
+			let result = new HashMap_1.AttributeHashMap();
+			const unreportedList = this._unreportedAccumulations.get(collector);
+			this._unreportedAccumulations.set(collector, []);
+			if (unreportedList === void 0) return result;
+			for (const it of unreportedList) result = TemporalMetricProcessor.merge(result, it, this._aggregator);
+			return result;
+		}
+		static merge(last, current, aggregator) {
+			const result = last;
+			const iterator = current.entries();
+			let next = iterator.next();
+			while (next.done !== true) {
+				const [key, record, hash] = next.value;
+				if (last.has(key, hash)) {
+					const lastAccumulation = last.get(key, hash);
+					const accumulation = aggregator.merge(lastAccumulation, record);
+					result.set(key, accumulation, hash);
+				} else result.set(key, record, hash);
+				next = iterator.next();
+			}
+			return result;
+		}
+		/**
+		* Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves
+		* the new stream to be the initial observation time unchanged.
+		*/
+		static calibrateStartTime(last, current, lastCollectionTime) {
+			for (const [key, hash] of last.keys()) current.get(key, hash)?.setStartTime(lastCollectionTime);
+			return current;
+		}
+	};
+	function AttributesMapToAccumulationRecords(map) {
+		return Array.from(map.entries());
+	}
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_TemporalMetricProcessor();
+	}
+});
+
+//# sourceMappingURL=TemporalMetricProcessor.cjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,100 @@
+"use strict";
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/utils.js
+var require_utils = /* @__PURE__ */ require("../../../../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.equalsCaseInsensitive = exports.binarySearchUB = exports.setEquals = exports.callWithTimeout = exports.TimeoutError = exports.instrumentationScopeId = exports.hashAttributes = void 0;
+	/**
+	* Converting the unordered attributes into unique identifier string.
+	* @param attributes user provided unordered Attributes.
+	*/
+	function hashAttributes(attributes) {
+		let keys = Object.keys(attributes);
+		if (keys.length === 0) return "";
+		keys = keys.sort();
+		return JSON.stringify(keys.map((key) => [key, attributes[key]]));
+	}
+	exports.hashAttributes = hashAttributes;
+	/**
+	* Converting the instrumentation scope object to a unique identifier string.
+	* @param instrumentationScope
+	*/
+	function instrumentationScopeId(instrumentationScope) {
+		return `${instrumentationScope.name}:${instrumentationScope.version ?? ""}:${instrumentationScope.schemaUrl ?? ""}`;
+	}
+	exports.instrumentationScopeId = instrumentationScopeId;
+	/**
+	* Error that is thrown on timeouts.
+	*/
+	var TimeoutError = class TimeoutError extends Error {
+		constructor(message) {
+			super(message);
+			Object.setPrototypeOf(this, TimeoutError.prototype);
+		}
+	};
+	exports.TimeoutError = TimeoutError;
+	/**
+	* Adds a timeout to a promise and rejects if the specified timeout has elapsed. Also rejects if the specified promise
+	* rejects, and resolves if the specified promise resolves.
+	*
+	* <p> NOTE: this operation will continue even after it throws a {@link TimeoutError}.
+	*
+	* @param promise promise to use with timeout.
+	* @param timeout the timeout in milliseconds until the returned promise is rejected.
+	*/
+	function callWithTimeout(promise, timeout) {
+		let timeoutHandle;
+		const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+			timeoutHandle = setTimeout(function timeoutHandler() {
+				reject(new TimeoutError("Operation timed out."));
+			}, timeout);
+		});
+		return Promise.race([promise, timeoutPromise]).then((result) => {
+			clearTimeout(timeoutHandle);
+			return result;
+		}, (reason) => {
+			clearTimeout(timeoutHandle);
+			throw reason;
+		});
+	}
+	exports.callWithTimeout = callWithTimeout;
+	function setEquals(lhs, rhs) {
+		if (lhs.size !== rhs.size) return false;
+		for (const item of lhs) if (!rhs.has(item)) return false;
+		return true;
+	}
+	exports.setEquals = setEquals;
+	/**
+	* Binary search the sorted array to the find upper bound for the value.
+	* @param arr
+	* @param value
+	* @returns
+	*/
+	function binarySearchUB(arr, value) {
+		let lo = 0;
+		let hi = arr.length - 1;
+		let ret = arr.length;
+		while (hi >= lo) {
+			const mid = lo + Math.trunc((hi - lo) / 2);
+			if (arr[mid] < value) lo = mid + 1;
+			else {
+				ret = mid;
+				hi = mid - 1;
+			}
+		}
+		return ret;
+	}
+	exports.binarySearchUB = binarySearchUB;
+	function equalsCaseInsensitive(lhs, rhs) {
+		return lhs.toLowerCase() === rhs.toLowerCase();
+	}
+	exports.equalsCaseInsensitive = equalsCaseInsensitive;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_utils();
+	}
+});
+
+//# sourceMappingURL=utils.cjs.map

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

@@ -0,0 +1 @@
+{"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/utils.d.cts

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

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/utils.d.ts

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

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

@@ -0,0 +1,151 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricData$1 = require("../export/MetricData.cjs");
+const require_index = require("../aggregator/index.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.js
+var require_Aggregation = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.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;
+	const api = require("@opentelemetry/api");
+	const aggregator_1 = require_index.default;
+	const MetricData_1 = require_MetricData$1.default;
+	/**
+	* The default drop aggregation.
+	*/
+	var DropAggregation = class DropAggregation {
+		static DEFAULT_INSTANCE = new aggregator_1.DropAggregator();
+		createAggregator(_instrument) {
+			return DropAggregation.DEFAULT_INSTANCE;
+		}
+	};
+	exports.DropAggregation = DropAggregation;
+	/**
+	* The default sum aggregation.
+	*/
+	var SumAggregation = class SumAggregation {
+		static MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(true);
+		static NON_MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(false);
+		createAggregator(instrument) {
+			switch (instrument.type) {
+				case MetricData_1.InstrumentType.COUNTER:
+				case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:
+				case MetricData_1.InstrumentType.HISTOGRAM: return SumAggregation.MONOTONIC_INSTANCE;
+				default: return SumAggregation.NON_MONOTONIC_INSTANCE;
+			}
+		}
+	};
+	exports.SumAggregation = SumAggregation;
+	/**
+	* The default last value aggregation.
+	*/
+	var LastValueAggregation = class LastValueAggregation {
+		static DEFAULT_INSTANCE = new aggregator_1.LastValueAggregator();
+		createAggregator(_instrument) {
+			return LastValueAggregation.DEFAULT_INSTANCE;
+		}
+	};
+	exports.LastValueAggregation = LastValueAggregation;
+	/**
+	* The default histogram aggregation.
+	
+	*/
+	var HistogramAggregation = class HistogramAggregation {
+		static DEFAULT_INSTANCE = new aggregator_1.HistogramAggregator([
+			0,
+			5,
+			10,
+			25,
+			50,
+			75,
+			100,
+			250,
+			500,
+			750,
+			1e3,
+			2500,
+			5e3,
+			7500,
+			1e4
+		], true);
+		createAggregator(_instrument) {
+			return HistogramAggregation.DEFAULT_INSTANCE;
+		}
+	};
+	exports.HistogramAggregation = HistogramAggregation;
+	/**
+	* The explicit bucket histogram aggregation.
+	*/
+	var ExplicitBucketHistogramAggregation = class {
+		_boundaries;
+		_recordMinMax;
+		/**
+		* @param boundaries the bucket boundaries of the histogram aggregation
+		* @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded.
+		*/
+		constructor(boundaries, recordMinMax = true) {
+			if (boundaries == null) throw new Error("ExplicitBucketHistogramAggregation should be created with explicit boundaries, if a single bucket histogram is required, please pass an empty array");
+			boundaries = boundaries.concat();
+			boundaries = boundaries.sort((a, b) => a - b);
+			const minusInfinityIndex = boundaries.lastIndexOf(-Infinity);
+			let infinityIndex = boundaries.indexOf(Infinity);
+			if (infinityIndex === -1) infinityIndex = void 0;
+			this._boundaries = boundaries.slice(minusInfinityIndex + 1, infinityIndex);
+			this._recordMinMax = recordMinMax;
+		}
+		createAggregator(_instrument) {
+			return new aggregator_1.HistogramAggregator(this._boundaries, this._recordMinMax);
+		}
+	};
+	exports.ExplicitBucketHistogramAggregation = ExplicitBucketHistogramAggregation;
+	var ExponentialHistogramAggregation = class {
+		_maxSize;
+		_recordMinMax;
+		constructor(maxSize = 160, recordMinMax = true) {
+			this._maxSize = maxSize;
+			this._recordMinMax = recordMinMax;
+		}
+		createAggregator(_instrument) {
+			return new aggregator_1.ExponentialHistogramAggregator(this._maxSize, this._recordMinMax);
+		}
+	};
+	exports.ExponentialHistogramAggregation = ExponentialHistogramAggregation;
+	/**
+	* The default aggregation.
+	*/
+	var DefaultAggregation = class {
+		_resolve(instrument) {
+			switch (instrument.type) {
+				case MetricData_1.InstrumentType.COUNTER:
+				case MetricData_1.InstrumentType.UP_DOWN_COUNTER:
+				case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:
+				case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER: return exports.SUM_AGGREGATION;
+				case MetricData_1.InstrumentType.GAUGE:
+				case MetricData_1.InstrumentType.OBSERVABLE_GAUGE: return exports.LAST_VALUE_AGGREGATION;
+				case MetricData_1.InstrumentType.HISTOGRAM:
+					if (instrument.advice.explicitBucketBoundaries) return new ExplicitBucketHistogramAggregation(instrument.advice.explicitBucketBoundaries);
+					return exports.HISTOGRAM_AGGREGATION;
+			}
+			api.diag.warn(`Unable to recognize instrument type: ${instrument.type}`);
+			return exports.DROP_AGGREGATION;
+		}
+		createAggregator(instrument) {
+			return this._resolve(instrument).createAggregator(instrument);
+		}
+	};
+	exports.DefaultAggregation = DefaultAggregation;
+	exports.DROP_AGGREGATION = new DropAggregation();
+	exports.SUM_AGGREGATION = new SumAggregation();
+	exports.LAST_VALUE_AGGREGATION = new LastValueAggregation();
+	exports.HISTOGRAM_AGGREGATION = new HistogramAggregation();
+	exports.EXPONENTIAL_HISTOGRAM_AGGREGATION = new ExponentialHistogramAggregation();
+	exports.DEFAULT_AGGREGATION = new DefaultAggregation();
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_Aggregation();
+	}
+});
+
+//# sourceMappingURL=Aggregation.cjs.map

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

@@ -0,0 +1 @@
+{"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/Aggregation.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.d.ts

@@ -0,0 +1 @@
+export { };

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

@@ -0,0 +1,46 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_Aggregation$1 = require("./Aggregation.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.js
+var require_AggregationOption = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.toAggregation = exports.AggregationType = void 0;
+	const Aggregation_1 = require_Aggregation$1.default;
+	var AggregationType;
+	(function(AggregationType) {
+		AggregationType[AggregationType["DEFAULT"] = 0] = "DEFAULT";
+		AggregationType[AggregationType["DROP"] = 1] = "DROP";
+		AggregationType[AggregationType["SUM"] = 2] = "SUM";
+		AggregationType[AggregationType["LAST_VALUE"] = 3] = "LAST_VALUE";
+		AggregationType[AggregationType["EXPLICIT_BUCKET_HISTOGRAM"] = 4] = "EXPLICIT_BUCKET_HISTOGRAM";
+		AggregationType[AggregationType["EXPONENTIAL_HISTOGRAM"] = 5] = "EXPONENTIAL_HISTOGRAM";
+	})(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
+	function toAggregation(option) {
+		switch (option.type) {
+			case AggregationType.DEFAULT: return Aggregation_1.DEFAULT_AGGREGATION;
+			case AggregationType.DROP: return Aggregation_1.DROP_AGGREGATION;
+			case AggregationType.SUM: return Aggregation_1.SUM_AGGREGATION;
+			case AggregationType.LAST_VALUE: return Aggregation_1.LAST_VALUE_AGGREGATION;
+			case AggregationType.EXPONENTIAL_HISTOGRAM: {
+				const expOption = option;
+				return new Aggregation_1.ExponentialHistogramAggregation(expOption.options?.maxSize, expOption.options?.recordMinMax);
+			}
+			case AggregationType.EXPLICIT_BUCKET_HISTOGRAM: {
+				const expOption = option;
+				if (expOption.options == null) return Aggregation_1.HISTOGRAM_AGGREGATION;
+				else return new Aggregation_1.ExplicitBucketHistogramAggregation(expOption.options?.boundaries, expOption.options?.recordMinMax);
+			}
+			default: throw new Error("Unsupported Aggregation");
+		}
+	}
+	exports.toAggregation = toAggregation;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_AggregationOption();
+	}
+});
+
+//# sourceMappingURL=AggregationOption.cjs.map

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

@@ -0,0 +1 @@
+{"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/AggregationOption.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.d.ts

@@ -0,0 +1 @@
+export { };