@qqbrowser/qbot-dsh 0.0.6 → 0.0.8

package/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js

@@ -1,179 +1,102 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 /**
  * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses
  * constant NoopMetrics for all of its methods.
  */
-var NoopMeter = /** @class */ (function () {
-    function NoopMeter() {
-    }
+export class NoopMeter {
+    constructor() { }
     /**
      * @see {@link Meter.createGauge}
      */
-    NoopMeter.prototype.createGauge = function (_name, _options) {
+    createGauge(_name, _options) {
         return NOOP_GAUGE_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createHistogram}
      */
-    NoopMeter.prototype.createHistogram = function (_name, _options) {
+    createHistogram(_name, _options) {
         return NOOP_HISTOGRAM_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createCounter}
      */
-    NoopMeter.prototype.createCounter = function (_name, _options) {
+    createCounter(_name, _options) {
         return NOOP_COUNTER_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createUpDownCounter}
      */
-    NoopMeter.prototype.createUpDownCounter = function (_name, _options) {
+    createUpDownCounter(_name, _options) {
         return NOOP_UP_DOWN_COUNTER_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createObservableGauge}
      */
-    NoopMeter.prototype.createObservableGauge = function (_name, _options) {
+    createObservableGauge(_name, _options) {
         return NOOP_OBSERVABLE_GAUGE_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createObservableCounter}
      */
-    NoopMeter.prototype.createObservableCounter = function (_name, _options) {
+    createObservableCounter(_name, _options) {
         return NOOP_OBSERVABLE_COUNTER_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.createObservableUpDownCounter}
      */
-    NoopMeter.prototype.createObservableUpDownCounter = function (_name, _options) {
+    createObservableUpDownCounter(_name, _options) {
         return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
-    };
+    }
     /**
      * @see {@link Meter.addBatchObservableCallback}
      */
-    NoopMeter.prototype.addBatchObservableCallback = function (_callback, _observables) { };
+    addBatchObservableCallback(_callback, _observables) { }
     /**
      * @see {@link Meter.removeBatchObservableCallback}
      */
-    NoopMeter.prototype.removeBatchObservableCallback = function (_callback) { };
-    return NoopMeter;
-}());
-export { NoopMeter };
-var NoopMetric = /** @class */ (function () {
-    function NoopMetric() {
-    }
-    return NoopMetric;
-}());
-export { NoopMetric };
-var NoopCounterMetric = /** @class */ (function (_super) {
-    __extends(NoopCounterMetric, _super);
-    function NoopCounterMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopCounterMetric.prototype.add = function (_value, _attributes) { };
-    return NoopCounterMetric;
-}(NoopMetric));
-export { NoopCounterMetric };
-var NoopUpDownCounterMetric = /** @class */ (function (_super) {
-    __extends(NoopUpDownCounterMetric, _super);
-    function NoopUpDownCounterMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopUpDownCounterMetric.prototype.add = function (_value, _attributes) { };
-    return NoopUpDownCounterMetric;
-}(NoopMetric));
-export { NoopUpDownCounterMetric };
-var NoopGaugeMetric = /** @class */ (function (_super) {
-    __extends(NoopGaugeMetric, _super);
-    function NoopGaugeMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopGaugeMetric.prototype.record = function (_value, _attributes) { };
-    return NoopGaugeMetric;
-}(NoopMetric));
-export { NoopGaugeMetric };
-var NoopHistogramMetric = /** @class */ (function (_super) {
-    __extends(NoopHistogramMetric, _super);
-    function NoopHistogramMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopHistogramMetric.prototype.record = function (_value, _attributes) { };
-    return NoopHistogramMetric;
-}(NoopMetric));
-export { NoopHistogramMetric };
-var NoopObservableMetric = /** @class */ (function () {
-    function NoopObservableMetric() {
-    }
-    NoopObservableMetric.prototype.addCallback = function (_callback) { };
-    NoopObservableMetric.prototype.removeCallback = function (_callback) { };
-    return NoopObservableMetric;
-}());
-export { NoopObservableMetric };
-var NoopObservableCounterMetric = /** @class */ (function (_super) {
-    __extends(NoopObservableCounterMetric, _super);
-    function NoopObservableCounterMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableCounterMetric;
-}(NoopObservableMetric));
-export { NoopObservableCounterMetric };
-var NoopObservableGaugeMetric = /** @class */ (function (_super) {
-    __extends(NoopObservableGaugeMetric, _super);
-    function NoopObservableGaugeMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableGaugeMetric;
-}(NoopObservableMetric));
-export { NoopObservableGaugeMetric };
-var NoopObservableUpDownCounterMetric = /** @class */ (function (_super) {
-    __extends(NoopObservableUpDownCounterMetric, _super);
-    function NoopObservableUpDownCounterMetric() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableUpDownCounterMetric;
-}(NoopObservableMetric));
-export { NoopObservableUpDownCounterMetric };
-export var NOOP_METER = new NoopMeter();
+    removeBatchObservableCallback(_callback) { }
+}
+export class NoopMetric {
+}
+export class NoopCounterMetric extends NoopMetric {
+    add(_value, _attributes) { }
+}
+export class NoopUpDownCounterMetric extends NoopMetric {
+    add(_value, _attributes) { }
+}
+export class NoopGaugeMetric extends NoopMetric {
+    record(_value, _attributes) { }
+}
+export class NoopHistogramMetric extends NoopMetric {
+    record(_value, _attributes) { }
+}
+export class NoopObservableMetric {
+    addCallback(_callback) { }
+    removeCallback(_callback) { }
+}
+export class NoopObservableCounterMetric extends NoopObservableMetric {
+}
+export class NoopObservableGaugeMetric extends NoopObservableMetric {
+}
+export class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
+}
+export const NOOP_METER = new NoopMeter();
 // Synchronous instruments
-export var NOOP_COUNTER_METRIC = new NoopCounterMetric();
-export var NOOP_GAUGE_METRIC = new NoopGaugeMetric();
-export var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
-export var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+export const NOOP_COUNTER_METRIC = new NoopCounterMetric();
+export const NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+export const NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+export const NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
 // Asynchronous instruments
-export var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
-export var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
-export var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+export const NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+export const NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+export const NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
 /**
  * Create a no-op Meter
+ *
+ * @since 1.3.0
  */
 export function createNoopMeter() {
     return NOOP_METER;

package/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js

@@ -1,31 +1,16 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 import { NOOP_METER } from './NoopMeter';
 /**
  * An implementation of the {@link MeterProvider} which returns an impotent Meter
  * for all calls to `getMeter`
  */
-var NoopMeterProvider = /** @class */ (function () {
-    function NoopMeterProvider() {
-    }
-    NoopMeterProvider.prototype.getMeter = function (_name, _version, _options) {
+export class NoopMeterProvider {
+    getMeter(_name, _version, _options) {
         return NOOP_METER;
-    };
-    return NoopMeterProvider;
-}());
-export { NoopMeterProvider };
-export var NOOP_METER_PROVIDER = new NoopMeterProvider();
+    }
+}
+export const NOOP_METER_PROVIDER = new NoopMeterProvider();
 //# sourceMappingURL=NoopMeterProvider.js.map

package/node_modules/@opentelemetry/api/build/esm/metrics-api.js

@@ -1,21 +1,14 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 // Split module-level variable definition into separate files to allow
 // tree-shaking on each api instance.
 import { MetricsAPI } from './api/metrics';
-/** Entrypoint for metrics API */
-export var metrics = MetricsAPI.getInstance();
+/**
+ * Entrypoint for metrics API
+ *
+ * @since 1.3.0
+ */
+export const metrics = MetricsAPI.getInstance();
 //# sourceMappingURL=metrics-api.js.map

package/node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js

@@ -1,34 +1,19 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * No-op implementations of {@link TextMapPropagator}.
  */
-var NoopTextMapPropagator = /** @class */ (function () {
-    function NoopTextMapPropagator() {
-    }
+export class NoopTextMapPropagator {
     /** Noop inject function does nothing */
-    NoopTextMapPropagator.prototype.inject = function (_context, _carrier) { };
+    inject(_context, _carrier) { }
     /** Noop extract function does nothing and returns the input context */
-    NoopTextMapPropagator.prototype.extract = function (context, _carrier) {
+    extract(context, _carrier) {
         return context;
-    };
-    NoopTextMapPropagator.prototype.fields = function () {
+    }
+    fields() {
         return [];
-    };
-    return NoopTextMapPropagator;
-}());
-export { NoopTextMapPropagator };
+    }
+}
 //# sourceMappingURL=NoopTextMapPropagator.js.map

package/node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js

@@ -1,34 +1,29 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
-export var defaultTextMapGetter = {
-    get: function (carrier, key) {
+/**
+ * @since 1.0.0
+ */
+export const defaultTextMapGetter = {
+    get(carrier, key) {
         if (carrier == null) {
             return undefined;
         }
         return carrier[key];
     },
-    keys: function (carrier) {
+    keys(carrier) {
         if (carrier == null) {
             return [];
         }
         return Object.keys(carrier);
     },
 };
-export var defaultTextMapSetter = {
-    set: function (carrier, key, value) {
+/**
+ * @since 1.0.0
+ */
+export const defaultTextMapSetter = {
+    set(carrier, key, value) {
         if (carrier == null) {
             return;
         }

package/node_modules/@opentelemetry/api/build/esm/propagation-api.js

@@ -1,21 +1,14 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 // Split module-level variable definition into separate files to allow
 // tree-shaking on each api instance.
 import { PropagationAPI } from './api/propagation';
-/** Entrypoint for propagation API */
-export var propagation = PropagationAPI.getInstance();
+/**
+ * Entrypoint for propagation API
+ *
+ * @since 1.0.0
+ */
+export const propagation = PropagationAPI.getInstance();
 //# sourceMappingURL=propagation-api.js.map

package/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js

@@ -1,17 +1,6 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 import { INVALID_SPAN_CONTEXT } from './invalid-span-constants';
 /**
@@ -19,50 +8,47 @@ import { INVALID_SPAN_CONTEXT } from './invalid-span-constants';
  * implementation is available. All operations are no-op including context
  * propagation.
  */
-var NonRecordingSpan = /** @class */ (function () {
-    function NonRecordingSpan(_spanContext) {
-        if (_spanContext === void 0) { _spanContext = INVALID_SPAN_CONTEXT; }
-        this._spanContext = _spanContext;
+export class NonRecordingSpan {
+    constructor(spanContext = INVALID_SPAN_CONTEXT) {
+        this._spanContext = spanContext;
     }
     // Returns a SpanContext.
-    NonRecordingSpan.prototype.spanContext = function () {
+    spanContext() {
         return this._spanContext;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.setAttribute = function (_key, _value) {
+    setAttribute(_key, _value) {
         return this;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.setAttributes = function (_attributes) {
+    setAttributes(_attributes) {
         return this;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.addEvent = function (_name, _attributes) {
+    addEvent(_name, _attributes) {
         return this;
-    };
-    NonRecordingSpan.prototype.addLink = function (_link) {
+    }
+    addLink(_link) {
         return this;
-    };
-    NonRecordingSpan.prototype.addLinks = function (_links) {
+    }
+    addLinks(_links) {
         return this;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.setStatus = function (_status) {
+    setStatus(_status) {
         return this;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.updateName = function (_name) {
+    updateName(_name) {
         return this;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.end = function (_endTime) { };
+    end(_endTime) { }
     // isRecording always returns false for NonRecordingSpan.
-    NonRecordingSpan.prototype.isRecording = function () {
+    isRecording() {
         return false;
-    };
+    }
     // By default does nothing
-    NonRecordingSpan.prototype.recordException = function (_exception, _time) { };
-    return NonRecordingSpan;
-}());
-export { NonRecordingSpan };
+    recordException(_exception, _time) { }
+}
 //# sourceMappingURL=NonRecordingSpan.js.map

package/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js

@@ -1,37 +1,23 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 import { ContextAPI } from '../api/context';
 import { getSpanContext, setSpan } from '../trace/context-utils';
 import { NonRecordingSpan } from './NonRecordingSpan';
 import { isSpanContextValid } from './spancontext-utils';
-var contextApi = ContextAPI.getInstance();
+const contextApi = ContextAPI.getInstance();
 /**
  * No-op implementations of {@link Tracer}.
  */
-var NoopTracer = /** @class */ (function () {
-    function NoopTracer() {
-    }
+export class NoopTracer {
     // startSpan starts a noop span.
-    NoopTracer.prototype.startSpan = function (name, options, context) {
-        if (context === void 0) { context = contextApi.active(); }
-        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+    startSpan(name, options, context = contextApi.active()) {
+        const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
         if (root) {
             return new NonRecordingSpan();
         }
-        var parentFromContext = context && getSpanContext(context);
+        const parentFromContext = context && getSpanContext(context);
         if (isSpanContext(parentFromContext) &&
             isSpanContextValid(parentFromContext)) {
             return new NonRecordingSpan(parentFromContext);
@@ -39,11 +25,11 @@ var NoopTracer = /** @class */ (function () {
         else {
             return new NonRecordingSpan();
         }
-    };
-    NoopTracer.prototype.startActiveSpan = function (name, arg2, arg3, arg4) {
-        var opts;
-        var ctx;
-        var fn;
+    }
+    startActiveSpan(name, arg2, arg3, arg4) {
+        let opts;
+        let ctx;
+        let fn;
         if (arguments.length < 2) {
             return;
         }
@@ -59,18 +45,20 @@ var NoopTracer = /** @class */ (function () {
             ctx = arg3;
             fn = arg4;
         }
-        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-        var span = this.startSpan(name, opts, parentContext);
-        var contextWithSpanSet = setSpan(parentContext, span);
+        const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = setSpan(parentContext, span);
         return contextApi.with(contextWithSpanSet, fn, undefined, span);
-    };
-    return NoopTracer;
-}());
-export { NoopTracer };
+    }
+}
 function isSpanContext(spanContext) {
-    return (typeof spanContext === 'object' &&
+    return (spanContext !== null &&
+        typeof spanContext === 'object' &&
+        'spanId' in spanContext &&
         typeof spanContext['spanId'] === 'string' &&
+        'traceId' in spanContext &&
         typeof spanContext['traceId'] === 'string' &&
+        'traceFlags' in spanContext &&
         typeof spanContext['traceFlags'] === 'number');
 }
 //# sourceMappingURL=NoopTracer.js.map

package/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js

@@ -1,17 +1,6 @@
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 import { NoopTracer } from './NoopTracer';
 /**
@@ -20,13 +9,9 @@ import { NoopTracer } from './NoopTracer';
  *
  * All operations are no-op.
  */
-var NoopTracerProvider = /** @class */ (function () {
-    function NoopTracerProvider() {
-    }
-    NoopTracerProvider.prototype.getTracer = function (_name, _version, _options) {
+export class NoopTracerProvider {
+    getTracer(_name, _version, _options) {
         return new NoopTracer();
-    };
-    return NoopTracerProvider;
-}());
-export { NoopTracerProvider };
+    }
+}
 //# sourceMappingURL=NoopTracerProvider.js.map