raindrop-ai 0.0.52 → 0.0.53

package/dist/chunk-NLQ6QY5H.mjs

@@ -0,0 +1,3188 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js
+var require_AbstractAsyncHooksContextManager = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AbstractAsyncHooksContextManager = void 0;
+    var events_1 = __require("events");
+    var ADD_LISTENER_METHODS = [
+      "addListener",
+      "on",
+      "once",
+      "prependListener",
+      "prependOnceListener"
+    ];
+    var AbstractAsyncHooksContextManager = class {
+      constructor() {
+        __publicField(this, "_kOtListeners", Symbol("OtListeners"));
+        __publicField(this, "_wrapped", false);
+      }
+      /**
+       * Binds a the certain context or the active one to the target function and then returns the target
+       * @param context A context (span) to be bind to target
+       * @param target a function or event emitter. When target or one of its callbacks is called,
+       *  the provided context will be used as the active context for the duration of the call.
+       */
+      bind(context4, target) {
+        if (target instanceof events_1.EventEmitter) {
+          return this._bindEventEmitter(context4, target);
+        }
+        if (typeof target === "function") {
+          return this._bindFunction(context4, target);
+        }
+        return target;
+      }
+      _bindFunction(context4, target) {
+        const manager = this;
+        const contextWrapper = function(...args) {
+          return manager.with(context4, () => target.apply(this, args));
+        };
+        Object.defineProperty(contextWrapper, "length", {
+          enumerable: false,
+          configurable: true,
+          writable: false,
+          value: target.length
+        });
+        return contextWrapper;
+      }
+      /**
+       * By default, EventEmitter call their callback with their context, which we do
+       * not want, instead we will bind a specific context to all callbacks that
+       * go through it.
+       * @param context the context we want to bind
+       * @param ee EventEmitter an instance of EventEmitter to patch
+       */
+      _bindEventEmitter(context4, ee) {
+        const map = this._getPatchMap(ee);
+        if (map !== void 0)
+          return ee;
+        this._createPatchMap(ee);
+        ADD_LISTENER_METHODS.forEach((methodName) => {
+          if (ee[methodName] === void 0)
+            return;
+          ee[methodName] = this._patchAddListener(ee, ee[methodName], context4);
+        });
+        if (typeof ee.removeListener === "function") {
+          ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+        }
+        if (typeof ee.off === "function") {
+          ee.off = this._patchRemoveListener(ee, ee.off);
+        }
+        if (typeof ee.removeAllListeners === "function") {
+          ee.removeAllListeners = this._patchRemoveAllListeners(ee, ee.removeAllListeners);
+        }
+        return ee;
+      }
+      /**
+       * Patch methods that remove a given listener so that we match the "patched"
+       * version of that listener (the one that propagate context).
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       */
+      _patchRemoveListener(ee, original) {
+        const contextManager = this;
+        return function(event, listener) {
+          var _a;
+          const events = (_a = contextManager._getPatchMap(ee)) == null ? void 0 : _a[event];
+          if (events === void 0) {
+            return original.call(this, event, listener);
+          }
+          const patchedListener = events.get(listener);
+          return original.call(this, event, patchedListener || listener);
+        };
+      }
+      /**
+       * Patch methods that remove all listeners so we remove our
+       * internal references for a given event.
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       */
+      _patchRemoveAllListeners(ee, original) {
+        const contextManager = this;
+        return function(event) {
+          const map = contextManager._getPatchMap(ee);
+          if (map !== void 0) {
+            if (arguments.length === 0) {
+              contextManager._createPatchMap(ee);
+            } else if (map[event] !== void 0) {
+              delete map[event];
+            }
+          }
+          return original.apply(this, arguments);
+        };
+      }
+      /**
+       * Patch methods on an event emitter instance that can add listeners so we
+       * can force them to propagate a given context.
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       * @param [context] context to propagate when calling listeners
+       */
+      _patchAddListener(ee, original, context4) {
+        const contextManager = this;
+        return function(event, listener) {
+          if (contextManager._wrapped) {
+            return original.call(this, event, listener);
+          }
+          let map = contextManager._getPatchMap(ee);
+          if (map === void 0) {
+            map = contextManager._createPatchMap(ee);
+          }
+          let listeners = map[event];
+          if (listeners === void 0) {
+            listeners = /* @__PURE__ */ new WeakMap();
+            map[event] = listeners;
+          }
+          const patchedListener = contextManager.bind(context4, listener);
+          listeners.set(listener, patchedListener);
+          contextManager._wrapped = true;
+          try {
+            return original.call(this, event, patchedListener);
+          } finally {
+            contextManager._wrapped = false;
+          }
+        };
+      }
+      _createPatchMap(ee) {
+        const map = /* @__PURE__ */ Object.create(null);
+        ee[this._kOtListeners] = map;
+        return map;
+      }
+      _getPatchMap(ee) {
+        return ee[this._kOtListeners];
+      }
+    };
+    exports.AbstractAsyncHooksContextManager = AbstractAsyncHooksContextManager;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js
+var require_AsyncHooksContextManager = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncHooksContextManager = void 0;
+    var api_1 = __require("@opentelemetry/api");
+    var asyncHooks = __require("async_hooks");
+    var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager();
+    var AsyncHooksContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager {
+      constructor() {
+        super();
+        __publicField(this, "_asyncHook");
+        __publicField(this, "_contexts", /* @__PURE__ */ new Map());
+        __publicField(this, "_stack", []);
+        this._asyncHook = asyncHooks.createHook({
+          init: this._init.bind(this),
+          before: this._before.bind(this),
+          after: this._after.bind(this),
+          destroy: this._destroy.bind(this),
+          promiseResolve: this._destroy.bind(this)
+        });
+      }
+      active() {
+        var _a;
+        return (_a = this._stack[this._stack.length - 1]) != null ? _a : api_1.ROOT_CONTEXT;
+      }
+      with(context4, fn, thisArg, ...args) {
+        this._enterContext(context4);
+        try {
+          return fn.call(thisArg, ...args);
+        } finally {
+          this._exitContext();
+        }
+      }
+      enable() {
+        this._asyncHook.enable();
+        return this;
+      }
+      disable() {
+        this._asyncHook.disable();
+        this._contexts.clear();
+        this._stack = [];
+        return this;
+      }
+      /**
+       * Init hook will be called when userland create a async context, setting the
+       * context as the current one if it exist.
+       * @param uid id of the async context
+       * @param type the resource type
+       */
+      _init(uid, type) {
+        if (type === "TIMERWRAP")
+          return;
+        const context4 = this._stack[this._stack.length - 1];
+        if (context4 !== void 0) {
+          this._contexts.set(uid, context4);
+        }
+      }
+      /**
+       * Destroy hook will be called when a given context is no longer used so we can
+       * remove its attached context.
+       * @param uid uid of the async context
+       */
+      _destroy(uid) {
+        this._contexts.delete(uid);
+      }
+      /**
+       * Before hook is called just before executing a async context.
+       * @param uid uid of the async context
+       */
+      _before(uid) {
+        const context4 = this._contexts.get(uid);
+        if (context4 !== void 0) {
+          this._enterContext(context4);
+        }
+      }
+      /**
+       * After hook is called just after completing the execution of a async context.
+       */
+      _after() {
+        this._exitContext();
+      }
+      /**
+       * Set the given context as active
+       */
+      _enterContext(context4) {
+        this._stack.push(context4);
+      }
+      /**
+       * Remove the context at the root of the stack
+       */
+      _exitContext() {
+        this._stack.pop();
+      }
+    };
+    exports.AsyncHooksContextManager = AsyncHooksContextManager;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js
+var require_AsyncLocalStorageContextManager = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncLocalStorageContextManager = void 0;
+    var api_1 = __require("@opentelemetry/api");
+    var async_hooks_1 = __require("async_hooks");
+    var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager();
+    var AsyncLocalStorageContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager {
+      constructor() {
+        super();
+        __publicField(this, "_asyncLocalStorage");
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+      }
+      active() {
+        var _a;
+        return (_a = this._asyncLocalStorage.getStore()) != null ? _a : api_1.ROOT_CONTEXT;
+      }
+      with(context4, fn, thisArg, ...args) {
+        const cb = thisArg == null ? fn : fn.bind(thisArg);
+        return this._asyncLocalStorage.run(context4, cb, ...args);
+      }
+      enable() {
+        return this;
+      }
+      disable() {
+        this._asyncLocalStorage.disable();
+        return this;
+      }
+    };
+    exports.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/context-async-hooks/build/src/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncLocalStorageContextManager = exports.AsyncHooksContextManager = void 0;
+    var AsyncHooksContextManager_1 = require_AsyncHooksContextManager();
+    Object.defineProperty(exports, "AsyncHooksContextManager", { enumerable: true, get: function() {
+      return AsyncHooksContextManager_1.AsyncHooksContextManager;
+    } });
+    var AsyncLocalStorageContextManager_1 = require_AsyncLocalStorageContextManager();
+    Object.defineProperty(exports, "AsyncLocalStorageContextManager", { enumerable: true, get: function() {
+      return AsyncLocalStorageContextManager_1.AsyncLocalStorageContextManager;
+    } });
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+import { createContextKey } from "@opentelemetry/api";
+function suppressTracing(context4) {
+  return context4.setValue(SUPPRESS_TRACING_KEY, true);
+}
+function unsuppressTracing(context4) {
+  return context4.deleteValue(SUPPRESS_TRACING_KEY);
+}
+function isTracingSuppressed(context4) {
+  return context4.getValue(SUPPRESS_TRACING_KEY) === true;
+}
+var SUPPRESS_TRACING_KEY;
+var init_suppress_tracing = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js"() {
+    "use strict";
+    SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR, BAGGAGE_PROPERTIES_SEPARATOR, BAGGAGE_ITEMS_SEPARATOR, BAGGAGE_HEADER, BAGGAGE_MAX_NAME_VALUE_PAIRS, BAGGAGE_MAX_PER_NAME_VALUE_PAIRS, BAGGAGE_MAX_TOTAL_LENGTH;
+var init_constants = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/constants.js"() {
+    "use strict";
+    BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+    BAGGAGE_PROPERTIES_SEPARATOR = ";";
+    BAGGAGE_ITEMS_SEPARATOR = ",";
+    BAGGAGE_HEADER = "baggage";
+    BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
+    BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
+    BAGGAGE_MAX_TOTAL_LENGTH = 8192;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+import { baggageEntryMetadataFromString } from "@opentelemetry/api";
+function serializeKeyPairs(keyPairs) {
+  return keyPairs.reduce((hValue, current) => {
+    const value = `${hValue}${hValue !== "" ? BAGGAGE_ITEMS_SEPARATOR : ""}${current}`;
+    return value.length > BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value;
+  }, "");
+}
+function getKeyPairs(baggage) {
+  return baggage.getAllEntries().map(([key, value]) => {
+    let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`;
+    if (value.metadata !== void 0) {
+      entry += BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString();
+    }
+    return entry;
+  });
+}
+function parsePairKeyValue(entry) {
+  const valueProps = entry.split(BAGGAGE_PROPERTIES_SEPARATOR);
+  if (valueProps.length <= 0)
+    return;
+  const keyPairPart = valueProps.shift();
+  if (!keyPairPart)
+    return;
+  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
+  if (separatorIndex <= 0)
+    return;
+  const key = decodeURIComponent(keyPairPart.substring(0, separatorIndex).trim());
+  const value = decodeURIComponent(keyPairPart.substring(separatorIndex + 1).trim());
+  let metadata;
+  if (valueProps.length > 0) {
+    metadata = baggageEntryMetadataFromString(valueProps.join(BAGGAGE_PROPERTIES_SEPARATOR));
+  }
+  return { key, value, metadata };
+}
+function parseKeyPairsIntoRecord(value) {
+  const result = {};
+  if (typeof value === "string" && value.length > 0) {
+    value.split(BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
+      const keyPair = parsePairKeyValue(entry);
+      if (keyPair !== void 0 && keyPair.value.length > 0) {
+        result[keyPair.key] = keyPair.value;
+      }
+    });
+  }
+  return result;
+}
+var init_utils = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/utils.js"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+import { propagation } from "@opentelemetry/api";
+var W3CBaggagePropagator;
+var init_W3CBaggagePropagator = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js"() {
+    "use strict";
+    init_suppress_tracing();
+    init_constants();
+    init_utils();
+    W3CBaggagePropagator = class {
+      inject(context4, carrier, setter) {
+        const baggage = propagation.getBaggage(context4);
+        if (!baggage || isTracingSuppressed(context4))
+          return;
+        const keyPairs = getKeyPairs(baggage).filter((pair) => {
+          return pair.length <= BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
+        }).slice(0, BAGGAGE_MAX_NAME_VALUE_PAIRS);
+        const headerValue = serializeKeyPairs(keyPairs);
+        if (headerValue.length > 0) {
+          setter.set(carrier, BAGGAGE_HEADER, headerValue);
+        }
+      }
+      extract(context4, carrier, getter) {
+        const headerValue = getter.get(carrier, BAGGAGE_HEADER);
+        const baggageString = Array.isArray(headerValue) ? headerValue.join(BAGGAGE_ITEMS_SEPARATOR) : headerValue;
+        if (!baggageString)
+          return context4;
+        const baggage = {};
+        if (baggageString.length === 0) {
+          return context4;
+        }
+        const pairs = baggageString.split(BAGGAGE_ITEMS_SEPARATOR);
+        pairs.forEach((entry) => {
+          const keyPair = parsePairKeyValue(entry);
+          if (keyPair) {
+            const baggageEntry = { value: keyPair.value };
+            if (keyPair.metadata) {
+              baggageEntry.metadata = keyPair.metadata;
+            }
+            baggage[keyPair.key] = baggageEntry;
+          }
+        });
+        if (Object.entries(baggage).length === 0) {
+          return context4;
+        }
+        return propagation.setBaggage(context4, propagation.createBaggage(baggage));
+      }
+      fields() {
+        return [BAGGAGE_HEADER];
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js
+var AnchoredClock;
+var init_anchored_clock = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js"() {
+    "use strict";
+    AnchoredClock = class {
+      /**
+       * Create a new AnchoredClock anchored to the current time returned by systemClock.
+       *
+       * @param systemClock should be a clock that returns the number of milliseconds since January 1 1970 such as Date
+       * @param monotonicClock should be a clock that counts milliseconds monotonically such as window.performance or perf_hooks.performance
+       */
+      constructor(systemClock, monotonicClock) {
+        __publicField(this, "_monotonicClock");
+        __publicField(this, "_epochMillis");
+        __publicField(this, "_performanceMillis");
+        this._monotonicClock = monotonicClock;
+        this._epochMillis = systemClock.now();
+        this._performanceMillis = monotonicClock.now();
+      }
+      /**
+       * Returns the current time by adding the number of milliseconds since the
+       * AnchoredClock was created to the creation epoch time
+       */
+      now() {
+        const delta = this._monotonicClock.now() - this._performanceMillis;
+        return this._epochMillis + delta;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/attributes.js
+import { diag } from "@opentelemetry/api";
+function sanitizeAttributes(attributes) {
+  const out = {};
+  if (typeof attributes !== "object" || attributes == null) {
+    return out;
+  }
+  for (const [key, val] of Object.entries(attributes)) {
+    if (!isAttributeKey(key)) {
+      diag.warn(`Invalid attribute key: ${key}`);
+      continue;
+    }
+    if (!isAttributeValue(val)) {
+      diag.warn(`Invalid attribute value set for key: ${key}`);
+      continue;
+    }
+    if (Array.isArray(val)) {
+      out[key] = val.slice();
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key.length > 0;
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValue(val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    if (!type) {
+      if (isValidPrimitiveAttributeValue(element)) {
+        type = typeof element;
+        continue;
+      }
+      return false;
+    }
+    if (typeof element === type) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValue(val) {
+  switch (typeof val) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+var init_attributes = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/attributes.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+import { diag as diag2 } from "@opentelemetry/api";
+function loggingErrorHandler() {
+  return (ex) => {
+    diag2.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+var init_logging_error_handler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+function setGlobalErrorHandler(handler) {
+  delegateHandler = handler;
+}
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch (e) {
+  }
+}
+var delegateHandler;
+var init_global_error_handler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js"() {
+    "use strict";
+    init_logging_error_handler();
+    delegateHandler = loggingErrorHandler();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+import { diag as diag3 } from "@opentelemetry/api";
+import { inspect } from "util";
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    diag3.warn(`Unknown value ${inspect(raw)} for ${key}, expected a number, using defaults`);
+    return void 0;
+  }
+  return value;
+}
+function getStringFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  return raw;
+}
+function getBooleanFromEnv(key) {
+  var _a;
+  const raw = (_a = process.env[key]) == null ? void 0 : _a.trim().toLowerCase();
+  if (raw == null || raw === "") {
+    return false;
+  }
+  if (raw === "true") {
+    return true;
+  } else if (raw === "false") {
+    return false;
+  } else {
+    diag3.warn(`Unknown value ${inspect(raw)} for ${key}, expected 'true' or 'false', falling back to 'false' (default)`);
+    return false;
+  }
+}
+function getStringListFromEnv(key) {
+  var _a;
+  return (_a = getStringFromEnv(key)) == null ? void 0 : _a.split(",").map((v) => v.trim()).filter((s) => s !== "");
+}
+var init_environment = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/globalThis.js"() {
+    "use strict";
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/performance.js
+import { performance } from "perf_hooks";
+var otperformance;
+var init_performance = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/performance.js"() {
+    "use strict";
+    otperformance = performance;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/version.js"() {
+    "use strict";
+    VERSION = "2.0.1";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js
+var init_SemanticAttributes = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js
+var init_trace = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js"() {
+    "use strict";
+    init_SemanticAttributes();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+var init_SemanticResourceAttributes = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js
+var init_resource = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js"() {
+    "use strict";
+    init_SemanticResourceAttributes();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var ATTR_EXCEPTION_MESSAGE, ATTR_EXCEPTION_STACKTRACE, ATTR_EXCEPTION_TYPE, ATTR_TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION;
+var init_stable_attributes = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js"() {
+    "use strict";
+    ATTR_EXCEPTION_MESSAGE = "exception.message";
+    ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+    ATTR_EXCEPTION_TYPE = "exception.type";
+    ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+    TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
+    ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+    ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js
+var init_stable_metrics = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/index.js
+var init_esm = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/semantic-conventions/build/esm/index.js"() {
+    "use strict";
+    init_trace();
+    init_resource();
+    init_stable_attributes();
+    init_stable_metrics();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME;
+var init_semconv = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/semconv.js"() {
+    "use strict";
+    ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var SDK_INFO;
+var init_sdk_info = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js"() {
+    "use strict";
+    init_version();
+    init_esm();
+    init_semconv();
+    SDK_INFO = {
+      [ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+      [ATTR_PROCESS_RUNTIME_NAME]: "node",
+      [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+      [ATTR_TELEMETRY_SDK_VERSION]: VERSION
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js
+function unrefTimer(timer) {
+  timer.unref();
+}
+var init_timer_util = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var init_node = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_environment();
+    init_globalThis();
+    init_performance();
+    init_sdk_info();
+    init_timer_util();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/time.js
+function millisToHrTime(epochMillis) {
+  const epochSeconds = epochMillis / 1e3;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
+  return [seconds, nanos];
+}
+function getTimeOrigin() {
+  let timeOrigin = otperformance.timeOrigin;
+  if (typeof timeOrigin !== "number") {
+    const perf = otperformance;
+    timeOrigin = perf.timing && perf.timing.fetchStart;
+  }
+  return timeOrigin;
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(getTimeOrigin());
+  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now);
+}
+function timeInputToHrTime(time) {
+  if (isTimeInputHrTime(time)) {
+    return time;
+  } else if (typeof time === "number") {
+    if (time < getTimeOrigin()) {
+      return hrTime(time);
+    } else {
+      return millisToHrTime(time);
+    }
+  } else if (time instanceof Date) {
+    return millisToHrTime(time.getTime());
+  } else {
+    throw TypeError("Invalid input type");
+  }
+}
+function hrTimeDuration(startTime, endTime) {
+  let seconds = endTime[0] - startTime[0];
+  let nanos = endTime[1] - startTime[1];
+  if (nanos < 0) {
+    seconds -= 1;
+    nanos += SECOND_TO_NANOSECONDS;
+  }
+  return [seconds, nanos];
+}
+function hrTimeToTimeStamp(time) {
+  const precision = NANOSECOND_DIGITS;
+  const tmp = `${"0".repeat(precision)}${time[1]}Z`;
+  const nanoString = tmp.substring(tmp.length - precision - 1);
+  const date = new Date(time[0] * 1e3).toISOString();
+  return date.replace("000Z", nanoString);
+}
+function hrTimeToNanoseconds(time) {
+  return time[0] * SECOND_TO_NANOSECONDS + time[1];
+}
+function hrTimeToMilliseconds(time) {
+  return time[0] * 1e3 + time[1] / 1e6;
+}
+function hrTimeToMicroseconds(time) {
+  return time[0] * 1e6 + time[1] / 1e3;
+}
+function isTimeInputHrTime(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isTimeInput(value) {
+  return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
+}
+function addHrTimes(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS) {
+    out[1] -= SECOND_TO_NANOSECONDS;
+    out[0] += 1;
+  }
+  return out;
+}
+var NANOSECOND_DIGITS, NANOSECOND_DIGITS_IN_MILLIS, MILLISECONDS_TO_NANOSECONDS, SECOND_TO_NANOSECONDS;
+var init_time = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/common/time.js"() {
+    "use strict";
+    init_platform();
+    NANOSECOND_DIGITS = 9;
+    NANOSECOND_DIGITS_IN_MILLIS = 6;
+    MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+    SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    (function(ExportResultCode2) {
+      ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode || (ExportResultCode = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/propagation/composite.js
+import { diag as diag4 } from "@opentelemetry/api";
+var CompositePropagator;
+var init_composite = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/propagation/composite.js"() {
+    "use strict";
+    CompositePropagator = class {
+      /**
+       * Construct a composite propagator from a list of propagators.
+       *
+       * @param [config] Configuration object for composite propagator
+       */
+      constructor(config = {}) {
+        __publicField(this, "_propagators");
+        __publicField(this, "_fields");
+        var _a;
+        this._propagators = (_a = config.propagators) != null ? _a : [];
+        this._fields = Array.from(new Set(this._propagators.map((p) => typeof p.fields === "function" ? p.fields() : []).reduce((x, y) => x.concat(y), [])));
+      }
+      /**
+       * Run each of the configured propagators with the given context and carrier.
+       * Propagators are run in the order they are configured, so if multiple
+       * propagators write the same carrier key, the propagator later in the list
+       * will "win".
+       *
+       * @param context Context to inject
+       * @param carrier Carrier into which context will be injected
+       */
+      inject(context4, carrier, setter) {
+        for (const propagator of this._propagators) {
+          try {
+            propagator.inject(context4, carrier, setter);
+          } catch (err) {
+            diag4.warn(`Failed to inject with ${propagator.constructor.name}. Err: ${err.message}`);
+          }
+        }
+      }
+      /**
+       * Run each of the configured propagators with the given context and carrier.
+       * Propagators are run in the order they are configured, so if multiple
+       * propagators write the same context key, the propagator later in the list
+       * will "win".
+       *
+       * @param context Context to add values to
+       * @param carrier Carrier from which to extract context
+       */
+      extract(context4, carrier, getter) {
+        return this._propagators.reduce((ctx, propagator) => {
+          try {
+            return propagator.extract(ctx, carrier, getter);
+          } catch (err) {
+            diag4.warn(`Failed to extract with ${propagator.constructor.name}. Err: ${err.message}`);
+          }
+          return ctx;
+        }, context4);
+      }
+      fields() {
+        return this._fields.slice();
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/internal/validators.js
+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);
+}
+var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
+var init_validators = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/internal/validators.js"() {
+    "use strict";
+    VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+    VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+    VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+    VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+    VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceState;
+var init_TraceState = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js"() {
+    "use strict";
+    init_validators();
+    MAX_TRACE_STATE_ITEMS = 32;
+    MAX_TRACE_STATE_LEN = 512;
+    LIST_MEMBERS_SEPARATOR = ",";
+    LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+    TraceState = class _TraceState {
+      constructor(rawTraceState) {
+        __publicField(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 this._keys().reduce((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).reverse().reduce((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);
+            } else {
+            }
+          }
+          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));
+        }
+      }
+      _keys() {
+        return Array.from(this._internalState.keys()).reverse();
+      }
+      _clone() {
+        const traceState = new _TraceState();
+        traceState._internalState = new Map(this._internalState);
+        return traceState;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js
+import { isSpanContextValid, trace, TraceFlags as TraceFlags2 } from "@opentelemetry/api";
+function parseTraceParent(traceParent) {
+  const match = TRACE_PARENT_REGEX.exec(traceParent);
+  if (!match)
+    return null;
+  if (match[1] === "00" && match[5])
+    return null;
+  return {
+    traceId: match[2],
+    spanId: match[3],
+    traceFlags: parseInt(match[4], 16)
+  };
+}
+var TRACE_PARENT_HEADER, TRACE_STATE_HEADER, VERSION2, VERSION_PART, TRACE_ID_PART, PARENT_ID_PART, FLAGS_PART, TRACE_PARENT_REGEX, W3CTraceContextPropagator;
+var init_W3CTraceContextPropagator = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js"() {
+    "use strict";
+    init_suppress_tracing();
+    init_TraceState();
+    TRACE_PARENT_HEADER = "traceparent";
+    TRACE_STATE_HEADER = "tracestate";
+    VERSION2 = "00";
+    VERSION_PART = "(?!ff)[\\da-f]{2}";
+    TRACE_ID_PART = "(?![0]{32})[\\da-f]{32}";
+    PARENT_ID_PART = "(?![0]{16})[\\da-f]{16}";
+    FLAGS_PART = "[\\da-f]{2}";
+    TRACE_PARENT_REGEX = new RegExp(`^\\s?(${VERSION_PART})-(${TRACE_ID_PART})-(${PARENT_ID_PART})-(${FLAGS_PART})(-.*)?\\s?$`);
+    W3CTraceContextPropagator = class {
+      inject(context4, carrier, setter) {
+        const spanContext = trace.getSpanContext(context4);
+        if (!spanContext || isTracingSuppressed(context4) || !isSpanContextValid(spanContext))
+          return;
+        const traceParent = `${VERSION2}-${spanContext.traceId}-${spanContext.spanId}-0${Number(spanContext.traceFlags || TraceFlags2.NONE).toString(16)}`;
+        setter.set(carrier, TRACE_PARENT_HEADER, traceParent);
+        if (spanContext.traceState) {
+          setter.set(carrier, TRACE_STATE_HEADER, spanContext.traceState.serialize());
+        }
+      }
+      extract(context4, carrier, getter) {
+        const traceParentHeader = getter.get(carrier, TRACE_PARENT_HEADER);
+        if (!traceParentHeader)
+          return context4;
+        const traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader;
+        if (typeof traceParent !== "string")
+          return context4;
+        const spanContext = parseTraceParent(traceParent);
+        if (!spanContext)
+          return context4;
+        spanContext.isRemote = true;
+        const traceStateHeader = getter.get(carrier, TRACE_STATE_HEADER);
+        if (traceStateHeader) {
+          const state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader;
+          spanContext.traceState = new TraceState(typeof state === "string" ? state : void 0);
+        }
+        return trace.setSpanContext(context4, spanContext);
+      }
+      fields() {
+        return [TRACE_PARENT_HEADER, TRACE_STATE_HEADER];
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js
+import { createContextKey as createContextKey2 } from "@opentelemetry/api";
+function setRPCMetadata(context4, meta) {
+  return context4.setValue(RPC_METADATA_KEY, meta);
+}
+function deleteRPCMetadata(context4) {
+  return context4.deleteValue(RPC_METADATA_KEY);
+}
+function getRPCMetadata(context4) {
+  return context4.getValue(RPC_METADATA_KEY);
+}
+var RPC_METADATA_KEY, RPCType;
+var init_rpc_metadata = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js"() {
+    "use strict";
+    RPC_METADATA_KEY = createContextKey2("OpenTelemetry SDK Context Key RPC_METADATA");
+    (function(RPCType2) {
+      RPCType2["HTTP"] = "http";
+    })(RPCType || (RPCType = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
+    return false;
+  }
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function getRawTag(value) {
+  const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  let unmasked = false;
+  try {
+    value[symToStringTag] = void 0;
+    unmasked = true;
+  } catch (e) {
+  }
+  const result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var objectTag, nullTag, undefinedTag, funcProto, funcToString, objectCtorString, getPrototypeOf, objectProto, hasOwnProperty, symToStringTag, nativeObjectToString;
+var init_lodash_merge = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js"() {
+    "use strict";
+    objectTag = "[object Object]";
+    nullTag = "[object Null]";
+    undefinedTag = "[object Undefined]";
+    funcProto = Function.prototype;
+    funcToString = funcProto.toString;
+    objectCtorString = funcToString.call(Object);
+    getPrototypeOf = Object.getPrototypeOf;
+    objectProto = Object.prototype;
+    hasOwnProperty = objectProto.hasOwnProperty;
+    symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    nativeObjectToString = objectProto.toString;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+function merge(...args) {
+  let result = args.shift();
+  const objects = /* @__PURE__ */ new WeakMap();
+  while (args.length > 0) {
+    result = mergeTwoObjects(result, args.shift(), 0, objects);
+  }
+  return result;
+}
+function takeValue(value) {
+  if (isArray(value)) {
+    return value.slice();
+  }
+  return value;
+}
+function mergeTwoObjects(one, two, level = 0, objects) {
+  let result;
+  if (level > MAX_LEVEL) {
+    return void 0;
+  }
+  level++;
+  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
+    result = takeValue(two);
+  } else if (isArray(one)) {
+    result = one.slice();
+    if (isArray(two)) {
+      for (let i = 0, j = two.length; i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject(two)) {
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        result[key] = takeValue(two[key]);
+      }
+    }
+  } else if (isObject(one)) {
+    if (isObject(two)) {
+      if (!shouldMerge(one, two)) {
+        return two;
+      }
+      result = Object.assign({}, one);
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        const twoValue = two[key];
+        if (isPrimitive(twoValue)) {
+          if (typeof twoValue === "undefined") {
+            delete result[key];
+          } else {
+            result[key] = twoValue;
+          }
+        } else {
+          const obj1 = result[key];
+          const obj2 = twoValue;
+          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
+            delete result[key];
+          } else {
+            if (isObject(obj1) && isObject(obj2)) {
+              const arr1 = objects.get(obj1) || [];
+              const arr2 = objects.get(obj2) || [];
+              arr1.push({ obj: one, key });
+              arr2.push({ obj: two, key });
+              objects.set(obj1, arr1);
+              objects.set(obj2, arr2);
+            }
+            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+          }
+        }
+      }
+    } else {
+      result = two;
+    }
+  }
+  return result;
+}
+function wasObjectReferenced(obj, key, objects) {
+  const arr = objects.get(obj[key]) || [];
+  for (let i = 0, j = arr.length; i < j; i++) {
+    const info = arr[i];
+    if (info.key === key && info.obj === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+  if (!isPlainObject(one) || !isPlainObject(two)) {
+    return false;
+  }
+  return true;
+}
+var MAX_LEVEL;
+var init_merge = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/merge.js"() {
+    "use strict";
+    init_lodash_merge();
+    MAX_LEVEL = 20;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/timeout.js
+function callWithTimeout(promise, timeout) {
+  let timeoutHandle;
+  const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+    timeoutHandle = setTimeout(function timeoutHandler() {
+      reject(new TimeoutError("Operation timed out."));
+    }, timeout);
+  });
+  return Promise.race([promise, timeoutPromise]).then((result) => {
+    clearTimeout(timeoutHandle);
+    return result;
+  }, (reason) => {
+    clearTimeout(timeoutHandle);
+    throw reason;
+  });
+}
+var TimeoutError;
+var init_timeout = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/timeout.js"() {
+    "use strict";
+    TimeoutError = class _TimeoutError extends Error {
+      constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, _TimeoutError.prototype);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/url.js
+function urlMatches(url, urlToMatch) {
+  if (typeof urlToMatch === "string") {
+    return url === urlToMatch;
+  } else {
+    return !!url.match(urlToMatch);
+  }
+}
+function isUrlIgnored(url, ignoredUrls) {
+  if (!ignoredUrls) {
+    return false;
+  }
+  for (const ignoreUrl of ignoredUrls) {
+    if (urlMatches(url, ignoreUrl)) {
+      return true;
+    }
+  }
+  return false;
+}
+var init_url = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/url.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred;
+var init_promise = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/promise.js"() {
+    "use strict";
+    Deferred = class {
+      constructor() {
+        __publicField(this, "_promise");
+        __publicField(this, "_resolve");
+        __publicField(this, "_reject");
+        this._promise = new Promise((resolve, reject) => {
+          this._resolve = resolve;
+          this._reject = reject;
+        });
+      }
+      get promise() {
+        return this._promise;
+      }
+      resolve(val) {
+        this._resolve(val);
+      }
+      reject(err) {
+        this._reject(err);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture;
+var init_callback = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/callback.js"() {
+    "use strict";
+    init_promise();
+    BindOnceFuture = class {
+      constructor(_callback, _that) {
+        __publicField(this, "_callback");
+        __publicField(this, "_that");
+        __publicField(this, "_isCalled", false);
+        __publicField(this, "_deferred", new Deferred());
+        this._callback = _callback;
+        this._that = _that;
+      }
+      get isCalled() {
+        return this._isCalled;
+      }
+      get promise() {
+        return this._deferred.promise;
+      }
+      call(...args) {
+        if (!this._isCalled) {
+          this._isCalled = true;
+          try {
+            Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+          } catch (err) {
+            this._deferred.reject(err);
+          }
+        }
+        return this._deferred.promise;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/configuration.js
+import { diag as diag5, DiagLogLevel } from "@opentelemetry/api";
+function diagLogLevelFromString(value) {
+  if (value == null) {
+    return void 0;
+  }
+  const resolvedLogLevel = logLevelMap[value.toUpperCase()];
+  if (resolvedLogLevel == null) {
+    diag5.warn(`Unknown log level "${value}", expected one of ${Object.keys(logLevelMap)}, using default`);
+    return DiagLogLevel.INFO;
+  }
+  return resolvedLogLevel;
+}
+var logLevelMap;
+var init_configuration = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/utils/configuration.js"() {
+    "use strict";
+    logLevelMap = {
+      ALL: DiagLogLevel.ALL,
+      VERBOSE: DiagLogLevel.VERBOSE,
+      DEBUG: DiagLogLevel.DEBUG,
+      INFO: DiagLogLevel.INFO,
+      WARN: DiagLogLevel.WARN,
+      ERROR: DiagLogLevel.ERROR,
+      NONE: DiagLogLevel.NONE
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+import { context } from "@opentelemetry/api";
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    context.with(suppressTracing(context.active()), () => {
+      exporter.export(arg, (result) => {
+        resolve(result);
+      });
+    });
+  });
+}
+var init_exporter = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/internal/exporter.js"() {
+    "use strict";
+    init_suppress_tracing();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  AnchoredClock: () => AnchoredClock,
+  BindOnceFuture: () => BindOnceFuture,
+  CompositePropagator: () => CompositePropagator,
+  ExportResultCode: () => ExportResultCode,
+  RPCType: () => RPCType,
+  SDK_INFO: () => SDK_INFO,
+  TRACE_PARENT_HEADER: () => TRACE_PARENT_HEADER,
+  TRACE_STATE_HEADER: () => TRACE_STATE_HEADER,
+  TimeoutError: () => TimeoutError,
+  TraceState: () => TraceState,
+  W3CBaggagePropagator: () => W3CBaggagePropagator,
+  W3CTraceContextPropagator: () => W3CTraceContextPropagator,
+  _globalThis: () => _globalThis,
+  addHrTimes: () => addHrTimes,
+  callWithTimeout: () => callWithTimeout,
+  deleteRPCMetadata: () => deleteRPCMetadata,
+  diagLogLevelFromString: () => diagLogLevelFromString,
+  getBooleanFromEnv: () => getBooleanFromEnv,
+  getNumberFromEnv: () => getNumberFromEnv,
+  getRPCMetadata: () => getRPCMetadata,
+  getStringFromEnv: () => getStringFromEnv,
+  getStringListFromEnv: () => getStringListFromEnv,
+  getTimeOrigin: () => getTimeOrigin,
+  globalErrorHandler: () => globalErrorHandler,
+  hrTime: () => hrTime,
+  hrTimeDuration: () => hrTimeDuration,
+  hrTimeToMicroseconds: () => hrTimeToMicroseconds,
+  hrTimeToMilliseconds: () => hrTimeToMilliseconds,
+  hrTimeToNanoseconds: () => hrTimeToNanoseconds,
+  hrTimeToTimeStamp: () => hrTimeToTimeStamp,
+  internal: () => internal,
+  isAttributeValue: () => isAttributeValue,
+  isTimeInput: () => isTimeInput,
+  isTimeInputHrTime: () => isTimeInputHrTime,
+  isTracingSuppressed: () => isTracingSuppressed,
+  isUrlIgnored: () => isUrlIgnored,
+  loggingErrorHandler: () => loggingErrorHandler,
+  merge: () => merge,
+  millisToHrTime: () => millisToHrTime,
+  otperformance: () => otperformance,
+  parseKeyPairsIntoRecord: () => parseKeyPairsIntoRecord,
+  parseTraceParent: () => parseTraceParent,
+  sanitizeAttributes: () => sanitizeAttributes,
+  setGlobalErrorHandler: () => setGlobalErrorHandler,
+  setRPCMetadata: () => setRPCMetadata,
+  suppressTracing: () => suppressTracing,
+  timeInputToHrTime: () => timeInputToHrTime,
+  unrefTimer: () => unrefTimer,
+  unsuppressTracing: () => unsuppressTracing,
+  urlMatches: () => urlMatches
+});
+var internal;
+var init_esm2 = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/core/build/esm/index.js"() {
+    "use strict";
+    init_W3CBaggagePropagator();
+    init_anchored_clock();
+    init_attributes();
+    init_global_error_handler();
+    init_logging_error_handler();
+    init_time();
+    init_ExportResult();
+    init_utils();
+    init_platform();
+    init_composite();
+    init_W3CTraceContextPropagator();
+    init_rpc_metadata();
+    init_suppress_tracing();
+    init_TraceState();
+    init_merge();
+    init_timeout();
+    init_url();
+    init_callback();
+    init_configuration();
+    init_exporter();
+    internal = {
+      _export
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
+var ExceptionEventName;
+var init_enums = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js"() {
+    "use strict";
+    ExceptionEventName = "exception";
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
+import { diag as diag6, SpanStatusCode } from "@opentelemetry/api";
+var SpanImpl;
+var init_Span = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js"() {
+    "use strict";
+    init_esm2();
+    init_esm();
+    init_enums();
+    SpanImpl = class {
+      /**
+       * Constructs a new SpanImpl instance.
+       */
+      constructor(opts) {
+        // Below properties are included to implement ReadableSpan for export
+        // purposes but are not intended to be written-to directly.
+        __publicField(this, "_spanContext");
+        __publicField(this, "kind");
+        __publicField(this, "parentSpanContext");
+        __publicField(this, "attributes", {});
+        __publicField(this, "links", []);
+        __publicField(this, "events", []);
+        __publicField(this, "startTime");
+        __publicField(this, "resource");
+        __publicField(this, "instrumentationScope");
+        __publicField(this, "_droppedAttributesCount", 0);
+        __publicField(this, "_droppedEventsCount", 0);
+        __publicField(this, "_droppedLinksCount", 0);
+        __publicField(this, "name");
+        __publicField(this, "status", {
+          code: SpanStatusCode.UNSET
+        });
+        __publicField(this, "endTime", [0, 0]);
+        __publicField(this, "_ended", false);
+        __publicField(this, "_duration", [-1, -1]);
+        __publicField(this, "_spanProcessor");
+        __publicField(this, "_spanLimits");
+        __publicField(this, "_attributeValueLengthLimit");
+        __publicField(this, "_performanceStartTime");
+        __publicField(this, "_performanceOffset");
+        __publicField(this, "_startTimeProvided");
+        var _a;
+        const now = Date.now();
+        this._spanContext = opts.spanContext;
+        this._performanceStartTime = otperformance.now();
+        this._performanceOffset = now - (this._performanceStartTime + getTimeOrigin());
+        this._startTimeProvided = opts.startTime != null;
+        this._spanLimits = opts.spanLimits;
+        this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit || 0;
+        this._spanProcessor = opts.spanProcessor;
+        this.name = opts.name;
+        this.parentSpanContext = opts.parentSpanContext;
+        this.kind = opts.kind;
+        this.links = opts.links || [];
+        this.startTime = this._getTime((_a = opts.startTime) != null ? _a : now);
+        this.resource = opts.resource;
+        this.instrumentationScope = opts.scope;
+        if (opts.attributes != null) {
+          this.setAttributes(opts.attributes);
+        }
+        this._spanProcessor.onStart(this, opts.context);
+      }
+      spanContext() {
+        return this._spanContext;
+      }
+      setAttribute(key, value) {
+        if (value == null || this._isSpanEnded())
+          return this;
+        if (key.length === 0) {
+          diag6.warn(`Invalid attribute key: ${key}`);
+          return this;
+        }
+        if (!isAttributeValue(value)) {
+          diag6.warn(`Invalid attribute value set for key: ${key}`);
+          return this;
+        }
+        const { attributeCountLimit } = this._spanLimits;
+        if (attributeCountLimit !== void 0 && Object.keys(this.attributes).length >= attributeCountLimit && !Object.prototype.hasOwnProperty.call(this.attributes, key)) {
+          this._droppedAttributesCount++;
+          return this;
+        }
+        this.attributes[key] = this._truncateToSize(value);
+        return this;
+      }
+      setAttributes(attributes) {
+        for (const [k, v] of Object.entries(attributes)) {
+          this.setAttribute(k, v);
+        }
+        return this;
+      }
+      /**
+       *
+       * @param name Span Name
+       * @param [attributesOrStartTime] Span attributes or start time
+       *     if type is {@type TimeInput} and 3rd param is undefined
+       * @param [timeStamp] Specified time stamp for the event
+       */
+      addEvent(name, attributesOrStartTime, timeStamp) {
+        if (this._isSpanEnded())
+          return this;
+        const { eventCountLimit } = this._spanLimits;
+        if (eventCountLimit === 0) {
+          diag6.warn("No events allowed.");
+          this._droppedEventsCount++;
+          return this;
+        }
+        if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
+          if (this._droppedEventsCount === 0) {
+            diag6.debug("Dropping extra events.");
+          }
+          this.events.shift();
+          this._droppedEventsCount++;
+        }
+        if (isTimeInput(attributesOrStartTime)) {
+          if (!isTimeInput(timeStamp)) {
+            timeStamp = attributesOrStartTime;
+          }
+          attributesOrStartTime = void 0;
+        }
+        const attributes = sanitizeAttributes(attributesOrStartTime);
+        this.events.push({
+          name,
+          attributes,
+          time: this._getTime(timeStamp),
+          droppedAttributesCount: 0
+        });
+        return this;
+      }
+      addLink(link) {
+        this.links.push(link);
+        return this;
+      }
+      addLinks(links) {
+        this.links.push(...links);
+        return this;
+      }
+      setStatus(status) {
+        if (this._isSpanEnded())
+          return this;
+        this.status = { ...status };
+        if (this.status.message != null && typeof status.message !== "string") {
+          diag6.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
+          delete this.status.message;
+        }
+        return this;
+      }
+      updateName(name) {
+        if (this._isSpanEnded())
+          return this;
+        this.name = name;
+        return this;
+      }
+      end(endTime) {
+        if (this._isSpanEnded()) {
+          diag6.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+          return;
+        }
+        this._ended = true;
+        this.endTime = this._getTime(endTime);
+        this._duration = hrTimeDuration(this.startTime, this.endTime);
+        if (this._duration[0] < 0) {
+          diag6.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime);
+          this.endTime = this.startTime.slice();
+          this._duration = [0, 0];
+        }
+        if (this._droppedEventsCount > 0) {
+          diag6.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
+        }
+        this._spanProcessor.onEnd(this);
+      }
+      _getTime(inp) {
+        if (typeof inp === "number" && inp <= otperformance.now()) {
+          return hrTime(inp + this._performanceOffset);
+        }
+        if (typeof inp === "number") {
+          return millisToHrTime(inp);
+        }
+        if (inp instanceof Date) {
+          return millisToHrTime(inp.getTime());
+        }
+        if (isTimeInputHrTime(inp)) {
+          return inp;
+        }
+        if (this._startTimeProvided) {
+          return millisToHrTime(Date.now());
+        }
+        const msDuration = otperformance.now() - this._performanceStartTime;
+        return addHrTimes(this.startTime, millisToHrTime(msDuration));
+      }
+      isRecording() {
+        return this._ended === false;
+      }
+      recordException(exception, time) {
+        const attributes = {};
+        if (typeof exception === "string") {
+          attributes[ATTR_EXCEPTION_MESSAGE] = exception;
+        } else if (exception) {
+          if (exception.code) {
+            attributes[ATTR_EXCEPTION_TYPE] = exception.code.toString();
+          } else if (exception.name) {
+            attributes[ATTR_EXCEPTION_TYPE] = exception.name;
+          }
+          if (exception.message) {
+            attributes[ATTR_EXCEPTION_MESSAGE] = exception.message;
+          }
+          if (exception.stack) {
+            attributes[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
+          }
+        }
+        if (attributes[ATTR_EXCEPTION_TYPE] || attributes[ATTR_EXCEPTION_MESSAGE]) {
+          this.addEvent(ExceptionEventName, attributes, time);
+        } else {
+          diag6.warn(`Failed to record an exception ${exception}`);
+        }
+      }
+      get duration() {
+        return this._duration;
+      }
+      get ended() {
+        return this._ended;
+      }
+      get droppedAttributesCount() {
+        return this._droppedAttributesCount;
+      }
+      get droppedEventsCount() {
+        return this._droppedEventsCount;
+      }
+      get droppedLinksCount() {
+        return this._droppedLinksCount;
+      }
+      _isSpanEnded() {
+        if (this._ended) {
+          const error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+          diag6.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
+        }
+        return this._ended;
+      }
+      // Utility function to truncate given value within size
+      // for value type of string, will truncate to given limit
+      // for type of non-string, will return same value
+      _truncateToLimitUtil(value, limit) {
+        if (value.length <= limit) {
+          return value;
+        }
+        return value.substring(0, limit);
+      }
+      /**
+       * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
+       * return string with truncated to {@code attributeValueLengthLimit} characters
+       *
+       * If the given attribute value is array of strings then
+       * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
+       *
+       * Otherwise return same Attribute {@code value}
+       *
+       * @param value Attribute value
+       * @returns truncated attribute value if required, otherwise same value
+       */
+      _truncateToSize(value) {
+        const limit = this._attributeValueLengthLimit;
+        if (limit <= 0) {
+          diag6.warn(`Attribute value limit must be positive, got ${limit}`);
+          return value;
+        }
+        if (typeof value === "string") {
+          return this._truncateToLimitUtil(value, limit);
+        }
+        if (Array.isArray(value)) {
+          return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
+        }
+        return value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
+var SamplingDecision;
+var init_Sampler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js"() {
+    "use strict";
+    (function(SamplingDecision3) {
+      SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD";
+      SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD";
+      SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+    })(SamplingDecision || (SamplingDecision = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
+var AlwaysOffSampler;
+var init_AlwaysOffSampler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js"() {
+    "use strict";
+    init_Sampler();
+    AlwaysOffSampler = class {
+      shouldSample() {
+        return {
+          decision: SamplingDecision.NOT_RECORD
+        };
+      }
+      toString() {
+        return "AlwaysOffSampler";
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
+var AlwaysOnSampler;
+var init_AlwaysOnSampler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js"() {
+    "use strict";
+    init_Sampler();
+    AlwaysOnSampler = class {
+      shouldSample() {
+        return {
+          decision: SamplingDecision.RECORD_AND_SAMPLED
+        };
+      }
+      toString() {
+        return "AlwaysOnSampler";
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
+import { isSpanContextValid as isSpanContextValid2, TraceFlags as TraceFlags3, trace as trace2 } from "@opentelemetry/api";
+var ParentBasedSampler;
+var init_ParentBasedSampler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js"() {
+    "use strict";
+    init_esm2();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    ParentBasedSampler = class {
+      constructor(config) {
+        __publicField(this, "_root");
+        __publicField(this, "_remoteParentSampled");
+        __publicField(this, "_remoteParentNotSampled");
+        __publicField(this, "_localParentSampled");
+        __publicField(this, "_localParentNotSampled");
+        var _a, _b, _c, _d;
+        this._root = config.root;
+        if (!this._root) {
+          globalErrorHandler(new Error("ParentBasedSampler must have a root sampler configured"));
+          this._root = new AlwaysOnSampler();
+        }
+        this._remoteParentSampled = (_a = config.remoteParentSampled) != null ? _a : new AlwaysOnSampler();
+        this._remoteParentNotSampled = (_b = config.remoteParentNotSampled) != null ? _b : new AlwaysOffSampler();
+        this._localParentSampled = (_c = config.localParentSampled) != null ? _c : new AlwaysOnSampler();
+        this._localParentNotSampled = (_d = config.localParentNotSampled) != null ? _d : new AlwaysOffSampler();
+      }
+      shouldSample(context4, traceId, spanName, spanKind, attributes, links) {
+        const parentContext = trace2.getSpanContext(context4);
+        if (!parentContext || !isSpanContextValid2(parentContext)) {
+          return this._root.shouldSample(context4, traceId, spanName, spanKind, attributes, links);
+        }
+        if (parentContext.isRemote) {
+          if (parentContext.traceFlags & TraceFlags3.SAMPLED) {
+            return this._remoteParentSampled.shouldSample(context4, traceId, spanName, spanKind, attributes, links);
+          }
+          return this._remoteParentNotSampled.shouldSample(context4, traceId, spanName, spanKind, attributes, links);
+        }
+        if (parentContext.traceFlags & TraceFlags3.SAMPLED) {
+          return this._localParentSampled.shouldSample(context4, traceId, spanName, spanKind, attributes, links);
+        }
+        return this._localParentNotSampled.shouldSample(context4, traceId, spanName, spanKind, attributes, links);
+      }
+      toString() {
+        return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
+import { isValidTraceId } from "@opentelemetry/api";
+var TraceIdRatioBasedSampler;
+var init_TraceIdRatioBasedSampler = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js"() {
+    "use strict";
+    init_Sampler();
+    TraceIdRatioBasedSampler = class {
+      constructor(_ratio = 0) {
+        __publicField(this, "_ratio");
+        __publicField(this, "_upperBound");
+        this._ratio = _ratio;
+        this._ratio = this._normalize(_ratio);
+        this._upperBound = Math.floor(this._ratio * 4294967295);
+      }
+      shouldSample(context4, traceId) {
+        return {
+          decision: isValidTraceId(traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD
+        };
+      }
+      toString() {
+        return `TraceIdRatioBased{${this._ratio}}`;
+      }
+      _normalize(ratio) {
+        if (typeof ratio !== "number" || isNaN(ratio))
+          return 0;
+        return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
+      }
+      _accumulate(traceId) {
+        let accumulation = 0;
+        for (let i = 0; i < traceId.length / 8; i++) {
+          const pos = i * 8;
+          const part = parseInt(traceId.slice(pos, pos + 8), 16);
+          accumulation = (accumulation ^ part) >>> 0;
+        }
+        return accumulation;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
+import { diag as diag7 } from "@opentelemetry/api";
+function loadDefaultConfig() {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  return {
+    sampler: buildSamplerFromEnv(),
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeValueLengthLimit: (_a = getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT")) != null ? _a : Infinity,
+      attributeCountLimit: (_b = getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT")) != null ? _b : 128
+    },
+    spanLimits: {
+      attributeValueLengthLimit: (_c = getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT")) != null ? _c : Infinity,
+      attributeCountLimit: (_d = getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT")) != null ? _d : 128,
+      linkCountLimit: (_e = getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT")) != null ? _e : 128,
+      eventCountLimit: (_f = getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT")) != null ? _f : 128,
+      attributePerEventCountLimit: (_g = getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT")) != null ? _g : 128,
+      attributePerLinkCountLimit: (_h = getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT")) != null ? _h : 128
+    }
+  };
+}
+function buildSamplerFromEnv() {
+  var _a;
+  const sampler = (_a = getStringFromEnv("OTEL_TRACES_SAMPLER")) != null ? _a : "parentbased_always_on";
+  switch (sampler) {
+    case "always_on":
+      return new AlwaysOnSampler();
+    case "always_off":
+      return new AlwaysOffSampler();
+    case "parentbased_always_on":
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+    case "parentbased_always_off":
+      return new ParentBasedSampler({
+        root: new AlwaysOffSampler()
+      });
+    case "traceidratio":
+      return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
+    case "parentbased_traceidratio":
+      return new ParentBasedSampler({
+        root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv())
+      });
+    default:
+      diag7.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${"parentbased_always_on"}".`);
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+  }
+}
+function getSamplerProbabilityFromEnv() {
+  const probability = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+  if (probability == null) {
+    diag7.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  if (probability < 0 || probability > 1) {
+    diag7.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  return probability;
+}
+var DEFAULT_RATIO;
+var init_config = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js"() {
+    "use strict";
+    init_esm2();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    DEFAULT_RATIO = 1;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js
+function mergeConfig(userConfig) {
+  const perInstanceDefaults = {
+    sampler: buildSamplerFromEnv()
+  };
+  const DEFAULT_CONFIG = loadDefaultConfig();
+  const target = Object.assign({}, DEFAULT_CONFIG, perInstanceDefaults, userConfig);
+  target.generalLimits = Object.assign({}, DEFAULT_CONFIG.generalLimits, userConfig.generalLimits || {});
+  target.spanLimits = Object.assign({}, DEFAULT_CONFIG.spanLimits, userConfig.spanLimits || {});
+  return target;
+}
+function reconfigureLimits(userConfig) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const spanLimits = Object.assign({}, userConfig.spanLimits);
+  spanLimits.attributeCountLimit = (_f = (_e = (_d = (_c = (_a = userConfig.spanLimits) == null ? void 0 : _a.attributeCountLimit) != null ? _c : (_b = userConfig.generalLimits) == null ? void 0 : _b.attributeCountLimit) != null ? _d : getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT")) != null ? _e : getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT")) != null ? _f : DEFAULT_ATTRIBUTE_COUNT_LIMIT;
+  spanLimits.attributeValueLengthLimit = (_l = (_k = (_j = (_i = (_g = userConfig.spanLimits) == null ? void 0 : _g.attributeValueLengthLimit) != null ? _i : (_h = userConfig.generalLimits) == null ? void 0 : _h.attributeValueLengthLimit) != null ? _j : getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT")) != null ? _k : getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT")) != null ? _l : DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+  return Object.assign({}, userConfig, { spanLimits });
+}
+var DEFAULT_ATTRIBUTE_COUNT_LIMIT, DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+var init_utility = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js"() {
+    "use strict";
+    init_config();
+    init_esm2();
+    DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
+    DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+import { context as context2, diag as diag8, TraceFlags as TraceFlags4 } from "@opentelemetry/api";
+var BatchSpanProcessorBase;
+var init_BatchSpanProcessorBase = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js"() {
+    "use strict";
+    init_esm2();
+    BatchSpanProcessorBase = class {
+      constructor(_exporter, config) {
+        __publicField(this, "_exporter");
+        __publicField(this, "_maxExportBatchSize");
+        __publicField(this, "_maxQueueSize");
+        __publicField(this, "_scheduledDelayMillis");
+        __publicField(this, "_exportTimeoutMillis");
+        __publicField(this, "_isExporting", false);
+        __publicField(this, "_finishedSpans", []);
+        __publicField(this, "_timer");
+        __publicField(this, "_shutdownOnce");
+        __publicField(this, "_droppedSpansCount", 0);
+        var _a, _b, _c, _d;
+        this._exporter = _exporter;
+        this._maxExportBatchSize = typeof (config == null ? void 0 : config.maxExportBatchSize) === "number" ? config.maxExportBatchSize : (_a = getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE")) != null ? _a : 512;
+        this._maxQueueSize = typeof (config == null ? void 0 : config.maxQueueSize) === "number" ? config.maxQueueSize : (_b = getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE")) != null ? _b : 2048;
+        this._scheduledDelayMillis = typeof (config == null ? void 0 : config.scheduledDelayMillis) === "number" ? config.scheduledDelayMillis : (_c = getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY")) != null ? _c : 5e3;
+        this._exportTimeoutMillis = typeof (config == null ? void 0 : config.exportTimeoutMillis) === "number" ? config.exportTimeoutMillis : (_d = getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT")) != null ? _d : 3e4;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+          diag8.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+          this._maxExportBatchSize = this._maxQueueSize;
+        }
+      }
+      forceFlush() {
+        if (this._shutdownOnce.isCalled) {
+          return this._shutdownOnce.promise;
+        }
+        return this._flushAll();
+      }
+      // does nothing.
+      onStart(_span, _parentContext) {
+      }
+      onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+          return;
+        }
+        if ((span.spanContext().traceFlags & TraceFlags4.SAMPLED) === 0) {
+          return;
+        }
+        this._addToBuffer(span);
+      }
+      shutdown() {
+        return this._shutdownOnce.call();
+      }
+      _shutdown() {
+        return Promise.resolve().then(() => {
+          return this.onShutdown();
+        }).then(() => {
+          return this._flushAll();
+        }).then(() => {
+          return this._exporter.shutdown();
+        });
+      }
+      /** Add a span in the buffer. */
+      _addToBuffer(span) {
+        if (this._finishedSpans.length >= this._maxQueueSize) {
+          if (this._droppedSpansCount === 0) {
+            diag8.debug("maxQueueSize reached, dropping spans");
+          }
+          this._droppedSpansCount++;
+          return;
+        }
+        if (this._droppedSpansCount > 0) {
+          diag8.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+          this._droppedSpansCount = 0;
+        }
+        this._finishedSpans.push(span);
+        this._maybeStartTimer();
+      }
+      /**
+       * Send all spans to the exporter respecting the batch size limit
+       * This function is used only on forceFlush or shutdown,
+       * for all other cases _flush should be used
+       * */
+      _flushAll() {
+        return new Promise((resolve, reject) => {
+          const promises = [];
+          const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+          for (let i = 0, j = count; i < j; i++) {
+            promises.push(this._flushOneBatch());
+          }
+          Promise.all(promises).then(() => {
+            resolve();
+          }).catch(reject);
+        });
+      }
+      _flushOneBatch() {
+        this._clearTimer();
+        if (this._finishedSpans.length === 0) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error("Timeout"));
+          }, this._exportTimeoutMillis);
+          context2.with(suppressTracing(context2.active()), () => {
+            let spans;
+            if (this._finishedSpans.length <= this._maxExportBatchSize) {
+              spans = this._finishedSpans;
+              this._finishedSpans = [];
+            } else {
+              spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+            }
+            const doExport = () => this._exporter.export(spans, (result) => {
+              var _a;
+              clearTimeout(timer);
+              if (result.code === ExportResultCode.SUCCESS) {
+                resolve();
+              } else {
+                reject((_a = result.error) != null ? _a : new Error("BatchSpanProcessor: span export failed"));
+              }
+            });
+            let pendingResources = null;
+            for (let i = 0, len = spans.length; i < len; i++) {
+              const span = spans[i];
+              if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+                pendingResources != null ? pendingResources : pendingResources = [];
+                pendingResources.push(span.resource.waitForAsyncAttributes());
+              }
+            }
+            if (pendingResources === null) {
+              doExport();
+            } else {
+              Promise.all(pendingResources).then(doExport, (err) => {
+                globalErrorHandler(err);
+                reject(err);
+              });
+            }
+          });
+        });
+      }
+      _maybeStartTimer() {
+        if (this._isExporting)
+          return;
+        const flush = () => {
+          this._isExporting = true;
+          this._flushOneBatch().finally(() => {
+            this._isExporting = false;
+            if (this._finishedSpans.length > 0) {
+              this._clearTimer();
+              this._maybeStartTimer();
+            }
+          }).catch((e) => {
+            this._isExporting = false;
+            globalErrorHandler(e);
+          });
+        };
+        if (this._finishedSpans.length >= this._maxExportBatchSize) {
+          return flush();
+        }
+        if (this._timer !== void 0)
+          return;
+        this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+        unrefTimer(this._timer);
+      }
+      _clearTimer() {
+        if (this._timer !== void 0) {
+          clearTimeout(this._timer);
+          this._timer = void 0;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var BatchSpanProcessor;
+var init_BatchSpanProcessor = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js"() {
+    "use strict";
+    init_BatchSpanProcessorBase();
+    BatchSpanProcessor = class extends BatchSpanProcessorBase {
+      onShutdown() {
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js
+function getIdGenerator(bytes) {
+  return function generateId() {
+    for (let i = 0; i < bytes / 4; i++) {
+      SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4);
+    }
+    for (let i = 0; i < bytes; i++) {
+      if (SHARED_BUFFER[i] > 0) {
+        break;
+      } else if (i === bytes - 1) {
+        SHARED_BUFFER[bytes - 1] = 1;
+      }
+    }
+    return SHARED_BUFFER.toString("hex", 0, bytes);
+  };
+}
+var SPAN_ID_BYTES, TRACE_ID_BYTES, RandomIdGenerator, SHARED_BUFFER;
+var init_RandomIdGenerator = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js"() {
+    "use strict";
+    SPAN_ID_BYTES = 8;
+    TRACE_ID_BYTES = 16;
+    RandomIdGenerator = class {
+      constructor() {
+        /**
+         * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+         * characters corresponding to 128 bits.
+         */
+        __publicField(this, "generateTraceId", getIdGenerator(TRACE_ID_BYTES));
+        /**
+         * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+         * characters corresponding to 64 bits.
+         */
+        __publicField(this, "generateSpanId", getIdGenerator(SPAN_ID_BYTES));
+      }
+    };
+    SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js
+var init_node2 = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_BatchSpanProcessor();
+    init_RandomIdGenerator();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js
+var init_platform2 = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js"() {
+    "use strict";
+    init_node2();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
+import * as api from "@opentelemetry/api";
+var Tracer;
+var init_Tracer = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js"() {
+    "use strict";
+    init_esm2();
+    init_Span();
+    init_utility();
+    init_platform2();
+    Tracer = class {
+      /**
+       * Constructs a new Tracer instance.
+       */
+      constructor(instrumentationScope, config, resource, spanProcessor) {
+        __publicField(this, "_sampler");
+        __publicField(this, "_generalLimits");
+        __publicField(this, "_spanLimits");
+        __publicField(this, "_idGenerator");
+        __publicField(this, "instrumentationScope");
+        __publicField(this, "_resource");
+        __publicField(this, "_spanProcessor");
+        const localConfig = mergeConfig(config);
+        this._sampler = localConfig.sampler;
+        this._generalLimits = localConfig.generalLimits;
+        this._spanLimits = localConfig.spanLimits;
+        this._idGenerator = config.idGenerator || new RandomIdGenerator();
+        this._resource = resource;
+        this._spanProcessor = spanProcessor;
+        this.instrumentationScope = instrumentationScope;
+      }
+      /**
+       * Starts a new Span or returns the default NoopSpan based on the sampling
+       * decision.
+       */
+      startSpan(name, options = {}, context4 = api.context.active()) {
+        var _a, _b, _c;
+        if (options.root) {
+          context4 = api.trace.deleteSpan(context4);
+        }
+        const parentSpan = api.trace.getSpan(context4);
+        if (isTracingSuppressed(context4)) {
+          api.diag.debug("Instrumentation suppressed, returning Noop Span");
+          const nonRecordingSpan = api.trace.wrapSpanContext(api.INVALID_SPAN_CONTEXT);
+          return nonRecordingSpan;
+        }
+        const parentSpanContext = parentSpan == null ? void 0 : parentSpan.spanContext();
+        const spanId = this._idGenerator.generateSpanId();
+        let validParentSpanContext;
+        let traceId;
+        let traceState;
+        if (!parentSpanContext || !api.trace.isSpanContextValid(parentSpanContext)) {
+          traceId = this._idGenerator.generateTraceId();
+        } else {
+          traceId = parentSpanContext.traceId;
+          traceState = parentSpanContext.traceState;
+          validParentSpanContext = parentSpanContext;
+        }
+        const spanKind = (_a = options.kind) != null ? _a : api.SpanKind.INTERNAL;
+        const links = ((_b = options.links) != null ? _b : []).map((link) => {
+          return {
+            context: link.context,
+            attributes: sanitizeAttributes(link.attributes)
+          };
+        });
+        const attributes = sanitizeAttributes(options.attributes);
+        const samplingResult = this._sampler.shouldSample(context4, traceId, name, spanKind, attributes, links);
+        traceState = (_c = samplingResult.traceState) != null ? _c : traceState;
+        const traceFlags = samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE;
+        const spanContext = { traceId, spanId, traceFlags, traceState };
+        if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
+          api.diag.debug("Recording is off, propagating context in a non-recording span");
+          const nonRecordingSpan = api.trace.wrapSpanContext(spanContext);
+          return nonRecordingSpan;
+        }
+        const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
+        const span = new SpanImpl({
+          resource: this._resource,
+          scope: this.instrumentationScope,
+          context: context4,
+          spanContext,
+          name,
+          kind: spanKind,
+          links,
+          parentSpanContext: validParentSpanContext,
+          attributes: initAttributes,
+          startTime: options.startTime,
+          spanProcessor: this._spanProcessor,
+          spanLimits: this._spanLimits
+        });
+        return span;
+      }
+      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 : api.context.active();
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = api.trace.setSpan(parentContext, span);
+        return api.context.with(contextWithSpanSet, fn, void 0, span);
+      }
+      /** Returns the active {@link GeneralLimits}. */
+      getGeneralLimits() {
+        return this._generalLimits;
+      }
+      /** Returns the active {@link SpanLimits}. */
+      getSpanLimits() {
+        return this._spanLimits;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
+var MultiSpanProcessor;
+var init_MultiSpanProcessor = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js"() {
+    "use strict";
+    init_esm2();
+    MultiSpanProcessor = class {
+      constructor(_spanProcessors) {
+        __publicField(this, "_spanProcessors");
+        this._spanProcessors = _spanProcessors;
+      }
+      forceFlush() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+          promises.push(spanProcessor.forceFlush());
+        }
+        return new Promise((resolve) => {
+          Promise.all(promises).then(() => {
+            resolve();
+          }).catch((error) => {
+            globalErrorHandler(error || new Error("MultiSpanProcessor: forceFlush failed"));
+            resolve();
+          });
+        });
+      }
+      onStart(span, context4) {
+        for (const spanProcessor of this._spanProcessors) {
+          spanProcessor.onStart(span, context4);
+        }
+      }
+      onEnd(span) {
+        for (const spanProcessor of this._spanProcessors) {
+          spanProcessor.onEnd(span);
+        }
+      }
+      shutdown() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+          promises.push(spanProcessor.shutdown());
+        }
+        return new Promise((resolve, reject) => {
+          Promise.all(promises).then(() => {
+            resolve();
+          }, reject);
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
+import { defaultResource } from "@opentelemetry/resources";
+var ForceFlushState, BasicTracerProvider;
+var init_BasicTracerProvider = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js"() {
+    "use strict";
+    init_esm2();
+    init_Tracer();
+    init_config();
+    init_MultiSpanProcessor();
+    init_utility();
+    (function(ForceFlushState2) {
+      ForceFlushState2[ForceFlushState2["resolved"] = 0] = "resolved";
+      ForceFlushState2[ForceFlushState2["timeout"] = 1] = "timeout";
+      ForceFlushState2[ForceFlushState2["error"] = 2] = "error";
+      ForceFlushState2[ForceFlushState2["unresolved"] = 3] = "unresolved";
+    })(ForceFlushState || (ForceFlushState = {}));
+    BasicTracerProvider = class {
+      constructor(config = {}) {
+        __publicField(this, "_config");
+        __publicField(this, "_tracers", /* @__PURE__ */ new Map());
+        __publicField(this, "_resource");
+        __publicField(this, "_activeSpanProcessor");
+        var _a, _b;
+        const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
+        this._resource = (_a = mergedConfig.resource) != null ? _a : defaultResource();
+        this._config = Object.assign({}, mergedConfig, {
+          resource: this._resource
+        });
+        const spanProcessors = [];
+        if ((_b = config.spanProcessors) == null ? void 0 : _b.length) {
+          spanProcessors.push(...config.spanProcessors);
+        }
+        this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
+      }
+      getTracer(name, version, options) {
+        const key = `${name}@${version || ""}:${(options == null ? void 0 : options.schemaUrl) || ""}`;
+        if (!this._tracers.has(key)) {
+          this._tracers.set(key, new Tracer({ name, version, schemaUrl: options == null ? void 0 : options.schemaUrl }, this._config, this._resource, this._activeSpanProcessor));
+        }
+        return this._tracers.get(key);
+      }
+      forceFlush() {
+        const timeout = this._config.forceFlushTimeoutMillis;
+        const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
+          return new Promise((resolve) => {
+            let state;
+            const timeoutInterval = setTimeout(() => {
+              resolve(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+              state = ForceFlushState.timeout;
+            }, timeout);
+            spanProcessor.forceFlush().then(() => {
+              clearTimeout(timeoutInterval);
+              if (state !== ForceFlushState.timeout) {
+                state = ForceFlushState.resolved;
+                resolve(state);
+              }
+            }).catch((error) => {
+              clearTimeout(timeoutInterval);
+              state = ForceFlushState.error;
+              resolve(error);
+            });
+          });
+        });
+        return new Promise((resolve, reject) => {
+          Promise.all(promises).then((results) => {
+            const errors = results.filter((result) => result !== ForceFlushState.resolved);
+            if (errors.length > 0) {
+              reject(errors);
+            } else {
+              resolve();
+            }
+          }).catch((error) => reject([error]));
+        });
+      }
+      shutdown() {
+        return this._activeSpanProcessor.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js
+var ConsoleSpanExporter;
+var init_ConsoleSpanExporter = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js"() {
+    "use strict";
+    init_esm2();
+    ConsoleSpanExporter = class {
+      /**
+       * Export spans.
+       * @param spans
+       * @param resultCallback
+       */
+      export(spans, resultCallback) {
+        return this._sendSpans(spans, resultCallback);
+      }
+      /**
+       * Shutdown the exporter.
+       */
+      shutdown() {
+        this._sendSpans([]);
+        return this.forceFlush();
+      }
+      /**
+       * Exports any pending spans in exporter
+       */
+      forceFlush() {
+        return Promise.resolve();
+      }
+      /**
+       * converts span info into more readable format
+       * @param span
+       */
+      _exportInfo(span) {
+        var _a;
+        return {
+          resource: {
+            attributes: span.resource.attributes
+          },
+          instrumentationScope: span.instrumentationScope,
+          traceId: span.spanContext().traceId,
+          parentSpanContext: span.parentSpanContext,
+          traceState: (_a = span.spanContext().traceState) == null ? void 0 : _a.serialize(),
+          name: span.name,
+          id: span.spanContext().spanId,
+          kind: span.kind,
+          timestamp: hrTimeToMicroseconds(span.startTime),
+          duration: hrTimeToMicroseconds(span.duration),
+          attributes: span.attributes,
+          status: span.status,
+          events: span.events,
+          links: span.links
+        };
+      }
+      /**
+       * Showing spans in console
+       * @param spans
+       * @param done
+       */
+      _sendSpans(spans, done) {
+        for (const span of spans) {
+          console.dir(this._exportInfo(span), { depth: 3 });
+        }
+        if (done) {
+          return done({ code: ExportResultCode.SUCCESS });
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js
+var InMemorySpanExporter;
+var init_InMemorySpanExporter = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js"() {
+    "use strict";
+    init_esm2();
+    InMemorySpanExporter = class {
+      constructor() {
+        __publicField(this, "_finishedSpans", []);
+        /**
+         * Indicates if the exporter has been "shutdown."
+         * When false, exported spans will not be stored in-memory.
+         */
+        __publicField(this, "_stopped", false);
+      }
+      export(spans, resultCallback) {
+        if (this._stopped)
+          return resultCallback({
+            code: ExportResultCode.FAILED,
+            error: new Error("Exporter has been stopped")
+          });
+        this._finishedSpans.push(...spans);
+        setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+      }
+      shutdown() {
+        this._stopped = true;
+        this._finishedSpans = [];
+        return this.forceFlush();
+      }
+      /**
+       * Exports any pending spans in the exporter
+       */
+      forceFlush() {
+        return Promise.resolve();
+      }
+      reset() {
+        this._finishedSpans = [];
+      }
+      getFinishedSpans() {
+        return this._finishedSpans;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js
+import { TraceFlags as TraceFlags6 } from "@opentelemetry/api";
+var SimpleSpanProcessor;
+var init_SimpleSpanProcessor = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js"() {
+    "use strict";
+    init_esm2();
+    SimpleSpanProcessor = class {
+      constructor(_exporter) {
+        __publicField(this, "_exporter");
+        __publicField(this, "_shutdownOnce");
+        __publicField(this, "_pendingExports");
+        this._exporter = _exporter;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        this._pendingExports = /* @__PURE__ */ new Set();
+      }
+      async forceFlush() {
+        await Promise.all(Array.from(this._pendingExports));
+        if (this._exporter.forceFlush) {
+          await this._exporter.forceFlush();
+        }
+      }
+      onStart(_span, _parentContext) {
+      }
+      onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+          return;
+        }
+        if ((span.spanContext().traceFlags & TraceFlags6.SAMPLED) === 0) {
+          return;
+        }
+        const pendingExport = this._doExport(span).catch((err) => globalErrorHandler(err));
+        this._pendingExports.add(pendingExport);
+        pendingExport.finally(() => this._pendingExports.delete(pendingExport));
+      }
+      async _doExport(span) {
+        var _a, _b, _c;
+        if (span.resource.asyncAttributesPending) {
+          await ((_b = (_a = span.resource).waitForAsyncAttributes) == null ? void 0 : _b.call(_a));
+        }
+        const result = await internal._export(this._exporter, [span]);
+        if (result.code !== ExportResultCode.SUCCESS) {
+          throw (_c = result.error) != null ? _c : new Error(`SimpleSpanProcessor: span export failed (status ${result})`);
+        }
+      }
+      shutdown() {
+        return this._shutdownOnce.call();
+      }
+      _shutdown() {
+        return this._exporter.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js
+var NoopSpanProcessor;
+var init_NoopSpanProcessor = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js"() {
+    "use strict";
+    NoopSpanProcessor = class {
+      onStart(_span, _context) {
+      }
+      onEnd(_span) {
+      }
+      shutdown() {
+        return Promise.resolve();
+      }
+      forceFlush() {
+        return Promise.resolve();
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js
+var esm_exports2 = {};
+__export(esm_exports2, {
+  AlwaysOffSampler: () => AlwaysOffSampler,
+  AlwaysOnSampler: () => AlwaysOnSampler,
+  BasicTracerProvider: () => BasicTracerProvider,
+  BatchSpanProcessor: () => BatchSpanProcessor,
+  ConsoleSpanExporter: () => ConsoleSpanExporter,
+  InMemorySpanExporter: () => InMemorySpanExporter,
+  NoopSpanProcessor: () => NoopSpanProcessor,
+  ParentBasedSampler: () => ParentBasedSampler,
+  RandomIdGenerator: () => RandomIdGenerator,
+  SamplingDecision: () => SamplingDecision,
+  SimpleSpanProcessor: () => SimpleSpanProcessor,
+  TraceIdRatioBasedSampler: () => TraceIdRatioBasedSampler
+});
+var init_esm3 = __esm({
+  "../../node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js"() {
+    "use strict";
+    init_BasicTracerProvider();
+    init_platform2();
+    init_ConsoleSpanExporter();
+    init_InMemorySpanExporter();
+    init_SimpleSpanProcessor();
+    init_NoopSpanProcessor();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    init_Sampler();
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js
+var require_NodeTracerProvider = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeTracerProvider = void 0;
+    var context_async_hooks_1 = require_src();
+    var sdk_trace_base_1 = (init_esm3(), __toCommonJS(esm_exports2));
+    var api_1 = __require("@opentelemetry/api");
+    var core_1 = (init_esm2(), __toCommonJS(esm_exports));
+    function setupContextManager(contextManager) {
+      if (contextManager === null) {
+        return;
+      }
+      if (contextManager === void 0) {
+        const defaultContextManager = new context_async_hooks_1.AsyncLocalStorageContextManager();
+        defaultContextManager.enable();
+        api_1.context.setGlobalContextManager(defaultContextManager);
+        return;
+      }
+      contextManager.enable();
+      api_1.context.setGlobalContextManager(contextManager);
+    }
+    function setupPropagator(propagator) {
+      if (propagator === null) {
+        return;
+      }
+      if (propagator === void 0) {
+        api_1.propagation.setGlobalPropagator(new core_1.CompositePropagator({
+          propagators: [
+            new core_1.W3CTraceContextPropagator(),
+            new core_1.W3CBaggagePropagator()
+          ]
+        }));
+        return;
+      }
+      api_1.propagation.setGlobalPropagator(propagator);
+    }
+    var NodeTracerProvider = class extends sdk_trace_base_1.BasicTracerProvider {
+      constructor(config = {}) {
+        super(config);
+      }
+      /**
+       * Register this TracerProvider for use with the OpenTelemetry API.
+       * Undefined values may be replaced with defaults, and
+       * null values will be skipped.
+       *
+       * @param config Configuration object for SDK registration
+       */
+      register(config = {}) {
+        api_1.trace.setGlobalTracerProvider(this);
+        setupContextManager(config.contextManager);
+        setupPropagator(config.propagator);
+      }
+    };
+    exports.NodeTracerProvider = NodeTracerProvider;
+  }
+});
+
+// ../../node_modules/@opentelemetry/sdk-trace-node/build/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/@opentelemetry/sdk-trace-node/build/src/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceIdRatioBasedSampler = exports.SimpleSpanProcessor = exports.SamplingDecision = exports.RandomIdGenerator = exports.ParentBasedSampler = exports.NoopSpanProcessor = exports.InMemorySpanExporter = exports.ConsoleSpanExporter = exports.BatchSpanProcessor = exports.BasicTracerProvider = exports.AlwaysOnSampler = exports.AlwaysOffSampler = exports.NodeTracerProvider = void 0;
+    var NodeTracerProvider_1 = require_NodeTracerProvider();
+    Object.defineProperty(exports, "NodeTracerProvider", { enumerable: true, get: function() {
+      return NodeTracerProvider_1.NodeTracerProvider;
+    } });
+    var sdk_trace_base_1 = (init_esm3(), __toCommonJS(esm_exports2));
+    Object.defineProperty(exports, "AlwaysOffSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.AlwaysOffSampler;
+    } });
+    Object.defineProperty(exports, "AlwaysOnSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.AlwaysOnSampler;
+    } });
+    Object.defineProperty(exports, "BasicTracerProvider", { enumerable: true, get: function() {
+      return sdk_trace_base_1.BasicTracerProvider;
+    } });
+    Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.BatchSpanProcessor;
+    } });
+    Object.defineProperty(exports, "ConsoleSpanExporter", { enumerable: true, get: function() {
+      return sdk_trace_base_1.ConsoleSpanExporter;
+    } });
+    Object.defineProperty(exports, "InMemorySpanExporter", { enumerable: true, get: function() {
+      return sdk_trace_base_1.InMemorySpanExporter;
+    } });
+    Object.defineProperty(exports, "NoopSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.NoopSpanProcessor;
+    } });
+    Object.defineProperty(exports, "ParentBasedSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.ParentBasedSampler;
+    } });
+    Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() {
+      return sdk_trace_base_1.RandomIdGenerator;
+    } });
+    Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
+      return sdk_trace_base_1.SamplingDecision;
+    } });
+    Object.defineProperty(exports, "SimpleSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.SimpleSpanProcessor;
+    } });
+    Object.defineProperty(exports, "TraceIdRatioBasedSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.TraceIdRatioBasedSampler;
+    } });
+  }
+});
+
+// src/tracing/noOpSpan.ts
+import {
+  TraceFlags
+} from "@opentelemetry/api";
+var INVALID_SPAN_CONTEXT = {
+  traceId: "",
+  spanId: "",
+  traceFlags: TraceFlags.NONE,
+  isRemote: false
+};
+var NoOpSpan = class {
+  spanContext() {
+    return INVALID_SPAN_CONTEXT;
+  }
+  setAttribute(_key, _value) {
+    return this;
+  }
+  setAttributes(_attributes) {
+    return this;
+  }
+  addEvent(_name, _attributesOrStartTime, _startTime) {
+    return this;
+  }
+  addLink(_link) {
+    return this;
+  }
+  addLinks(_links) {
+    return this;
+  }
+  setStatus(_status) {
+    return this;
+  }
+  updateName(_name) {
+    return this;
+  }
+  end(_endTime) {
+  }
+  recordException(_exception, _time) {
+  }
+  isRecording() {
+    return false;
+  }
+};
+var NO_OP_SPAN = new NoOpSpan();
+
+// src/tracing/nonLiveInteraction.ts
+var NonLiveInteraction = class {
+  constructor(context4, traceId, analytics) {
+    this.context = context4;
+    this.analytics = analytics;
+  }
+  withSpan(_params, fn, thisArg, ...args) {
+    var _a;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withSpan in nonLiveInteraction");
+    }
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  withTool(_params, fn, thisArg, ...args) {
+    var _a;
+    if ((_a = this.analytics) == null ? void 0 : _a.debugLogs) {
+      console.log("[raindrop] using withTool in nonLiveInteraction");
+    }
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  startSpan(_params) {
+    return NO_OP_SPAN;
+  }
+  setProperties(_properties) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties: _properties
+    });
+  }
+  setProperty(_key, _value) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      properties: {
+        [_key]: _value
+      }
+    });
+  }
+  addAttachments(_attachments) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      attachments: _attachments
+    });
+  }
+  setInput(_input) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      eventId: this.context.eventId,
+      input: _input
+    });
+  }
+  finish(resultEvent) {
+    var _a;
+    (_a = this.analytics) == null ? void 0 : _a._trackAiPartial({
+      ...resultEvent,
+      eventId: this.context.eventId,
+      isPending: false
+    });
+  }
+};
+
+// src/tracing/tracer-core.ts
+var import_sdk_trace_node = __toESM(require_src2());
+
+// src/tracing/nonLiveTracer.ts
+var NoOpTracer = class {
+  withSpan(_params, fn, thisArg, ...args) {
+    try {
+      return Promise.resolve(fn.apply(thisArg, args));
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+};
+
+// src/tracing/tracer-core.ts
+var getGlobalRegistry = () => {
+  if (typeof globalThis !== "undefined") {
+    globalThis.__RAINDROP_TRACING_REGISTRY__ = globalThis.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return globalThis.__RAINDROP_TRACING_REGISTRY__;
+  } else if (typeof window !== "undefined") {
+    window.__RAINDROP_TRACING_REGISTRY__ = window.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return window.__RAINDROP_TRACING_REGISTRY__;
+  } else if (typeof global !== "undefined") {
+    global.__RAINDROP_TRACING_REGISTRY__ = global.__RAINDROP_TRACING_REGISTRY__ || {
+      hasRealImplementation: false,
+      realImplementation: null
+    };
+    return global.__RAINDROP_TRACING_REGISTRY__;
+  }
+  return {
+    hasRealImplementation: false,
+    realImplementation: null
+  };
+};
+var createTracing = (analytics, _apiUrl, _writeKey, _options, isDebug = false) => ({
+  createSpanProcessor(processorOptions) {
+    return new import_sdk_trace_node.NoopSpanProcessor();
+  },
+  begin(traceContext) {
+    if (isDebug) {
+      console.log("not using traces");
+    }
+    if (!traceContext.eventId) {
+      traceContext.eventId = crypto.randomUUID();
+    }
+    analytics._trackAiPartial({
+      ...traceContext
+    });
+    return new NonLiveInteraction(
+      traceContext,
+      void 0,
+      // No traceId in stub
+      analytics
+    );
+  },
+  getActiveInteraction(eventId) {
+    return new NonLiveInteraction({ eventId }, void 0, analytics);
+  },
+  tracer(globalProperties) {
+    return new NoOpTracer();
+  },
+  async close() {
+  }
+});
+var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
+  const registry = getGlobalRegistry();
+  if (registry.hasRealImplementation && registry.realImplementation) {
+    if (isDebug) {
+      console.log("[raindrop] Using real tracing implementation");
+    }
+    return registry.realImplementation(analytics, apiUrl, writeKey, options, isDebug);
+  }
+  if (isDebug) {
+    console.log("[raindrop] Using stub implementation");
+  }
+  return createTracing(analytics, apiUrl, writeKey, options, isDebug);
+};
+var _setImplementation = (impl) => {
+  const registry = getGlobalRegistry();
+  registry.realImplementation = impl;
+  registry.hasRealImplementation = true;
+  if (typeof process !== "undefined" && process.env.RAINDROP_DEBUG === "true") {
+    console.log("[raindrop] Set real implementation in global registry");
+  }
+};
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  __publicField,
+  require_src2 as require_src,
+  NonLiveInteraction,
+  tracing,
+  _setImplementation
+};