ima2-gen 2.0.5 → 2.0.13

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.d.ts

@@ -0,0 +1,13 @@
+import { Span, SpanOptions } from '../../';
+/**
+ * Options needed for span creation
+ */
+export interface SugaredSpanOptions extends SpanOptions {
+    /**
+     * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function.
+     * @param e Error which triggered this exception
+     * @param span current span from context
+     */
+    onException?: (e: Error, span: Span) => void;
+}
+//# sourceMappingURL=SugaredOptions.d.ts.map

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=SugaredOptions.js.map

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredOptions.js","sourceRoot":"","sources":["../../../../src/experimental/trace/SugaredOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Span, SpanOptions } from '../../';\n\n/**\n * Options needed for span creation\n */\nexport interface SugaredSpanOptions extends SpanOptions {\n  /**\n   * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function.\n   * @param e Error which triggered this exception\n   * @param span current span from context\n   */\n  onException?: (e: Error, span: Span) => void;\n}\n"]}

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.d.ts

@@ -0,0 +1,64 @@
+import { SugaredSpanOptions } from './SugaredOptions';
+import { Context, Span, Tracer } from '../../';
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+export declare function wrapTracer(tracer: Tracer): SugaredTracer;
+export declare class SugaredTracer implements Tracer {
+    private readonly _tracer;
+    constructor(tracer: Tracer);
+    startActiveSpan: Tracer['startActiveSpan'];
+    startSpan: Tracer['startSpan'];
+    /**
+     * Starts a new {@link Span} and calls the given function passing it the
+     * created span as first argument.
+     * Additionally, the new span gets set in context and this context is activated
+     * for the duration of the function call.
+     * The span will be closed after the function has executed.
+     * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.
+     *
+     * @param name The name of the span
+     * @param [options] SugaredSpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @param fn function called in the context of the span and receives the newly created span as an argument
+     * @returns return value of fn
+     * @example
+     *     const something = tracer.withActiveSpan('op', span => {
+     *      // do some work
+     *     });
+     * @example
+     *     const something = await tracer.withActiveSpan('op', span => {
+     *      // do some async work
+     *     });
+     */
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+    withActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+    /**
+     * Starts a new {@link Span} and ends it after execution of fn without setting it on context.
+     * The span will be closed after the function has executed.
+     * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.
+     *
+     * This method does NOT modify the current Context.
+     *
+     * @param name The name of the span
+     * @param [options] SugaredSpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @param fn function called in the context of the span and receives the newly created span as an argument
+     * @returns Span The newly created span
+     * @example
+     *     const something = tracer.withSpan('op', span => {
+     *      // do some work
+     *     });
+     * @example
+     *     const something = await tracer.withSpan('op', span => {
+     *      // do some async work
+     *     });
+     */
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+    withSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType<F>;
+}
+//# sourceMappingURL=SugaredTracer.d.ts.map

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js

@@ -0,0 +1,92 @@
+import { context, SpanStatusCode } from '../../';
+var defaultOnException = function (e, span) {
+    span.recordException(e);
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+    });
+};
+/**
+ * return a new SugaredTracer created from the supplied one
+ * @param tracer
+ */
+export function wrapTracer(tracer) {
+    return new SugaredTracer(tracer);
+}
+var SugaredTracer = /** @class */ (function () {
+    function SugaredTracer(tracer) {
+        this._tracer = tracer;
+        this.startSpan = tracer.startSpan.bind(this._tracer);
+        this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+    }
+    SugaredTracer.prototype.withActiveSpan = function (name, arg2, arg3, arg4) {
+        var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+        return this._tracer.startActiveSpan(name, opts, ctx, function (span) {
+            return handleFn(span, opts, fn);
+        });
+    };
+    SugaredTracer.prototype.withSpan = function (name, arg2, arg3, arg4) {
+        var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+        var span = this._tracer.startSpan(name, opts, ctx);
+        return handleFn(span, opts, fn);
+    };
+    return SugaredTracer;
+}());
+export { SugaredTracer };
+/**
+ * Massages parameters of withSpan and withActiveSpan to allow signature overwrites
+ * @param arg
+ * @param arg2
+ * @param arg3
+ */
+function massageParams(arg, arg2, arg3) {
+    var opts;
+    var ctx;
+    var fn;
+    if (!arg2 && !arg3) {
+        fn = arg;
+    }
+    else if (!arg3) {
+        opts = arg;
+        fn = arg2;
+    }
+    else {
+        opts = arg;
+        ctx = arg2;
+        fn = arg3;
+    }
+    opts = opts !== null && opts !== void 0 ? opts : {};
+    ctx = ctx !== null && ctx !== void 0 ? ctx : context.active();
+    return { opts: opts, ctx: ctx, fn: fn };
+}
+/**
+ * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling
+ * @param span
+ * @param opts
+ * @param fn
+ */
+function handleFn(span, opts, fn) {
+    var _a;
+    var onException = (_a = opts.onException) !== null && _a !== void 0 ? _a : defaultOnException;
+    var errorHandler = function (e) {
+        onException(e, span);
+        span.end();
+        throw e;
+    };
+    try {
+        var ret = fn(span);
+        // if fn is an async function, attach a recordException and spanEnd callback to the promise
+        if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === 'function') {
+            return ret.then(function (val) {
+                span.end();
+                return val;
+            }, errorHandler);
+        }
+        span.end();
+        return ret;
+    }
+    catch (e) {
+        // add throw to signal the compiler that this will throw in the inner scope
+        throw errorHandler(e);
+    }
+}
+//# sourceMappingURL=SugaredTracer.js.map

package/node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugaredTracer.js","sourceRoot":"","sources":["../../../../src/experimental/trace/SugaredTracer.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SugaredSpanOptions } from './SugaredOptions';\nimport { context, Context, Span, SpanStatusCode, Tracer } from '../../';\n\nconst defaultOnException = (e: Error, span: Span) => {\n  span.recordException(e);\n  span.setStatus({\n    code: SpanStatusCode.ERROR,\n  });\n};\n\n/**\n * return a new SugaredTracer created from the supplied one\n * @param tracer\n */\nexport function wrapTracer(tracer: Tracer): SugaredTracer {\n  return new SugaredTracer(tracer);\n}\n\nexport class SugaredTracer implements Tracer {\n  private readonly _tracer: Tracer;\n\n  constructor(tracer: Tracer) {\n    this._tracer = tracer;\n    this.startSpan = tracer.startSpan.bind(this._tracer);\n    this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);\n  }\n\n  startActiveSpan: Tracer['startActiveSpan'];\n  startSpan: Tracer['startSpan'];\n\n  /**\n   * Starts a new {@link Span} and calls the given function passing it the\n   * created span as first argument.\n   * Additionally, the new span gets set in context and this context is activated\n   * for the duration of the function call.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns return value of fn\n   * @example\n   *     const something = tracer.withActiveSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withActiveSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withActiveSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: F | SugaredSpanOptions,\n    arg3?: F | Context,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    return this._tracer.startActiveSpan(name, opts, ctx, (span: Span) =>\n      handleFn(span, opts, fn)\n    ) as ReturnType<F>;\n  }\n\n  /**\n   * Starts a new {@link Span} and ends it after execution of fn without setting it on context.\n   * The span will be closed after the function has executed.\n   * If an exception occurs, it is recorded, the status is et to ERROR and rethrown.\n   *\n   * This method does NOT modify the current Context.\n   *\n   * @param name The name of the span\n   * @param [options] SugaredSpanOptions used for span creation\n   * @param [context] Context to use to extract parent\n   * @param fn function called in the context of the span and receives the newly created span as an argument\n   * @returns Span The newly created span\n   * @example\n   *     const something = tracer.withSpan('op', span => {\n   *      // do some work\n   *     });\n   * @example\n   *     const something = await tracer.withSpan('op', span => {\n   *      // do some async work\n   *     });\n   */\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    options: SugaredSpanOptions,\n    context: Context,\n    fn: F\n  ): ReturnType<F>;\n  withSpan<F extends (span: Span) => ReturnType<F>>(\n    name: string,\n    arg2: SugaredSpanOptions | F,\n    arg3?: Context | F,\n    arg4?: F\n  ): ReturnType<F> {\n    const { opts, ctx, fn } = massageParams(arg2, arg3, arg4);\n\n    const span = this._tracer.startSpan(name, opts, ctx);\n    return handleFn(span, opts, fn) as ReturnType<F>;\n  }\n}\n\n/**\n * Massages parameters of withSpan and withActiveSpan to allow signature overwrites\n * @param arg\n * @param arg2\n * @param arg3\n */\nfunction massageParams<F extends (span: Span) => ReturnType<F>>(\n  arg: F | SugaredSpanOptions,\n  arg2?: F | Context,\n  arg3?: F\n) {\n  let opts: SugaredSpanOptions | undefined;\n  let ctx: Context | undefined;\n  let fn: F;\n\n  if (!arg2 && !arg3) {\n    fn = arg as F;\n  } else if (!arg3) {\n    opts = arg as SugaredSpanOptions;\n    fn = arg2 as F;\n  } else {\n    opts = arg as SugaredSpanOptions;\n    ctx = arg2 as Context;\n    fn = arg3 as F;\n  }\n  opts = opts ?? {};\n  ctx = ctx ?? context.active();\n\n  return { opts, ctx, fn };\n}\n\n/**\n * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling\n * @param span\n * @param opts\n * @param fn\n */\nfunction handleFn<F extends (span: Span) => ReturnType<F>>(\n  span: Span,\n  opts: SugaredSpanOptions,\n  fn: F\n): ReturnType<F> {\n  const onException = opts.onException ?? defaultOnException;\n  const errorHandler = (e: Error) => {\n    onException(e, span);\n    span.end();\n    throw e;\n  };\n\n  try {\n    const ret = fn(span) as Promise<ReturnType<F>>;\n    // if fn is an async function, attach a recordException and spanEnd callback to the promise\n    if (typeof ret?.then === 'function') {\n      return ret.then(val => {\n        span.end();\n        return val;\n      }, errorHandler) as ReturnType<F>;\n    }\n    span.end();\n    return ret as ReturnType<F>;\n  } catch (e) {\n    // add throw to signal the compiler that this will throw in the inner scope\n    throw errorHandler(e);\n  }\n}\n"]}

package/node_modules/@opentelemetry/api/build/esm/index.d.ts

@@ -0,0 +1,54 @@
+export { BaggageEntry, BaggageEntryMetadata, Baggage } from './baggage/types';
+export { baggageEntryMetadataFromString } from './baggage/utils';
+export { Exception } from './common/Exception';
+export { HrTime, TimeInput } from './common/Time';
+export { Attributes, AttributeValue } from './common/Attributes';
+export { createContextKey, ROOT_CONTEXT } from './context/context';
+export { Context, ContextManager } from './context/types';
+export type { ContextAPI } from './api/context';
+export { DiagConsoleLogger } from './diag/consoleLogger';
+export { DiagLogFunction, DiagLogger, DiagLogLevel, ComponentLoggerOptions, DiagLoggerOptions, } from './diag/types';
+export type { DiagAPI } from './api/diag';
+export { createNoopMeter } from './metrics/NoopMeter';
+export { MeterOptions, Meter } from './metrics/Meter';
+export { MeterProvider } from './metrics/MeterProvider';
+export { ValueType, Counter, Gauge, Histogram, MetricOptions, Observable, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, BatchObservableCallback, MetricAdvice, MetricAttributes, MetricAttributeValue, ObservableCallback, } from './metrics/Metric';
+export { BatchObservableResult, ObservableResult, } from './metrics/ObservableResult';
+export type { MetricsAPI } from './api/metrics';
+export { TextMapPropagator, TextMapSetter, TextMapGetter, defaultTextMapGetter, defaultTextMapSetter, } from './propagation/TextMapPropagator';
+export type { PropagationAPI } from './api/propagation';
+export { SpanAttributes, SpanAttributeValue } from './trace/attributes';
+export { Link } from './trace/link';
+export { ProxyTracer, TracerDelegator } from './trace/ProxyTracer';
+export { ProxyTracerProvider } from './trace/ProxyTracerProvider';
+export { Sampler } from './trace/Sampler';
+export { SamplingDecision, SamplingResult } from './trace/SamplingResult';
+export { SpanContext } from './trace/span_context';
+export { SpanKind } from './trace/span_kind';
+export { Span } from './trace/span';
+export { SpanOptions } from './trace/SpanOptions';
+export { SpanStatus, SpanStatusCode } from './trace/status';
+export { TraceFlags } from './trace/trace_flags';
+export { TraceState } from './trace/trace_state';
+export { createTraceState } from './trace/internal/utils';
+export { TracerProvider } from './trace/tracer_provider';
+export { Tracer } from './trace/tracer';
+export { TracerOptions } from './trace/tracer_options';
+export { isSpanContextValid, isValidTraceId, isValidSpanId, } from './trace/spancontext-utils';
+export { INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT, } from './trace/invalid-span-constants';
+export type { TraceAPI } from './api/trace';
+import { context } from './context-api';
+import { diag } from './diag-api';
+import { metrics } from './metrics-api';
+import { propagation } from './propagation-api';
+import { trace } from './trace-api';
+export { context, diag, metrics, propagation, trace };
+declare const _default: {
+    context: import("./api/context").ContextAPI;
+    diag: import("./api/diag").DiagAPI;
+    metrics: import("./api/metrics").MetricsAPI;
+    propagation: import("./api/propagation").PropagationAPI;
+    trace: import("./api/trace").TraceAPI;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@opentelemetry/api/build/esm/index.js

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+export { baggageEntryMetadataFromString } from './baggage/utils';
+// Context APIs
+export { createContextKey, ROOT_CONTEXT } from './context/context';
+// Diag APIs
+export { DiagConsoleLogger } from './diag/consoleLogger';
+export { DiagLogLevel, } from './diag/types';
+// Metrics APIs
+export { createNoopMeter } from './metrics/NoopMeter';
+export { ValueType, } from './metrics/Metric';
+// Propagation APIs
+export { defaultTextMapGetter, defaultTextMapSetter, } from './propagation/TextMapPropagator';
+export { ProxyTracer } from './trace/ProxyTracer';
+export { ProxyTracerProvider } from './trace/ProxyTracerProvider';
+export { SamplingDecision } from './trace/SamplingResult';
+export { SpanKind } from './trace/span_kind';
+export { SpanStatusCode } from './trace/status';
+export { TraceFlags } from './trace/trace_flags';
+export { createTraceState } from './trace/internal/utils';
+export { isSpanContextValid, isValidTraceId, isValidSpanId, } from './trace/spancontext-utils';
+export { INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT, } from './trace/invalid-span-constants';
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+import { context } from './context-api';
+import { diag } from './diag-api';
+import { metrics } from './metrics-api';
+import { propagation } from './propagation-api';
+import { trace } from './trace-api';
+// Named export.
+export { context, diag, metrics, propagation, trace };
+// Default export.
+export default {
+    context: context,
+    diag: diag,
+    metrics: metrics,
+    propagation: propagation,
+    trace: trace,
+};
+//# sourceMappingURL=index.js.map

package/node_modules/@opentelemetry/api/build/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AAKjE,eAAe;AACf,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAInE,YAAY;AACZ,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAGL,YAAY,GAGb,MAAM,cAAc,CAAC;AAGtB,eAAe;AACf,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EACL,SAAS,GAeV,MAAM,kBAAkB,CAAC;AAO1B,mBAAmB;AACnB,OAAO,EAIL,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAMzC,OAAO,EAAE,WAAW,EAAmB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAG7C,OAAO,EAAc,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI1D,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,aAAa,GACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,cAAc,EACd,eAAe,EACf,oBAAoB,GACrB,MAAM,gCAAgC,CAAC;AAGxC,sEAAsE;AACtE,qCAAqC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,gBAAgB;AAChB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AACtD,kBAAkB;AAClB,eAAe;IACb,OAAO,SAAA;IACP,IAAI,MAAA;IACJ,OAAO,SAAA;IACP,WAAW,aAAA;IACX,KAAK,OAAA;CACN,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport { BaggageEntry, BaggageEntryMetadata, Baggage } from './baggage/types';\nexport { baggageEntryMetadataFromString } from './baggage/utils';\nexport { Exception } from './common/Exception';\nexport { HrTime, TimeInput } from './common/Time';\nexport { Attributes, AttributeValue } from './common/Attributes';\n\n// Context APIs\nexport { createContextKey, ROOT_CONTEXT } from './context/context';\nexport { Context, ContextManager } from './context/types';\nexport type { ContextAPI } from './api/context';\n\n// Diag APIs\nexport { DiagConsoleLogger } from './diag/consoleLogger';\nexport {\n  DiagLogFunction,\n  DiagLogger,\n  DiagLogLevel,\n  ComponentLoggerOptions,\n  DiagLoggerOptions,\n} from './diag/types';\nexport type { DiagAPI } from './api/diag';\n\n// Metrics APIs\nexport { createNoopMeter } from './metrics/NoopMeter';\nexport { MeterOptions, Meter } from './metrics/Meter';\nexport { MeterProvider } from './metrics/MeterProvider';\nexport {\n  ValueType,\n  Counter,\n  Gauge,\n  Histogram,\n  MetricOptions,\n  Observable,\n  ObservableCounter,\n  ObservableGauge,\n  ObservableUpDownCounter,\n  UpDownCounter,\n  BatchObservableCallback,\n  MetricAdvice,\n  MetricAttributes,\n  MetricAttributeValue,\n  ObservableCallback,\n} from './metrics/Metric';\nexport {\n  BatchObservableResult,\n  ObservableResult,\n} from './metrics/ObservableResult';\nexport type { MetricsAPI } from './api/metrics';\n\n// Propagation APIs\nexport {\n  TextMapPropagator,\n  TextMapSetter,\n  TextMapGetter,\n  defaultTextMapGetter,\n  defaultTextMapSetter,\n} from './propagation/TextMapPropagator';\nexport type { PropagationAPI } from './api/propagation';\n\n// Trace APIs\nexport { SpanAttributes, SpanAttributeValue } from './trace/attributes';\nexport { Link } from './trace/link';\nexport { ProxyTracer, TracerDelegator } from './trace/ProxyTracer';\nexport { ProxyTracerProvider } from './trace/ProxyTracerProvider';\nexport { Sampler } from './trace/Sampler';\nexport { SamplingDecision, SamplingResult } from './trace/SamplingResult';\nexport { SpanContext } from './trace/span_context';\nexport { SpanKind } from './trace/span_kind';\nexport { Span } from './trace/span';\nexport { SpanOptions } from './trace/SpanOptions';\nexport { SpanStatus, SpanStatusCode } from './trace/status';\nexport { TraceFlags } from './trace/trace_flags';\nexport { TraceState } from './trace/trace_state';\nexport { createTraceState } from './trace/internal/utils';\nexport { TracerProvider } from './trace/tracer_provider';\nexport { Tracer } from './trace/tracer';\nexport { TracerOptions } from './trace/tracer_options';\nexport {\n  isSpanContextValid,\n  isValidTraceId,\n  isValidSpanId,\n} from './trace/spancontext-utils';\nexport {\n  INVALID_SPANID,\n  INVALID_TRACEID,\n  INVALID_SPAN_CONTEXT,\n} from './trace/invalid-span-constants';\nexport type { TraceAPI } from './api/trace';\n\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { context } from './context-api';\nimport { diag } from './diag-api';\nimport { metrics } from './metrics-api';\nimport { propagation } from './propagation-api';\nimport { trace } from './trace-api';\n\n// Named export.\nexport { context, diag, metrics, propagation, trace };\n// Default export.\nexport default {\n  context,\n  diag,\n  metrics,\n  propagation,\n  trace,\n};\n"]}

package/node_modules/@opentelemetry/api/build/esm/internal/global-utils.d.ts

@@ -0,0 +1,18 @@
+import { MeterProvider } from '../metrics/MeterProvider';
+import { ContextManager } from '../context/types';
+import { DiagLogger } from '../diag/types';
+import { TextMapPropagator } from '../propagation/TextMapPropagator';
+import type { TracerProvider } from '../trace/tracer_provider';
+export declare function registerGlobal<Type extends keyof OTelGlobalAPI>(type: Type, instance: OTelGlobalAPI[Type], diag: DiagLogger, allowOverride?: boolean): boolean;
+export declare function getGlobal<Type extends keyof OTelGlobalAPI>(type: Type): OTelGlobalAPI[Type] | undefined;
+export declare function unregisterGlobal(type: keyof OTelGlobalAPI, diag: DiagLogger): void;
+declare type OTelGlobalAPI = {
+    version: string;
+    diag?: DiagLogger;
+    trace?: TracerProvider;
+    context?: ContextManager;
+    metrics?: MeterProvider;
+    propagation?: TextMapPropagator;
+};
+export {};
+//# sourceMappingURL=global-utils.d.ts.map

package/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js

@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+import { _globalThis } from '../platform';
+import { VERSION } from '../version';
+import { isCompatible } from './semver';
+var major = VERSION.split('.')[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+export function registerGlobal(type, instance, diag, allowOverride) {
+    var _a;
+    if (allowOverride === void 0) { allowOverride = false; }
+    var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+        version: VERSION,
+    });
+    if (!allowOverride && api[type]) {
+        // already registered an API of this type
+        var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+        diag.error(err.stack || err.message);
+        return false;
+    }
+    if (api.version !== VERSION) {
+        // All registered APIs must be of the same version exactly
+        var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+        diag.error(err.stack || err.message);
+        return false;
+    }
+    api[type] = instance;
+    diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+    return true;
+}
+export function getGlobal(type) {
+    var _a, _b;
+    var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+    if (!globalVersion || !isCompatible(globalVersion)) {
+        return;
+    }
+    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+export function unregisterGlobal(type, diag) {
+    diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+    if (api) {
+        delete api[type];
+    }
+}
+//# sourceMappingURL=global-utils.js.map

package/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-utils.js","sourceRoot":"","sources":["../../../src/internal/global-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,IAAM,4BAA4B,GAAG,MAAM,CAAC,GAAG,CAC7C,0BAAwB,KAAO,CAChC,CAAC;AAEF,IAAM,OAAO,GAAG,WAAyB,CAAC;AAE1C,MAAM,UAAU,cAAc,CAC5B,IAAU,EACV,QAA6B,EAC7B,IAAgB,EAChB,aAAqB;;IAArB,8BAAA,EAAA,qBAAqB;IAErB,IAAM,GAAG,GAAG,CAAC,OAAO,CAAC,4BAA4B,CAAC,GAAG,MAAA,OAAO,CAC1D,4BAA4B,CAC7B,mCAAI;QACH,OAAO,EAAE,OAAO;KACjB,CAAC,CAAC;IAEH,IAAI,CAAC,aAAa,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE;QAC/B,yCAAyC;QACzC,IAAM,GAAG,GAAG,IAAI,KAAK,CACnB,kEAAgE,IAAM,CACvE,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC;KACd;IAED,IAAI,GAAG,CAAC,OAAO,KAAK,OAAO,EAAE;QAC3B,0DAA0D;QAC1D,IAAM,GAAG,GAAG,IAAI,KAAK,CACnB,kDAAgD,GAAG,CAAC,OAAO,aAAQ,IAAI,mDAA8C,OAAS,CAC/H,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC;KACd;IAED,GAAG,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;IACrB,IAAI,CAAC,KAAK,CACR,iDAA+C,IAAI,UAAK,OAAO,MAAG,CACnE,CAAC;IAEF,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,SAAS,CACvB,IAAU;;IAEV,IAAM,aAAa,GAAG,MAAA,OAAO,CAAC,4BAA4B,CAAC,0CAAE,OAAO,CAAC;IACrE,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE;QAClD,OAAO;KACR;IACD,OAAO,MAAA,OAAO,CAAC,4BAA4B,CAAC,0CAAG,IAAI,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAyB,EAAE,IAAgB;IAC1E,IAAI,CAAC,KAAK,CACR,oDAAkD,IAAI,UAAK,OAAO,MAAG,CACtE,CAAC;IACF,IAAM,GAAG,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAElD,IAAI,GAAG,EAAE;QACP,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC;KAClB;AACH,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { MeterProvider } from '../metrics/MeterProvider';\nimport { ContextManager } from '../context/types';\nimport { DiagLogger } from '../diag/types';\nimport { _globalThis } from '../platform';\nimport { TextMapPropagator } from '../propagation/TextMapPropagator';\nimport type { TracerProvider } from '../trace/tracer_provider';\nimport { VERSION } from '../version';\nimport { isCompatible } from './semver';\n\nconst major = VERSION.split('.')[0];\nconst GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(\n  `opentelemetry.js.api.${major}`\n);\n\nconst _global = _globalThis as OTelGlobal;\n\nexport function registerGlobal<Type extends keyof OTelGlobalAPI>(\n  type: Type,\n  instance: OTelGlobalAPI[Type],\n  diag: DiagLogger,\n  allowOverride = false\n): boolean {\n  const api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = _global[\n    GLOBAL_OPENTELEMETRY_API_KEY\n  ] ?? {\n    version: VERSION,\n  });\n\n  if (!allowOverride && api[type]) {\n    // already registered an API of this type\n    const err = new Error(\n      `@opentelemetry/api: Attempted duplicate registration of API: ${type}`\n    );\n    diag.error(err.stack || err.message);\n    return false;\n  }\n\n  if (api.version !== VERSION) {\n    // All registered APIs must be of the same version exactly\n    const err = new Error(\n      `@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`\n    );\n    diag.error(err.stack || err.message);\n    return false;\n  }\n\n  api[type] = instance;\n  diag.debug(\n    `@opentelemetry/api: Registered a global for ${type} v${VERSION}.`\n  );\n\n  return true;\n}\n\nexport function getGlobal<Type extends keyof OTelGlobalAPI>(\n  type: Type\n): OTelGlobalAPI[Type] | undefined {\n  const globalVersion = _global[GLOBAL_OPENTELEMETRY_API_KEY]?.version;\n  if (!globalVersion || !isCompatible(globalVersion)) {\n    return;\n  }\n  return _global[GLOBAL_OPENTELEMETRY_API_KEY]?.[type];\n}\n\nexport function unregisterGlobal(type: keyof OTelGlobalAPI, diag: DiagLogger) {\n  diag.debug(\n    `@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`\n  );\n  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];\n\n  if (api) {\n    delete api[type];\n  }\n}\n\ntype OTelGlobal = {\n  [GLOBAL_OPENTELEMETRY_API_KEY]?: OTelGlobalAPI;\n};\n\ntype OTelGlobalAPI = {\n  version: string;\n\n  diag?: DiagLogger;\n  trace?: TracerProvider;\n  context?: ContextManager;\n  metrics?: MeterProvider;\n  propagation?: TextMapPropagator;\n};\n"]}

package/node_modules/@opentelemetry/api/build/esm/internal/semver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Create a function to test an API version to see if it is compatible with the provided ownVersion.
+ *
+ * The returned function has the following semantics:
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param ownVersion version which should be checked against
+ */
+export declare function _makeCompatibilityCheck(ownVersion: string): (globalVersion: string) => boolean;
+/**
+ * Test an API version to see if it is compatible with this API.
+ *
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param version version of the API requesting an instance of the global API
+ */
+export declare const isCompatible: (globalVersion: string) => boolean;
+//# sourceMappingURL=semver.d.ts.map

package/node_modules/@opentelemetry/api/build/esm/internal/semver.js

@@ -0,0 +1,118 @@
+/*
+ * 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.
+ */
+import { VERSION } from '../version';
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+/**
+ * Create a function to test an API version to see if it is compatible with the provided ownVersion.
+ *
+ * The returned function has the following semantics:
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param ownVersion version which should be checked against
+ */
+export function _makeCompatibilityCheck(ownVersion) {
+    var acceptedVersions = new Set([ownVersion]);
+    var rejectedVersions = new Set();
+    var myVersionMatch = ownVersion.match(re);
+    if (!myVersionMatch) {
+        // we cannot guarantee compatibility so we always return noop
+        return function () { return false; };
+    }
+    var ownVersionParsed = {
+        major: +myVersionMatch[1],
+        minor: +myVersionMatch[2],
+        patch: +myVersionMatch[3],
+        prerelease: myVersionMatch[4],
+    };
+    // if ownVersion has a prerelease tag, versions must match exactly
+    if (ownVersionParsed.prerelease != null) {
+        return function isExactmatch(globalVersion) {
+            return globalVersion === ownVersion;
+        };
+    }
+    function _reject(v) {
+        rejectedVersions.add(v);
+        return false;
+    }
+    function _accept(v) {
+        acceptedVersions.add(v);
+        return true;
+    }
+    return function isCompatible(globalVersion) {
+        if (acceptedVersions.has(globalVersion)) {
+            return true;
+        }
+        if (rejectedVersions.has(globalVersion)) {
+            return false;
+        }
+        var globalVersionMatch = globalVersion.match(re);
+        if (!globalVersionMatch) {
+            // cannot parse other version
+            // we cannot guarantee compatibility so we always noop
+            return _reject(globalVersion);
+        }
+        var globalVersionParsed = {
+            major: +globalVersionMatch[1],
+            minor: +globalVersionMatch[2],
+            patch: +globalVersionMatch[3],
+            prerelease: globalVersionMatch[4],
+        };
+        // if globalVersion has a prerelease tag, versions must match exactly
+        if (globalVersionParsed.prerelease != null) {
+            return _reject(globalVersion);
+        }
+        // major versions must match
+        if (ownVersionParsed.major !== globalVersionParsed.major) {
+            return _reject(globalVersion);
+        }
+        if (ownVersionParsed.major === 0) {
+            if (ownVersionParsed.minor === globalVersionParsed.minor &&
+                ownVersionParsed.patch <= globalVersionParsed.patch) {
+                return _accept(globalVersion);
+            }
+            return _reject(globalVersion);
+        }
+        if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+            return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+    };
+}
+/**
+ * Test an API version to see if it is compatible with this API.
+ *
+ * - Exact match is always compatible
+ * - Major versions must match exactly
+ *    - 1.x package cannot use global 2.x package
+ *    - 2.x package cannot use global 1.x package
+ * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+ *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+ *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+ * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+ * - Patch and build tag differences are not considered at this time
+ *
+ * @param version version of the API requesting an instance of the global API
+ */
+export var isCompatible = _makeCompatibilityCheck(VERSION);
+//# sourceMappingURL=semver.js.map

package/node_modules/@opentelemetry/api/build/esm/internal/semver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semver.js","sourceRoot":"","sources":["../../../src/internal/semver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,IAAM,EAAE,GAAG,+BAA+B,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAkB;IAElB,IAAM,gBAAgB,GAAG,IAAI,GAAG,CAAS,CAAC,UAAU,CAAC,CAAC,CAAC;IACvD,IAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;IAE3C,IAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5C,IAAI,CAAC,cAAc,EAAE;QACnB,6DAA6D;QAC7D,OAAO,cAAM,OAAA,KAAK,EAAL,CAAK,CAAC;KACpB;IAED,IAAM,gBAAgB,GAAG;QACvB,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QACzB,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QACzB,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QACzB,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;KAC9B,CAAC;IAEF,kEAAkE;IAClE,IAAI,gBAAgB,CAAC,UAAU,IAAI,IAAI,EAAE;QACvC,OAAO,SAAS,YAAY,CAAC,aAAqB;YAChD,OAAO,aAAa,KAAK,UAAU,CAAC;QACtC,CAAC,CAAC;KACH;IAED,SAAS,OAAO,CAAC,CAAS;QACxB,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,OAAO,CAAC,CAAS;QACxB,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,SAAS,YAAY,CAAC,aAAqB;QAChD,IAAI,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;YACvC,OAAO,IAAI,CAAC;SACb;QAED,IAAI,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;YACvC,OAAO,KAAK,CAAC;SACd;QAED,IAAM,kBAAkB,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACnD,IAAI,CAAC,kBAAkB,EAAE;YACvB,6BAA6B;YAC7B,sDAAsD;YACtD,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;SAC/B;QAED,IAAM,mBAAmB,GAAG;YAC1B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAC7B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAC7B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAC7B,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC;SAClC,CAAC;QAEF,qEAAqE;QACrE,IAAI,mBAAmB,CAAC,UAAU,IAAI,IAAI,EAAE;YAC1C,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;SAC/B;QAED,4BAA4B;QAC5B,IAAI,gBAAgB,CAAC,KAAK,KAAK,mBAAmB,CAAC,KAAK,EAAE;YACxD,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;SAC/B;QAED,IAAI,gBAAgB,CAAC,KAAK,KAAK,CAAC,EAAE;YAChC,IACE,gBAAgB,CAAC,KAAK,KAAK,mBAAmB,CAAC,KAAK;gBACpD,gBAAgB,CAAC,KAAK,IAAI,mBAAmB,CAAC,KAAK,EACnD;gBACA,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;aAC/B;YAED,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;SAC/B;QAED,IAAI,gBAAgB,CAAC,KAAK,IAAI,mBAAmB,CAAC,KAAK,EAAE;YACvD,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;SAC/B;QAED,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,IAAM,YAAY,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { VERSION } from '../version';\n\nconst re = /^(\\d+)\\.(\\d+)\\.(\\d+)(-(.+))?$/;\n\n/**\n * Create a function to test an API version to see if it is compatible with the provided ownVersion.\n *\n * The returned function has the following semantics:\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param ownVersion version which should be checked against\n */\nexport function _makeCompatibilityCheck(\n  ownVersion: string\n): (globalVersion: string) => boolean {\n  const acceptedVersions = new Set<string>([ownVersion]);\n  const rejectedVersions = new Set<string>();\n\n  const myVersionMatch = ownVersion.match(re);\n  if (!myVersionMatch) {\n    // we cannot guarantee compatibility so we always return noop\n    return () => false;\n  }\n\n  const ownVersionParsed = {\n    major: +myVersionMatch[1],\n    minor: +myVersionMatch[2],\n    patch: +myVersionMatch[3],\n    prerelease: myVersionMatch[4],\n  };\n\n  // if ownVersion has a prerelease tag, versions must match exactly\n  if (ownVersionParsed.prerelease != null) {\n    return function isExactmatch(globalVersion: string): boolean {\n      return globalVersion === ownVersion;\n    };\n  }\n\n  function _reject(v: string) {\n    rejectedVersions.add(v);\n    return false;\n  }\n\n  function _accept(v: string) {\n    acceptedVersions.add(v);\n    return true;\n  }\n\n  return function isCompatible(globalVersion: string): boolean {\n    if (acceptedVersions.has(globalVersion)) {\n      return true;\n    }\n\n    if (rejectedVersions.has(globalVersion)) {\n      return false;\n    }\n\n    const globalVersionMatch = globalVersion.match(re);\n    if (!globalVersionMatch) {\n      // cannot parse other version\n      // we cannot guarantee compatibility so we always noop\n      return _reject(globalVersion);\n    }\n\n    const globalVersionParsed = {\n      major: +globalVersionMatch[1],\n      minor: +globalVersionMatch[2],\n      patch: +globalVersionMatch[3],\n      prerelease: globalVersionMatch[4],\n    };\n\n    // if globalVersion has a prerelease tag, versions must match exactly\n    if (globalVersionParsed.prerelease != null) {\n      return _reject(globalVersion);\n    }\n\n    // major versions must match\n    if (ownVersionParsed.major !== globalVersionParsed.major) {\n      return _reject(globalVersion);\n    }\n\n    if (ownVersionParsed.major === 0) {\n      if (\n        ownVersionParsed.minor === globalVersionParsed.minor &&\n        ownVersionParsed.patch <= globalVersionParsed.patch\n      ) {\n        return _accept(globalVersion);\n      }\n\n      return _reject(globalVersion);\n    }\n\n    if (ownVersionParsed.minor <= globalVersionParsed.minor) {\n      return _accept(globalVersion);\n    }\n\n    return _reject(globalVersion);\n  };\n}\n\n/**\n * Test an API version to see if it is compatible with this API.\n *\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param version version of the API requesting an instance of the global API\n */\nexport const isCompatible = _makeCompatibilityCheck(VERSION);\n"]}