@workflow/web 5.0.0-beta.5 → 5.0.0-beta.51

package/build/server/assets/index-CETb4fkq.js

@@ -0,0 +1,1164 @@
+import { createRequire as __wkfCreateRequire } from "node:module";
+if (typeof require === "undefined") {
+  globalThis.require = __wkfCreateRequire(import.meta.url);
+}
+const VERSION = "1.9.1";
+const re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  const rejectedVersions = /* @__PURE__ */ new Set();
+  const myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return () => false;
+  }
+  const ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  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 isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    const globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    const globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    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);
+  };
+}
+const isCompatible = _makeCompatibilityCheck(VERSION);
+const major = VERSION.split(".")[0];
+const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+const _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag2, allowOverride = false) {
+  var _a;
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  const 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];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+class DiagComponentLogger {
+  constructor(props) {
+    this._namespace = props.namespace || "DiagComponentLogger";
+  }
+  debug(...args) {
+    return logProxy("debug", this._namespace, args);
+  }
+  error(...args) {
+    return logProxy("error", this._namespace, args);
+  }
+  info(...args) {
+    return logProxy("info", this._namespace, args);
+  }
+  warn(...args) {
+    return logProxy("warn", this._namespace, args);
+  }
+  verbose(...args) {
+    return logProxy("verbose", this._namespace, args);
+  }
+}
+function logProxy(funcName, namespace, args) {
+  const logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  return logger[funcName](namespace, ...args);
+}
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    const theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+const API_NAME$4 = "diag";
+class DiagAPI {
+  /** Get the singleton instance of the DiagAPI API */
+  static instance() {
+    if (!this._instance) {
+      this._instance = new DiagAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Private internal constructor
+   * @private
+   */
+  constructor() {
+    function _logProxy(funcName) {
+      return function(...args) {
+        const logger = getGlobal("diag");
+        if (!logger)
+          return;
+        return logger[funcName](...args);
+      };
+    }
+    const self2 = this;
+    const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+      var _a, _b, _c;
+      if (logger === self2) {
+        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+        return false;
+      }
+      if (typeof optionsOrLogLevel === "number") {
+        optionsOrLogLevel = {
+          logLevel: optionsOrLogLevel
+        };
+      }
+      const oldLogger = getGlobal("diag");
+      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+        oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+        newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+      }
+      return registerGlobal("diag", newLogger, self2, true);
+    };
+    self2.setLogger = setLogger;
+    self2.disable = () => {
+      unregisterGlobal(API_NAME$4, self2);
+    };
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
+    };
+    self2.verbose = _logProxy("verbose");
+    self2.debug = _logProxy("debug");
+    self2.info = _logProxy("info");
+    self2.warn = _logProxy("warn");
+    self2.error = _logProxy("error");
+  }
+}
+class BaggageImpl {
+  constructor(entries) {
+    this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+  }
+  getEntry(key) {
+    const entry = this._entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    return Object.assign({}, entry);
+  }
+  getAllEntries() {
+    return Array.from(this._entries.entries());
+  }
+  setEntry(key, entry) {
+    const newBaggage = new BaggageImpl(this._entries);
+    newBaggage._entries.set(key, entry);
+    return newBaggage;
+  }
+  removeEntry(key) {
+    const newBaggage = new BaggageImpl(this._entries);
+    newBaggage._entries.delete(key);
+    return newBaggage;
+  }
+  removeEntries(...keys) {
+    const newBaggage = new BaggageImpl(this._entries);
+    for (const key of keys) {
+      newBaggage._entries.delete(key);
+    }
+    return newBaggage;
+  }
+  clear() {
+    return new BaggageImpl();
+  }
+}
+const baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+const diag$1 = DiagAPI.instance();
+function createBaggage(entries = {}) {
+  return new BaggageImpl(new Map(Object.entries(entries)));
+}
+function baggageEntryMetadataFromString(str) {
+  if (typeof str !== "string") {
+    diag$1.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+    str = "";
+  }
+  return {
+    __TYPE__: baggageEntryMetadataSymbol,
+    toString() {
+      return str;
+    }
+  };
+}
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+class BaseContext {
+  /**
+   * Construct a new context which inherits values from an optional parent context.
+   *
+   * @param parentContext a context from which to inherit values
+   */
+  constructor(parentContext) {
+    const self2 = this;
+    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2.getValue = (key) => self2._currentContext.get(key);
+    self2.setValue = (key, value) => {
+      const context2 = new BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
+    };
+    self2.deleteValue = (key) => {
+      const context2 = new BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
+    };
+  }
+}
+const ROOT_CONTEXT = new BaseContext();
+const consoleMap = [
+  { n: "error", c: "error" },
+  { n: "warn", c: "warn" },
+  { n: "info", c: "info" },
+  { n: "debug", c: "debug" },
+  { n: "verbose", c: "trace" }
+];
+const _originalConsoleMethods = {};
+if (typeof console !== "undefined") {
+  const keys = [
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace",
+    "log"
+  ];
+  for (const key of keys) {
+    if (typeof console[key] === "function") {
+      _originalConsoleMethods[key] = console[key];
+    }
+  }
+}
+class DiagConsoleLogger {
+  constructor() {
+    function _consoleFunc(funcName) {
+      return function(...args) {
+        let theFunc = _originalConsoleMethods[funcName];
+        if (typeof theFunc !== "function") {
+          theFunc = _originalConsoleMethods["log"];
+        }
+        if (typeof theFunc !== "function" && console) {
+          theFunc = console[funcName];
+          if (typeof theFunc !== "function") {
+            theFunc = console.log;
+          }
+        }
+        if (typeof theFunc === "function") {
+          return theFunc.apply(console, args);
+        }
+      };
+    }
+    for (let i = 0; i < consoleMap.length; i++) {
+      this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+    }
+  }
+}
+class NoopMeter {
+  constructor() {
+  }
+  /**
+   * @see {@link Meter.createGauge}
+   */
+  createGauge(_name, _options) {
+    return NOOP_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createHistogram}
+   */
+  createHistogram(_name, _options) {
+    return NOOP_HISTOGRAM_METRIC;
+  }
+  /**
+   * @see {@link Meter.createCounter}
+   */
+  createCounter(_name, _options) {
+    return NOOP_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createUpDownCounter(_name, _options) {
+    return NOOP_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableGauge}
+   */
+  createObservableGauge(_name, _options) {
+    return NOOP_OBSERVABLE_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableCounter}
+   */
+  createObservableCounter(_name, _options) {
+    return NOOP_OBSERVABLE_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableUpDownCounter}
+   */
+  createObservableUpDownCounter(_name, _options) {
+    return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.addBatchObservableCallback}
+   */
+  addBatchObservableCallback(_callback, _observables) {
+  }
+  /**
+   * @see {@link Meter.removeBatchObservableCallback}
+   */
+  removeBatchObservableCallback(_callback) {
+  }
+}
+class NoopMetric {
+}
+class NoopCounterMetric extends NoopMetric {
+  add(_value, _attributes) {
+  }
+}
+class NoopUpDownCounterMetric extends NoopMetric {
+  add(_value, _attributes) {
+  }
+}
+class NoopGaugeMetric extends NoopMetric {
+  record(_value, _attributes) {
+  }
+}
+class NoopHistogramMetric extends NoopMetric {
+  record(_value, _attributes) {
+  }
+}
+class NoopObservableMetric {
+  addCallback(_callback) {
+  }
+  removeCallback(_callback) {
+  }
+}
+class NoopObservableCounterMetric extends NoopObservableMetric {
+}
+class NoopObservableGaugeMetric extends NoopObservableMetric {
+}
+class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
+}
+const NOOP_METER = new NoopMeter();
+const NOOP_COUNTER_METRIC = new NoopCounterMetric();
+const NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+const NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+const NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+const NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+const NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+const NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+function createNoopMeter() {
+  return NOOP_METER;
+}
+var ValueType;
+(function(ValueType2) {
+  ValueType2[ValueType2["INT"] = 0] = "INT";
+  ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+})(ValueType || (ValueType = {}));
+const defaultTextMapGetter = {
+  get(carrier, key) {
+    if (carrier == null) {
+      return void 0;
+    }
+    return carrier[key];
+  },
+  keys(carrier) {
+    if (carrier == null) {
+      return [];
+    }
+    return Object.keys(carrier);
+  }
+};
+const defaultTextMapSetter = {
+  set(carrier, key, value) {
+    if (carrier == null) {
+      return;
+    }
+    carrier[key] = value;
+  }
+};
+class NoopContextManager {
+  active() {
+    return ROOT_CONTEXT;
+  }
+  with(_context, fn, thisArg, ...args) {
+    return fn.call(thisArg, ...args);
+  }
+  bind(_context, target) {
+    return target;
+  }
+  enable() {
+    return this;
+  }
+  disable() {
+    return this;
+  }
+}
+const API_NAME$3 = "context";
+const NOOP_CONTEXT_MANAGER = new NoopContextManager();
+class ContextAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Context API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new ContextAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager) {
+    return registerGlobal(API_NAME$3, contextManager, DiagAPI.instance());
+  }
+  /**
+   * Get the currently active context
+   */
+  active() {
+    return this._getContextManager().active();
+  }
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, fn, thisArg, ...args);
+  }
+  /**
+   * Bind a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind(context2, target) {
+    return this._getContextManager().bind(context2, target);
+  }
+  _getContextManager() {
+    return getGlobal(API_NAME$3) || NOOP_CONTEXT_MANAGER;
+  }
+  /** Disable and remove the global context manager */
+  disable() {
+    this._getContextManager().disable();
+    unregisterGlobal(API_NAME$3, DiagAPI.instance());
+  }
+}
+var TraceFlags;
+(function(TraceFlags2) {
+  TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+  TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags || (TraceFlags = {}));
+const INVALID_SPANID = "0000000000000000";
+const INVALID_TRACEID = "00000000000000000000000000000000";
+const INVALID_SPAN_CONTEXT = {
+  traceId: INVALID_TRACEID,
+  spanId: INVALID_SPANID,
+  traceFlags: TraceFlags.NONE
+};
+class NonRecordingSpan {
+  constructor(spanContext = INVALID_SPAN_CONTEXT) {
+    this._spanContext = spanContext;
+  }
+  // Returns a SpanContext.
+  spanContext() {
+    return this._spanContext;
+  }
+  // By default does nothing
+  setAttribute(_key, _value) {
+    return this;
+  }
+  // By default does nothing
+  setAttributes(_attributes) {
+    return this;
+  }
+  // By default does nothing
+  addEvent(_name, _attributes) {
+    return this;
+  }
+  addLink(_link) {
+    return this;
+  }
+  addLinks(_links) {
+    return this;
+  }
+  // By default does nothing
+  setStatus(_status) {
+    return this;
+  }
+  // By default does nothing
+  updateName(_name) {
+    return this;
+  }
+  // By default does nothing
+  end(_endTime) {
+  }
+  // isRecording always returns false for NonRecordingSpan.
+  isRecording() {
+    return false;
+  }
+  // By default does nothing
+  recordException(_exception, _time) {
+  }
+}
+const SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
+}
+function getActiveSpan() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context2) {
+  var _a;
+  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+const isHex = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1
+]);
+function isValidHex(id, length) {
+  if (typeof id !== "string" || id.length !== length)
+    return false;
+  let r = 0;
+  for (let i = 0; i < id.length; i += 4) {
+    r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+  }
+  return r === length;
+}
+function isValidTraceId(traceId) {
+  return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+const contextApi = ContextAPI.getInstance();
+class NoopTracer {
+  // startSpan starts a noop span.
+  startSpan(name, options, context2 = contextApi.active()) {
+    const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+    if (root) {
+      return new NonRecordingSpan();
+    }
+    const parentFromContext = context2 && getSpanContext(context2);
+    if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+      return new NonRecordingSpan(parentFromContext);
+    } else {
+      return new NonRecordingSpan();
+    }
+  }
+  startActiveSpan(name, arg2, arg3, arg4) {
+    let opts;
+    let ctx;
+    let fn;
+    if (arguments.length < 2) {
+      return;
+    } else if (arguments.length === 2) {
+      fn = arg2;
+    } else if (arguments.length === 3) {
+      opts = arg2;
+      fn = arg3;
+    } else {
+      opts = arg2;
+      ctx = arg3;
+      fn = arg4;
+    }
+    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, void 0, span);
+  }
+}
+function isSpanContext(spanContext) {
+  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";
+}
+const NOOP_TRACER = new NoopTracer();
+class ProxyTracer {
+  constructor(provider, name, version, options) {
+    this._provider = provider;
+    this.name = name;
+    this.version = version;
+    this.options = options;
+  }
+  startSpan(name, options, context2) {
+    return this._getTracer().startSpan(name, options, context2);
+  }
+  startActiveSpan(_name, _options, _context, _fn) {
+    const tracer = this._getTracer();
+    return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+  }
+  /**
+   * Try to get a tracer from the proxy tracer provider.
+   * If the proxy tracer provider has no delegate, return a noop tracer.
+   */
+  _getTracer() {
+    if (this._delegate) {
+      return this._delegate;
+    }
+    const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+    if (!tracer) {
+      return NOOP_TRACER;
+    }
+    this._delegate = tracer;
+    return this._delegate;
+  }
+}
+class NoopTracerProvider {
+  getTracer(_name, _version, _options) {
+    return new NoopTracer();
+  }
+}
+const NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+class ProxyTracerProvider {
+  /**
+   * Get a {@link ProxyTracer}
+   */
+  getTracer(name, version, options) {
+    var _a;
+    return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+  }
+  getDelegate() {
+    var _a;
+    return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+  }
+  /**
+   * Set the delegate tracer provider
+   */
+  setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  getDelegateTracer(name, version, options) {
+    var _a;
+    return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+  }
+}
+var SamplingDecision;
+(function(SamplingDecision2) {
+  SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+  SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+  SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+})(SamplingDecision || (SamplingDecision = {}));
+var SpanKind;
+(function(SpanKind2) {
+  SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+  SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+  SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+  SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+  SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+const VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+const VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+const VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+const VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+const VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+const INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+function validateKey(key) {
+  return VALID_KEY_REGEX.test(key);
+}
+function validateValue(value) {
+  return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+const MAX_TRACE_STATE_ITEMS = 32;
+const MAX_TRACE_STATE_LEN = 512;
+const LIST_MEMBERS_SEPARATOR = ",";
+const LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+class TraceStateImpl {
+  constructor(rawTraceState) {
+    this._internalState = /* @__PURE__ */ new Map();
+    if (rawTraceState)
+      this._parse(rawTraceState);
+  }
+  set(key, value) {
+    const traceState = this._clone();
+    if (traceState._internalState.has(key)) {
+      traceState._internalState.delete(key);
+    }
+    traceState._internalState.set(key, value);
+    return traceState;
+  }
+  unset(key) {
+    const traceState = this._clone();
+    traceState._internalState.delete(key);
+    return traceState;
+  }
+  get(key) {
+    return this._internalState.get(key);
+  }
+  serialize() {
+    return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
+      agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+      return agg;
+    }, []).join(LIST_MEMBERS_SEPARATOR);
+  }
+  _parse(rawTraceState) {
+    if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+      return;
+    this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
+      const listMember = part.trim();
+      const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+      if (i !== -1) {
+        const key = listMember.slice(0, i);
+        const value = listMember.slice(i + 1, part.length);
+        if (validateKey(key) && validateValue(value)) {
+          agg.set(key, value);
+        }
+      }
+      return agg;
+    }, /* @__PURE__ */ new Map());
+    if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+      this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+    }
+  }
+  // @ts-expect-error TS6133 Accessed in tests only.
+  _keys() {
+    return Array.from(this._internalState.keys()).reverse();
+  }
+  _clone() {
+    const traceState = new TraceStateImpl();
+    traceState._internalState = new Map(this._internalState);
+    return traceState;
+  }
+}
+function createTraceState(rawTraceState) {
+  return new TraceStateImpl(rawTraceState);
+}
+const context = ContextAPI.getInstance();
+const diag = DiagAPI.instance();
+class NoopMeterProvider {
+  getMeter(_name, _version, _options) {
+    return NOOP_METER;
+  }
+}
+const NOOP_METER_PROVIDER = new NoopMeterProvider();
+const API_NAME$2 = "metrics";
+class MetricsAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Metrics API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new MetricsAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current global meter provider.
+   * Returns true if the meter provider was successfully registered, else false.
+   */
+  setGlobalMeterProvider(provider) {
+    return registerGlobal(API_NAME$2, provider, DiagAPI.instance());
+  }
+  /**
+   * Returns the global meter provider.
+   */
+  getMeterProvider() {
+    return getGlobal(API_NAME$2) || NOOP_METER_PROVIDER;
+  }
+  /**
+   * Returns a meter from the global meter provider.
+   */
+  getMeter(name, version, options) {
+    return this.getMeterProvider().getMeter(name, version, options);
+  }
+  /** Remove the global meter provider */
+  disable() {
+    unregisterGlobal(API_NAME$2, DiagAPI.instance());
+  }
+}
+const metrics = MetricsAPI.getInstance();
+class NoopTextMapPropagator {
+  /** Noop inject function does nothing */
+  inject(_context, _carrier) {
+  }
+  /** Noop extract function does nothing and returns the input context */
+  extract(context2, _carrier) {
+    return context2;
+  }
+  fields() {
+    return [];
+  }
+}
+const BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+function getBaggage(context2) {
+  return context2.getValue(BAGGAGE_KEY) || void 0;
+}
+function getActiveBaggage() {
+  return getBaggage(ContextAPI.getInstance().active());
+}
+function setBaggage(context2, baggage) {
+  return context2.setValue(BAGGAGE_KEY, baggage);
+}
+function deleteBaggage(context2) {
+  return context2.deleteValue(BAGGAGE_KEY);
+}
+const API_NAME$1 = "propagation";
+const NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+class PropagationAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+    this.createBaggage = createBaggage;
+    this.getBaggage = getBaggage;
+    this.getActiveBaggage = getActiveBaggage;
+    this.setBaggage = setBaggage;
+    this.deleteBaggage = deleteBaggage;
+  }
+  /** Get the singleton instance of the Propagator API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new PropagationAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current propagator.
+   *
+   * @returns true if the propagator was successfully registered, else false
+   */
+  setGlobalPropagator(propagator) {
+    return registerGlobal(API_NAME$1, propagator, DiagAPI.instance());
+  }
+  /**
+   * Inject context into a carrier to be propagated inter-process
+   *
+   * @param context Context carrying tracing data to inject
+   * @param carrier carrier to inject context into
+   * @param setter Function used to set values on the carrier
+   */
+  inject(context2, carrier, setter = defaultTextMapSetter) {
+    return this._getGlobalPropagator().inject(context2, carrier, setter);
+  }
+  /**
+   * Extract context from a carrier
+   *
+   * @param context Context which the newly created context will inherit from
+   * @param carrier Carrier to extract context from
+   * @param getter Function used to extract keys from a carrier
+   */
+  extract(context2, carrier, getter = defaultTextMapGetter) {
+    return this._getGlobalPropagator().extract(context2, carrier, getter);
+  }
+  /**
+   * Return a list of all fields which may be used by the propagator.
+   */
+  fields() {
+    return this._getGlobalPropagator().fields();
+  }
+  /** Remove the global propagator */
+  disable() {
+    unregisterGlobal(API_NAME$1, DiagAPI.instance());
+  }
+  _getGlobalPropagator() {
+    return getGlobal(API_NAME$1) || NOOP_TEXT_MAP_PROPAGATOR;
+  }
+}
+const propagation = PropagationAPI.getInstance();
+const API_NAME = "trace";
+class TraceAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+    this._proxyTracerProvider = new ProxyTracerProvider();
+    this.wrapSpanContext = wrapSpanContext;
+    this.isSpanContextValid = isSpanContextValid;
+    this.deleteSpan = deleteSpan;
+    this.getSpan = getSpan;
+    this.getActiveSpan = getActiveSpan;
+    this.getSpanContext = getSpanContext;
+    this.setSpan = setSpan;
+    this.setSpanContext = setSpanContext;
+  }
+  /** Get the singleton instance of the Trace API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new TraceAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current global tracer.
+   *
+   * @returns true if the tracer provider was successfully registered, else false
+   */
+  setGlobalTracerProvider(provider) {
+    const success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
+    if (success) {
+      this._proxyTracerProvider.setDelegate(provider);
+    }
+    return success;
+  }
+  /**
+   * Returns the global tracer provider.
+   */
+  getTracerProvider() {
+    return getGlobal(API_NAME) || this._proxyTracerProvider;
+  }
+  /**
+   * Returns a tracer from the global tracer provider.
+   */
+  getTracer(name, version) {
+    return this.getTracerProvider().getTracer(name, version);
+  }
+  /** Remove the global tracer provider */
+  disable() {
+    unregisterGlobal(API_NAME, DiagAPI.instance());
+    this._proxyTracerProvider = new ProxyTracerProvider();
+  }
+}
+const trace = TraceAPI.getInstance();
+const index = {
+  context,
+  diag,
+  metrics,
+  propagation,
+  trace
+};
+export {
+  DiagConsoleLogger,
+  DiagLogLevel,
+  INVALID_SPANID,
+  INVALID_SPAN_CONTEXT,
+  INVALID_TRACEID,
+  ProxyTracer,
+  ProxyTracerProvider,
+  ROOT_CONTEXT,
+  SamplingDecision,
+  SpanKind,
+  SpanStatusCode,
+  TraceFlags,
+  ValueType,
+  baggageEntryMetadataFromString,
+  context,
+  createContextKey,
+  createNoopMeter,
+  createTraceState,
+  index as default,
+  defaultTextMapGetter,
+  defaultTextMapSetter,
+  diag,
+  isSpanContextValid,
+  isValidSpanId,
+  isValidTraceId,
+  metrics,
+  propagation,
+  trace
+};