@safaricom-mxl/web-sdk 0.0.21 → 0.0.22

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

@@ -1 +0,0 @@
-{"version":3,"file":"Instruments.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/Instruments.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.isObservableInstrument = exports.ObservableUpDownCounterInstrument = exports.ObservableGaugeInstrument = exports.ObservableCounterInstrument = exports.ObservableInstrument = exports.HistogramInstrument = exports.GaugeInstrument = exports.CounterInstrument = exports.UpDownCounterInstrument = exports.SyncInstrument = void 0;\nconst api_1 = require(\"@opentelemetry/api\");\nconst core_1 = require(\"@opentelemetry/core\");\nclass SyncInstrument {\n    _writableMetricStorage;\n    _descriptor;\n    constructor(writableMetricStorage, descriptor) {\n        this._writableMetricStorage = writableMetricStorage;\n        this._descriptor = descriptor;\n    }\n    _record(value, attributes = {}, context = api_1.context.active()) {\n        if (typeof value !== 'number') {\n            api_1.diag.warn(`non-number value provided to metric ${this._descriptor.name}: ${value}`);\n            return;\n        }\n        if (this._descriptor.valueType === api_1.ValueType.INT &&\n            !Number.isInteger(value)) {\n            api_1.diag.warn(`INT value type cannot accept a floating-point value for ${this._descriptor.name}, ignoring the fractional digits.`);\n            value = Math.trunc(value);\n            // ignore non-finite values.\n            if (!Number.isInteger(value)) {\n                return;\n            }\n        }\n        this._writableMetricStorage.record(value, attributes, context, (0, core_1.millisToHrTime)(Date.now()));\n    }\n}\nexports.SyncInstrument = SyncInstrument;\n/**\n * The class implements {@link UpDownCounter} interface.\n */\nclass UpDownCounterInstrument extends SyncInstrument {\n    /**\n     * Increment value of counter by the input. Inputs may be negative.\n     */\n    add(value, attributes, ctx) {\n        this._record(value, attributes, ctx);\n    }\n}\nexports.UpDownCounterInstrument = UpDownCounterInstrument;\n/**\n * The class implements {@link Counter} interface.\n */\nclass CounterInstrument extends SyncInstrument {\n    /**\n     * Increment value of counter by the input. Inputs may not be negative.\n     */\n    add(value, attributes, ctx) {\n        if (value < 0) {\n            api_1.diag.warn(`negative value provided to counter ${this._descriptor.name}: ${value}`);\n            return;\n        }\n        this._record(value, attributes, ctx);\n    }\n}\nexports.CounterInstrument = CounterInstrument;\n/**\n * The class implements {@link Gauge} interface.\n */\nclass GaugeInstrument extends SyncInstrument {\n    /**\n     * Records a measurement.\n     */\n    record(value, attributes, ctx) {\n        this._record(value, attributes, ctx);\n    }\n}\nexports.GaugeInstrument = GaugeInstrument;\n/**\n * The class implements {@link Histogram} interface.\n */\nclass HistogramInstrument extends SyncInstrument {\n    /**\n     * Records a measurement. Value of the measurement must not be negative.\n     */\n    record(value, attributes, ctx) {\n        if (value < 0) {\n            api_1.diag.warn(`negative value provided to histogram ${this._descriptor.name}: ${value}`);\n            return;\n        }\n        this._record(value, attributes, ctx);\n    }\n}\nexports.HistogramInstrument = HistogramInstrument;\nclass ObservableInstrument {\n    /** @internal */\n    _metricStorages;\n    /** @internal */\n    _descriptor;\n    _observableRegistry;\n    constructor(descriptor, metricStorages, observableRegistry) {\n        this._descriptor = descriptor;\n        this._metricStorages = metricStorages;\n        this._observableRegistry = observableRegistry;\n    }\n    /**\n     * @see {Observable.addCallback}\n     */\n    addCallback(callback) {\n        this._observableRegistry.addCallback(callback, this);\n    }\n    /**\n     * @see {Observable.removeCallback}\n     */\n    removeCallback(callback) {\n        this._observableRegistry.removeCallback(callback, this);\n    }\n}\nexports.ObservableInstrument = ObservableInstrument;\nclass ObservableCounterInstrument extends ObservableInstrument {\n}\nexports.ObservableCounterInstrument = ObservableCounterInstrument;\nclass ObservableGaugeInstrument extends ObservableInstrument {\n}\nexports.ObservableGaugeInstrument = ObservableGaugeInstrument;\nclass ObservableUpDownCounterInstrument extends ObservableInstrument {\n}\nexports.ObservableUpDownCounterInstrument = ObservableUpDownCounterInstrument;\nfunction isObservableInstrument(it) {\n    return it instanceof ObservableInstrument;\n}\nexports.isObservableInstrument = isObservableInstrument;\n//# sourceMappingURL=Instruments.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,yBAAyB,QAAQ,oCAAoC,QAAQ,4BAA4B,QAAQ,8BAA8B,QAAQ,uBAAuB,QAAQ,sBAAsB,QAAQ,kBAAkB,QAAQ,oBAAoB,QAAQ,0BAA0B,QAAQ,iBAAiB,KAAK;CAC1U,MAAM,QAAQ,QAAQ,qBAAqB;CAC3C,MAAM,SAAS,QAAQ,sBAAsB;CAC7C,IAAM,iBAAN,MAAqB;EACjB;EACA;EACA,YAAY,uBAAuB,YAAY;AAC3C,QAAK,yBAAyB;AAC9B,QAAK,cAAc;;EAEvB,QAAQ,OAAO,aAAa,EAAE,EAAE,UAAU,MAAM,QAAQ,QAAQ,EAAE;AAC9D,OAAI,OAAO,UAAU,UAAU;AAC3B,UAAM,KAAK,KAAK,uCAAuC,KAAK,YAAY,KAAK,IAAI,QAAQ;AACzF;;AAEJ,OAAI,KAAK,YAAY,cAAc,MAAM,UAAU,OAC/C,CAAC,OAAO,UAAU,MAAM,EAAE;AAC1B,UAAM,KAAK,KAAK,2DAA2D,KAAK,YAAY,KAAK,mCAAmC;AACpI,YAAQ,KAAK,MAAM,MAAM;AAEzB,QAAI,CAAC,OAAO,UAAU,MAAM,CACxB;;AAGR,QAAK,uBAAuB,OAAO,OAAO,YAAY,UAAU,GAAG,OAAO,gBAAgB,KAAK,KAAK,CAAC,CAAC;;;AAG9G,SAAQ,iBAAiB;;;;CAIzB,IAAM,0BAAN,cAAsC,eAAe;;;;EAIjD,IAAI,OAAO,YAAY,KAAK;AACxB,QAAK,QAAQ,OAAO,YAAY,IAAI;;;AAG5C,SAAQ,0BAA0B;;;;CAIlC,IAAM,oBAAN,cAAgC,eAAe;;;;EAI3C,IAAI,OAAO,YAAY,KAAK;AACxB,OAAI,QAAQ,GAAG;AACX,UAAM,KAAK,KAAK,sCAAsC,KAAK,YAAY,KAAK,IAAI,QAAQ;AACxF;;AAEJ,QAAK,QAAQ,OAAO,YAAY,IAAI;;;AAG5C,SAAQ,oBAAoB;;;;CAI5B,IAAM,kBAAN,cAA8B,eAAe;;;;EAIzC,OAAO,OAAO,YAAY,KAAK;AAC3B,QAAK,QAAQ,OAAO,YAAY,IAAI;;;AAG5C,SAAQ,kBAAkB;;;;CAI1B,IAAM,sBAAN,cAAkC,eAAe;;;;EAI7C,OAAO,OAAO,YAAY,KAAK;AAC3B,OAAI,QAAQ,GAAG;AACX,UAAM,KAAK,KAAK,wCAAwC,KAAK,YAAY,KAAK,IAAI,QAAQ;AAC1F;;AAEJ,QAAK,QAAQ,OAAO,YAAY,IAAI;;;AAG5C,SAAQ,sBAAsB;CAC9B,IAAM,uBAAN,MAA2B;;EAEvB;;EAEA;EACA;EACA,YAAY,YAAY,gBAAgB,oBAAoB;AACxD,QAAK,cAAc;AACnB,QAAK,kBAAkB;AACvB,QAAK,sBAAsB;;;;;EAK/B,YAAY,UAAU;AAClB,QAAK,oBAAoB,YAAY,UAAU,KAAK;;;;;EAKxD,eAAe,UAAU;AACrB,QAAK,oBAAoB,eAAe,UAAU,KAAK;;;AAG/D,SAAQ,uBAAuB;CAC/B,IAAM,8BAAN,cAA0C,qBAAqB;AAE/D,SAAQ,8BAA8B;CACtC,IAAM,4BAAN,cAAwC,qBAAqB;AAE7D,SAAQ,4BAA4B;CACpC,IAAM,oCAAN,cAAgD,qBAAqB;AAErE,SAAQ,oCAAoC;CAC5C,SAAS,uBAAuB,IAAI;AAChC,SAAO,cAAc;;AAEzB,SAAQ,yBAAyB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"MeterProvider.cjs","names":[],"sources":["../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/MeterProvider.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.MeterProvider = void 0;\nconst api_1 = require(\"@opentelemetry/api\");\nconst resources_1 = require(\"@opentelemetry/resources\");\nconst MeterProviderSharedState_1 = require(\"./state/MeterProviderSharedState\");\nconst MetricCollector_1 = require(\"./state/MetricCollector\");\nconst View_1 = require(\"./view/View\");\n/**\n * This class implements the {@link MeterProvider} interface.\n */\nclass MeterProvider {\n    _sharedState;\n    _shutdown = false;\n    constructor(options) {\n        this._sharedState = new MeterProviderSharedState_1.MeterProviderSharedState(options?.resource ?? (0, resources_1.defaultResource)());\n        if (options?.views != null && options.views.length > 0) {\n            for (const viewOption of options.views) {\n                this._sharedState.viewRegistry.addView(new View_1.View(viewOption));\n            }\n        }\n        if (options?.readers != null && options.readers.length > 0) {\n            for (const metricReader of options.readers) {\n                const collector = new MetricCollector_1.MetricCollector(this._sharedState, metricReader);\n                metricReader.setMetricProducer(collector);\n                this._sharedState.metricCollectors.push(collector);\n            }\n        }\n    }\n    /**\n     * Get a meter with the configuration of the MeterProvider.\n     */\n    getMeter(name, version = '', options = {}) {\n        // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#meter-creation\n        if (this._shutdown) {\n            api_1.diag.warn('A shutdown MeterProvider cannot provide a Meter');\n            return (0, api_1.createNoopMeter)();\n        }\n        return this._sharedState.getMeterSharedState({\n            name,\n            version,\n            schemaUrl: options.schemaUrl,\n        }).meter;\n    }\n    /**\n     * Shut down the MeterProvider and all registered\n     * MetricReaders.\n     *\n     * Returns a promise which is resolved when all flushes are complete.\n     */\n    async shutdown(options) {\n        if (this._shutdown) {\n            api_1.diag.warn('shutdown may only be called once per MeterProvider');\n            return;\n        }\n        this._shutdown = true;\n        await Promise.all(this._sharedState.metricCollectors.map(collector => {\n            return collector.shutdown(options);\n        }));\n    }\n    /**\n     * Notifies all registered MetricReaders to flush any buffered data.\n     *\n     * Returns a promise which is resolved when all flushes are complete.\n     */\n    async forceFlush(options) {\n        // do not flush after shutdown\n        if (this._shutdown) {\n            api_1.diag.warn('invalid attempt to force flush after MeterProvider shutdown');\n            return;\n        }\n        await Promise.all(this._sharedState.metricCollectors.map(collector => {\n            return collector.forceFlush(options);\n        }));\n    }\n}\nexports.MeterProvider = MeterProvider;\n//# sourceMappingURL=MeterProvider.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gBAAgB,KAAK;CAC7B,MAAM,QAAQ,QAAQ,qBAAqB;CAC3C,MAAM,cAAc,QAAQ,2BAA2B;CACvD,MAAM,6BAAA,mCAAA;CACN,MAAM,oBAAA,0BAAA;CACN,MAAM,SAAA,eAAA;;;;CAIN,IAAM,gBAAN,MAAoB;EAChB;EACA,YAAY;EACZ,YAAY,SAAS;AACjB,QAAK,eAAe,IAAI,2BAA2B,yBAAyB,SAAS,aAAa,GAAG,YAAY,kBAAkB,CAAC;AACpI,OAAI,SAAS,SAAS,QAAQ,QAAQ,MAAM,SAAS,EACjD,MAAK,MAAM,cAAc,QAAQ,MAC7B,MAAK,aAAa,aAAa,QAAQ,IAAI,OAAO,KAAK,WAAW,CAAC;AAG3E,OAAI,SAAS,WAAW,QAAQ,QAAQ,QAAQ,SAAS,EACrD,MAAK,MAAM,gBAAgB,QAAQ,SAAS;IACxC,MAAM,YAAY,IAAI,kBAAkB,gBAAgB,KAAK,cAAc,aAAa;AACxF,iBAAa,kBAAkB,UAAU;AACzC,SAAK,aAAa,iBAAiB,KAAK,UAAU;;;;;;EAO9D,SAAS,MAAM,UAAU,IAAI,UAAU,EAAE,EAAE;AAEvC,OAAI,KAAK,WAAW;AAChB,UAAM,KAAK,KAAK,kDAAkD;AAClE,YAAQ,GAAG,MAAM,kBAAkB;;AAEvC,UAAO,KAAK,aAAa,oBAAoB;IACzC;IACA;IACA,WAAW,QAAQ;IACtB,CAAC,CAAC;;;;;;;;EAQP,MAAM,SAAS,SAAS;AACpB,OAAI,KAAK,WAAW;AAChB,UAAM,KAAK,KAAK,qDAAqD;AACrE;;AAEJ,QAAK,YAAY;AACjB,SAAM,QAAQ,IAAI,KAAK,aAAa,iBAAiB,KAAI,cAAa;AAClE,WAAO,UAAU,SAAS,QAAQ;KACpC,CAAC;;;;;;;EAOP,MAAM,WAAW,SAAS;AAEtB,OAAI,KAAK,WAAW;AAChB,UAAM,KAAK,KAAK,8DAA8D;AAC9E;;AAEJ,SAAM,QAAQ,IAAI,KAAK,aAAa,iBAAiB,KAAI,cAAa;AAClE,WAAO,UAAU,WAAW,QAAQ;KACtC,CAAC;;;AAGX,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/export/MetricReader.cjs.map

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"PeriodicExportingMetricReader.cjs","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/@opentelemetry+sdk-metrics@2.7.1_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PeriodicExportingMetricReader = void 0;\nconst api = require(\"@opentelemetry/api\");\nconst core_1 = require(\"@opentelemetry/core\");\nconst MetricReader_1 = require(\"./MetricReader\");\nconst utils_1 = require(\"../utils\");\nconst MetricData_1 = require(\"./MetricData\");\n/**\n * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to\n * the configured {@link PushMetricExporter}\n */\nclass PeriodicExportingMetricReader extends MetricReader_1.MetricReader {\n    _interval;\n    _exporter;\n    _exportInterval;\n    _exportTimeout;\n    constructor(options) {\n        const { exporter, exportIntervalMillis = 60000, metricProducers, cardinalityLimits, } = options;\n        let { exportTimeoutMillis = 30000 } = options;\n        super({\n            aggregationSelector: exporter.selectAggregation?.bind(exporter),\n            aggregationTemporalitySelector: exporter.selectAggregationTemporality?.bind(exporter),\n            metricProducers,\n            cardinalitySelector: (instrumentType) => {\n                const limits = {\n                    default: 2000,\n                    ...cardinalityLimits,\n                };\n                switch (instrumentType) {\n                    case MetricData_1.InstrumentType.COUNTER:\n                        return limits.counter ?? limits.default;\n                    case MetricData_1.InstrumentType.GAUGE:\n                        return limits.gauge ?? limits.default;\n                    case MetricData_1.InstrumentType.HISTOGRAM:\n                        return limits.histogram ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_COUNTER:\n                        return limits.observableCounter ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:\n                        return limits.observableUpDownCounter ?? limits.default;\n                    case MetricData_1.InstrumentType.OBSERVABLE_GAUGE:\n                        return limits.observableGauge ?? limits.default;\n                    case MetricData_1.InstrumentType.UP_DOWN_COUNTER:\n                        return limits.upDownCounter ?? limits.default;\n                    default:\n                        return limits.default;\n                }\n            },\n        });\n        if (exportIntervalMillis <= 0) {\n            throw Error('exportIntervalMillis must be greater than 0');\n        }\n        if (exportTimeoutMillis <= 0) {\n            throw Error('exportTimeoutMillis must be greater than 0');\n        }\n        if (exportIntervalMillis < exportTimeoutMillis) {\n            if ('exportIntervalMillis' in options &&\n                'exportTimeoutMillis' in options) {\n                // An invalid combination of values was explicitly provided.\n                throw Error('exportIntervalMillis must be greater than or equal to exportTimeoutMillis');\n            }\n            else {\n                // An invalid combination of value was implicitly provided.\n                api.diag.info(`Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`);\n                exportTimeoutMillis = exportIntervalMillis;\n            }\n        }\n        this._exportInterval = exportIntervalMillis;\n        this._exportTimeout = exportTimeoutMillis;\n        this._exporter = exporter;\n    }\n    async _runOnce() {\n        try {\n            await (0, utils_1.callWithTimeout)(this._doRun(), this._exportTimeout);\n        }\n        catch (err) {\n            if (err instanceof utils_1.TimeoutError) {\n                api.diag.error('Export took longer than %s milliseconds and timed out.', this._exportTimeout);\n                return;\n            }\n            (0, core_1.globalErrorHandler)(err);\n        }\n    }\n    async _doRun() {\n        const { resourceMetrics, errors } = await this.collect({\n            timeoutMillis: this._exportTimeout,\n        });\n        if (errors.length > 0) {\n            api.diag.error('PeriodicExportingMetricReader: metrics collection errors', ...errors);\n        }\n        if (resourceMetrics.resource.asyncAttributesPending) {\n            try {\n                await resourceMetrics.resource.waitForAsyncAttributes?.();\n            }\n            catch (e) {\n                api.diag.debug('Error while resolving async portion of resource: ', e);\n                (0, core_1.globalErrorHandler)(e);\n            }\n        }\n        if (resourceMetrics.scopeMetrics.length === 0) {\n            return;\n        }\n        const result = await core_1.internal._export(this._exporter, resourceMetrics);\n        if (result.code !== core_1.ExportResultCode.SUCCESS) {\n            throw new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`);\n        }\n    }\n    onInitialized() {\n        // start running the interval as soon as this reader is initialized and keep handle for shutdown.\n        this._interval = setInterval(() => {\n            // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.\n            void this._runOnce();\n        }, this._exportInterval);\n        // depending on runtime, this may be a 'number' or NodeJS.Timeout\n        if (typeof this._interval !== 'number') {\n            this._interval.unref();\n        }\n    }\n    async onForceFlush() {\n        await this._runOnce();\n        await this._exporter.forceFlush();\n    }\n    async onShutdown() {\n        if (this._interval) {\n            clearInterval(this._interval);\n        }\n        await this.onForceFlush();\n        await this._exporter.shutdown();\n    }\n}\nexports.PeriodicExportingMetricReader = PeriodicExportingMetricReader;\n//# sourceMappingURL=PeriodicExportingMetricReader.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAKA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,gCAAgC,KAAK;CAC7C,MAAM,MAAM,QAAQ,qBAAqB;CACzC,MAAM,SAAS,QAAQ,sBAAsB;CAC7C,MAAM,iBAAA,uBAAA;CACN,MAAM,UAAA,gBAAA;CACN,MAAM,eAAA,qBAAA;;;;;CAKN,IAAM,gCAAN,cAA4C,eAAe,aAAa;EACpE;EACA;EACA;EACA;EACA,YAAY,SAAS;GACjB,MAAM,EAAE,UAAU,uBAAuB,KAAO,iBAAiB,sBAAuB;GACxF,IAAI,EAAE,sBAAsB,QAAU;AACtC,SAAM;IACF,qBAAqB,SAAS,mBAAmB,KAAK,SAAS;IAC/D,gCAAgC,SAAS,8BAA8B,KAAK,SAAS;IACrF;IACA,sBAAsB,mBAAmB;KACrC,MAAM,SAAS;MACX,SAAS;MACT,GAAG;MACN;AACD,aAAQ,gBAAR;MACI,KAAK,aAAa,eAAe,QAC7B,QAAO,OAAO,WAAW,OAAO;MACpC,KAAK,aAAa,eAAe,MAC7B,QAAO,OAAO,SAAS,OAAO;MAClC,KAAK,aAAa,eAAe,UAC7B,QAAO,OAAO,aAAa,OAAO;MACtC,KAAK,aAAa,eAAe,mBAC7B,QAAO,OAAO,qBAAqB,OAAO;MAC9C,KAAK,aAAa,eAAe,2BAC7B,QAAO,OAAO,2BAA2B,OAAO;MACpD,KAAK,aAAa,eAAe,iBAC7B,QAAO,OAAO,mBAAmB,OAAO;MAC5C,KAAK,aAAa,eAAe,gBAC7B,QAAO,OAAO,iBAAiB,OAAO;MAC1C,QACI,QAAO,OAAO;;;IAG7B,CAAC;AACF,OAAI,wBAAwB,EACxB,OAAM,MAAM,8CAA8C;AAE9D,OAAI,uBAAuB,EACvB,OAAM,MAAM,6CAA6C;AAE7D,OAAI,uBAAuB,oBACvB,KAAI,0BAA0B,WAC1B,yBAAyB,QAEzB,OAAM,MAAM,4EAA4E;QAEvF;AAED,QAAI,KAAK,KAAK,cAAc,oBAAoB,2BAA2B,qBAAqB,0CAA0C;AAC1I,0BAAsB;;AAG9B,QAAK,kBAAkB;AACvB,QAAK,iBAAiB;AACtB,QAAK,YAAY;;EAErB,MAAM,WAAW;AACb,OAAI;AACA,WAAO,GAAG,QAAQ,iBAAiB,KAAK,QAAQ,EAAE,KAAK,eAAe;YAEnE,KAAK;AACR,QAAI,eAAe,QAAQ,cAAc;AACrC,SAAI,KAAK,MAAM,0DAA0D,KAAK,eAAe;AAC7F;;AAEJ,KAAC,GAAG,OAAO,oBAAoB,IAAI;;;EAG3C,MAAM,SAAS;GACX,MAAM,EAAE,iBAAiB,WAAW,MAAM,KAAK,QAAQ,EACnD,eAAe,KAAK,gBACvB,CAAC;AACF,OAAI,OAAO,SAAS,EAChB,KAAI,KAAK,MAAM,4DAA4D,GAAG,OAAO;AAEzF,OAAI,gBAAgB,SAAS,uBACzB,KAAI;AACA,UAAM,gBAAgB,SAAS,0BAA0B;YAEtD,GAAG;AACN,QAAI,KAAK,MAAM,qDAAqD,EAAE;AACtE,KAAC,GAAG,OAAO,oBAAoB,EAAE;;AAGzC,OAAI,gBAAgB,aAAa,WAAW,EACxC;GAEJ,MAAM,SAAS,MAAM,OAAO,SAAS,QAAQ,KAAK,WAAW,gBAAgB;AAC7E,OAAI,OAAO,SAAS,OAAO,iBAAiB,QACxC,OAAM,IAAI,MAAM,+DAA+D,OAAO,MAAM,GAAG;;EAGvG,gBAAgB;AAEZ,QAAK,YAAY,kBAAkB;AAE1B,SAAK,UAAU;MACrB,KAAK,gBAAgB;AAExB,OAAI,OAAO,KAAK,cAAc,SAC1B,MAAK,UAAU,OAAO;;EAG9B,MAAM,eAAe;AACjB,SAAM,KAAK,UAAU;AACrB,SAAM,KAAK,UAAU,YAAY;;EAErC,MAAM,aAAa;AACf,OAAI,KAAK,UACL,eAAc,KAAK,UAAU;AAEjC,SAAM,KAAK,cAAc;AACzB,SAAM,KAAK,UAAU,UAAU;;;AAGvC,SAAQ,gCAAgC"}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,2 +0,0 @@
-import { ContextManager, MeterProvider, TextMapPropagator } from "@opentelemetry/api";
-import { Resource } from "@opentelemetry/resources";

package/dist/node_modules/.pnpm/@opentelemetry_sdk-trace-base@2.7.1_@opentelemetry_api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/src/types.d.ts

@@ -1,2 +0,0 @@
-import { ContextManager, MeterProvider, TextMapPropagator } from "@opentelemetry/api";
-import { Resource } from "@opentelemetry/resources";