var __bare_os_bundle_exports__ = (() => {
  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 __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);

  // ../../node_modules/bare-prom-client/lib/util.js
  var require_util = __commonJS({
    "../../node_modules/bare-prom-client/lib/util.js"(exports) {
      "use strict";
      exports.getValueAsString = function getValueString(value) {
        if (Number.isNaN(value)) {
          return "Nan";
        } else if (!Number.isFinite(value)) {
          if (value < 0) {
            return "-Inf";
          } else {
            return "+Inf";
          }
        } else {
          return `${value}`;
        }
      };
      exports.removeLabels = function removeLabels(hashMap, labels, sortedLabelNames) {
        const hash = hashObject(labels, sortedLabelNames);
        delete hashMap[hash];
      };
      exports.setValue = function setValue(hashMap, value, labels) {
        const hash = hashObject(labels);
        hashMap[hash] = {
          value: typeof value === "number" ? value : 0,
          labels: labels || {}
        };
        return hashMap;
      };
      exports.setValueDelta = function setValueDelta(hashMap, deltaValue, labels, hash = "") {
        const value = typeof deltaValue === "number" ? deltaValue : 0;
        if (hashMap[hash]) {
          hashMap[hash].value += value;
        } else {
          hashMap[hash] = { value, labels };
        }
        return hashMap;
      };
      exports.getLabels = function(labelNames, args) {
        if (typeof args[0] === "object") {
          return args[0];
        }
        if (labelNames.length !== args.length) {
          throw new Error(
            `Invalid number of arguments (${args.length}): "${args.join(
              ", "
            )}" for label names (${labelNames.length}): "${labelNames.join(", ")}".`
          );
        }
        const acc = {};
        for (let i = 0; i < labelNames.length; i++) {
          acc[labelNames[i]] = args[i];
        }
        return acc;
      };
      function fastHashObject(keys, labels) {
        if (keys.length === 0) {
          return "";
        }
        let hash = "";
        for (let i = 0; i < keys.length; i++) {
          const key = keys[i];
          const value = labels[key];
          if (value === void 0) continue;
          hash += `${key}:${value},`;
        }
        return hash;
      }
      function hashObject(labels, labelNames) {
        if (labelNames) {
          return fastHashObject(labelNames, labels);
        }
        const keys = Object.keys(labels);
        if (keys.length > 1) {
          keys.sort();
        }
        return fastHashObject(keys, labels);
      }
      exports.hashObject = hashObject;
      exports.isObject = function isObject(obj) {
        return obj !== null && typeof obj === "object";
      };
      exports.nowTimestamp = function nowTimestamp() {
        return Date.now() / 1e3;
      };
      var Grouper = class extends Map {
        /**
         * Adds the `value` to the `key`'s array of values.
         * @param {*} key Key to set.
         * @param {*} value Value to add to `key`'s array.
         * @returns {undefined} undefined.
         */
        add(key, value) {
          if (this.has(key)) {
            this.get(key).push(value);
          } else {
            this.set(key, [value]);
          }
        }
      };
      exports.Grouper = Grouper;
    }
  });

  // ../../node_modules/bare-prom-client/lib/registry.js
  var require_registry = __commonJS({
    "../../node_modules/bare-prom-client/lib/registry.js"(exports, module) {
      "use strict";
      var { getValueAsString } = require_util();
      var Registry = class _Registry {
        static get PROMETHEUS_CONTENT_TYPE() {
          return "text/plain; version=0.0.4; charset=utf-8";
        }
        static get OPENMETRICS_CONTENT_TYPE() {
          return "application/openmetrics-text; version=1.0.0; charset=utf-8";
        }
        constructor(regContentType = _Registry.PROMETHEUS_CONTENT_TYPE) {
          this._metrics = {};
          this._collectors = [];
          this._defaultLabels = {};
          if (regContentType !== _Registry.PROMETHEUS_CONTENT_TYPE && regContentType !== _Registry.OPENMETRICS_CONTENT_TYPE) {
            throw new TypeError(`Content type ${regContentType} is unsupported`);
          }
          this._contentType = regContentType;
        }
        getMetricsAsArray() {
          return Object.values(this._metrics);
        }
        async getMetricsAsString(metrics2) {
          const metric = typeof metrics2.getForPromString === "function" ? await metrics2.getForPromString() : await metrics2.get();
          const name = escapeString(metric.name);
          const help = `# HELP ${name} ${escapeString(metric.help)}`;
          const type = `# TYPE ${name} ${metric.type}`;
          const values = [help, type];
          const defaultLabels = Object.keys(this._defaultLabels).length > 0 ? this._defaultLabels : null;
          const isOpenMetrics = this.contentType === _Registry.OPENMETRICS_CONTENT_TYPE;
          for (const val of metric.values || []) {
            let { metricName = name, labels = {} } = val;
            const { sharedLabels = {} } = val;
            if (isOpenMetrics && metric.type === "counter") {
              metricName = `${metricName}_total`;
            }
            if (defaultLabels) {
              labels = { ...labels, ...defaultLabels, ...labels };
            }
            const formattedLabels = formatLabels(labels, sharedLabels);
            const flattenedShared = flattenSharedLabels(sharedLabels);
            const labelParts = [...formattedLabels, flattenedShared].filter(Boolean);
            const labelsString = labelParts.length ? `{${labelParts.join(",")}}` : "";
            let fullMetricLine = `${metricName}${labelsString} ${getValueAsString(
              val.value
            )}`;
            const { exemplar } = val;
            if (exemplar && isOpenMetrics) {
              const formattedExemplars = formatLabels(exemplar.labelSet);
              fullMetricLine += ` # {${formattedExemplars.join(
                ","
              )}} ${getValueAsString(exemplar.value)} ${exemplar.timestamp}`;
            }
            values.push(fullMetricLine);
          }
          return values.join("\n");
        }
        async metrics() {
          const isOpenMetrics = this.contentType === _Registry.OPENMETRICS_CONTENT_TYPE;
          const promises = this.getMetricsAsArray().map((metric) => {
            if (isOpenMetrics && metric.type === "counter") {
              metric.name = standardizeCounterName(metric.name);
            }
            return this.getMetricsAsString(metric);
          });
          const resolves = await Promise.all(promises);
          return isOpenMetrics ? `${resolves.join("\n")}
# EOF
` : `${resolves.join("\n\n")}
`;
        }
        registerMetric(metric) {
          if (this._metrics[metric.name] && this._metrics[metric.name] !== metric) {
            throw new Error(
              `A metric with the name ${metric.name} has already been registered.`
            );
          }
          this._metrics[metric.name] = metric;
        }
        clear() {
          this._metrics = {};
          this._defaultLabels = {};
        }
        async getMetricsAsJSON() {
          const metrics2 = [];
          const defaultLabelNames = Object.keys(this._defaultLabels);
          const promises = [];
          for (const metric of this.getMetricsAsArray()) {
            promises.push(metric.get());
          }
          const resolves = await Promise.all(promises);
          for (const item of resolves) {
            if (item.values && defaultLabelNames.length > 0) {
              for (const val of item.values) {
                val.labels = Object.assign({}, val.labels);
                for (const labelName of defaultLabelNames) {
                  val.labels[labelName] = val.labels[labelName] || this._defaultLabels[labelName];
                }
              }
            }
            metrics2.push(item);
          }
          return metrics2;
        }
        removeSingleMetric(name) {
          delete this._metrics[name];
        }
        getSingleMetricAsString(name) {
          return this.getMetricsAsString(this._metrics[name]);
        }
        getSingleMetric(name) {
          return this._metrics[name];
        }
        setDefaultLabels(labels) {
          this._defaultLabels = labels;
        }
        resetMetrics() {
          for (const metric in this._metrics) {
            this._metrics[metric].reset();
          }
        }
        get contentType() {
          return this._contentType;
        }
        setContentType(metricsContentType) {
          if (metricsContentType === _Registry.OPENMETRICS_CONTENT_TYPE || metricsContentType === _Registry.PROMETHEUS_CONTENT_TYPE) {
            this._contentType = metricsContentType;
          } else {
            throw new Error(`Content type ${metricsContentType} is unsupported`);
          }
        }
        static merge(registers) {
          const regType = registers[0].contentType;
          for (const reg of registers) {
            if (reg.contentType !== regType) {
              throw new Error(
                "Registers can only be merged if they have the same content type"
              );
            }
          }
          const mergedRegistry = new _Registry(regType);
          const metricsToMerge = registers.reduce(
            (acc, reg) => acc.concat(reg.getMetricsAsArray()),
            []
          );
          metricsToMerge.forEach(mergedRegistry.registerMetric, mergedRegistry);
          return mergedRegistry;
        }
      };
      function formatLabels(labels, exclude) {
        const { hasOwnProperty } = Object.prototype;
        const formatted = [];
        for (const [name, value] of Object.entries(labels)) {
          if (!exclude || !hasOwnProperty.call(exclude, name)) {
            formatted.push(`${name}="${escapeLabelValue(value)}"`);
          }
        }
        return formatted;
      }
      var sharedLabelCache = /* @__PURE__ */ new WeakMap();
      function flattenSharedLabels(labels) {
        const cached = sharedLabelCache.get(labels);
        if (cached) {
          return cached;
        }
        const formattedLabels = formatLabels(labels);
        const flattened = formattedLabels.join(",");
        sharedLabelCache.set(labels, flattened);
        return flattened;
      }
      function escapeLabelValue(str) {
        if (typeof str !== "string") {
          return str;
        }
        return escapeString(str).replace(/"/g, '\\"');
      }
      function escapeString(str) {
        return str.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
      }
      function standardizeCounterName(name) {
        return name.replace(/_total$/, "");
      }
      module.exports = Registry;
      module.exports.globalRegistry = new Registry();
    }
  });

  // ../../node_modules/bare-prom-client/lib/validation.js
  var require_validation = __commonJS({
    "../../node_modules/bare-prom-client/lib/validation.js"(exports) {
      "use strict";
      var util = __require("util");
      var metricRegexp = /^[a-zA-Z_:][a-zA-Z0-9_:]*$/;
      var labelRegexp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
      exports.validateMetricName = function(name) {
        return metricRegexp.test(name);
      };
      exports.validateLabelName = function(names = []) {
        return names.every((name) => labelRegexp.test(name));
      };
      exports.validateLabel = function validateLabel(savedLabels, labels) {
        for (const label in labels) {
          if (!savedLabels.includes(label)) {
            throw new Error(
              `Added label "${label}" is not included in initial labelset: ${util.inspect(
                savedLabels
              )}`
            );
          }
        }
      };
    }
  });

  // ../../node_modules/bare-prom-client/lib/metric.js
  var require_metric = __commonJS({
    "../../node_modules/bare-prom-client/lib/metric.js"(exports, module) {
      "use strict";
      var Registry = require_registry();
      var { isObject } = require_util();
      var { validateMetricName, validateLabelName } = require_validation();
      var Metric = class {
        constructor(config, defaults = {}) {
          if (!isObject(config)) {
            throw new TypeError("constructor expected a config object");
          }
          Object.assign(
            this,
            {
              labelNames: [],
              registers: [Registry.globalRegistry],
              aggregator: "sum",
              enableExemplars: false
            },
            defaults,
            config
          );
          if (!this.registers) {
            this.registers = [Registry.globalRegistry];
          }
          if (!this.help) {
            throw new Error("Missing mandatory help parameter");
          }
          if (!this.name) {
            throw new Error("Missing mandatory name parameter");
          }
          if (!validateMetricName(this.name)) {
            throw new Error("Invalid metric name");
          }
          if (!validateLabelName(this.labelNames)) {
            throw new Error("Invalid label name");
          }
          if (this.collect && typeof this.collect !== "function") {
            throw new Error('Optional "collect" parameter must be a function');
          }
          if (this.labelNames) {
            this.sortedLabelNames = [...this.labelNames].sort();
          } else {
            this.sortedLabelNames = [];
          }
          this.reset();
          for (const register of this.registers) {
            if (this.enableExemplars && register.contentType === Registry.PROMETHEUS_CONTENT_TYPE) {
              throw new TypeError(
                "Exemplars are supported only on OpenMetrics registries"
              );
            }
            register.registerMetric(this);
          }
        }
        reset() {
        }
      };
      module.exports = { Metric };
    }
  });

  // ../../node_modules/bare-prom-client/lib/exemplar.js
  var require_exemplar = __commonJS({
    "../../node_modules/bare-prom-client/lib/exemplar.js"(exports, module) {
      "use strict";
      var Exemplar = class {
        constructor(labelSet = {}, value = null) {
          this.labelSet = labelSet;
          this.value = value;
        }
        /**
         * Validation for the label set format.
         * https://github.com/OpenObservability/OpenMetrics/blob/d99b705f611b75fec8f450b05e344e02eea6921d/specification/OpenMetrics.md#exemplars
         *
         * @param {object} labelSet - Exemplar labels.
         * @throws {RangeError}
         * @return {void}
         */
        validateExemplarLabelSet(labelSet) {
          let res = "";
          for (const [labelName, labelValue] of Object.entries(labelSet)) {
            res += `${labelName}${labelValue}`;
          }
          if (res.length > 128) {
            throw new RangeError(
              "Label set size must be smaller than 128 UTF-8 chars"
            );
          }
        }
      };
      module.exports = Exemplar;
    }
  });

  // ../../node_modules/bare-prom-client/lib/counter.js
  var require_counter = __commonJS({
    "../../node_modules/bare-prom-client/lib/counter.js"(exports, module) {
      "use strict";
      var util = __require("util");
      var {
        hashObject,
        isObject,
        getLabels,
        removeLabels,
        nowTimestamp
      } = require_util();
      var { validateLabel } = require_validation();
      var { Metric } = require_metric();
      var Exemplar = require_exemplar();
      var Counter = class extends Metric {
        constructor(config) {
          super(config);
          this.type = "counter";
          this.defaultLabels = {};
          this.defaultValue = 1;
          this.defaultExemplarLabelSet = {};
          if (config.enableExemplars) {
            this.enableExemplars = true;
            this.inc = this.incWithExemplar;
          } else {
            this.inc = this.incWithoutExemplar;
          }
        }
        /**
         * Increment counter
         * @param {object} labels - What label you want to be incremented
         * @param {Number} value - Value to increment, if omitted increment with 1
         * @returns {object} results - object with information about the inc operation
         * @returns {string} results.labelHash - hash representation of the labels
         */
        incWithoutExemplar(labels, value) {
          let hash = "";
          if (isObject(labels)) {
            hash = hashObject(labels, this.sortedLabelNames);
            validateLabel(this.labelNames, labels);
          } else {
            value = labels;
            labels = {};
          }
          if (value && !Number.isFinite(value)) {
            throw new TypeError(`Value is not a valid number: ${util.format(value)}`);
          }
          if (value < 0) {
            throw new Error("It is not possible to decrease a counter");
          }
          if (value === null || value === void 0) value = 1;
          setValue(this.hashMap, value, labels, hash);
          return { labelHash: hash };
        }
        /**
         * Increment counter with exemplar, same as inc but accepts labels for an
         * exemplar.
         * If no label is provided the current exemplar labels are kept unchanged
         * (defaults to empty set).
         *
         * @param {object} incOpts - Object with options about what metric to increase
         * @param {object} incOpts.labels - What label you want to be incremented,
         *                                  defaults to null (metric with no labels)
         * @param {Number} incOpts.value - Value to increment, defaults to 1
         * @param {object} incOpts.exemplarLabels - Key-value  labels for the
         *                                          exemplar, defaults to empty set {}
         * @returns {void}
         */
        incWithExemplar({
          labels = this.defaultLabels,
          value = this.defaultValue,
          exemplarLabels = this.defaultExemplarLabelSet
        } = {}) {
          const res = this.incWithoutExemplar(labels, value);
          this.updateExemplar(exemplarLabels, value, res.labelHash);
        }
        updateExemplar(exemplarLabels, value, hash) {
          if (exemplarLabels === this.defaultExemplarLabelSet) return;
          if (!isObject(this.hashMap[hash].exemplar)) {
            this.hashMap[hash].exemplar = new Exemplar();
          }
          this.hashMap[hash].exemplar.validateExemplarLabelSet(exemplarLabels);
          this.hashMap[hash].exemplar.labelSet = exemplarLabels;
          this.hashMap[hash].exemplar.value = value ? value : 1;
          this.hashMap[hash].exemplar.timestamp = nowTimestamp();
        }
        /**
         * Reset counter
         * @returns {void}
         */
        reset() {
          this.hashMap = {};
          if (this.labelNames.length === 0) {
            setValue(this.hashMap, 0);
          }
        }
        async get() {
          if (this.collect) {
            const v = this.collect();
            if (v instanceof Promise) await v;
          }
          return {
            help: this.help,
            name: this.name,
            type: this.type,
            values: Object.values(this.hashMap),
            aggregator: this.aggregator
          };
        }
        labels(...args) {
          const labels = getLabels(this.labelNames, args) || {};
          return {
            inc: this.inc.bind(this, labels)
          };
        }
        remove(...args) {
          const labels = getLabels(this.labelNames, args) || {};
          validateLabel(this.labelNames, labels);
          return removeLabels.call(this, this.hashMap, labels, this.sortedLabelNames);
        }
      };
      function setValue(hashMap, value, labels = {}, hash = "") {
        if (hashMap[hash]) {
          hashMap[hash].value += value;
        } else {
          hashMap[hash] = { value, labels };
        }
        return hashMap;
      }
      module.exports = Counter;
    }
  });

  // ../../node_modules/bare-prom-client/lib/gauge.js
  var require_gauge = __commonJS({
    "../../node_modules/bare-prom-client/lib/gauge.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var util = __require("util");
      var {
        setValue,
        setValueDelta,
        getLabels,
        hashObject,
        isObject,
        removeLabels
      } = require_util();
      var { validateLabel } = require_validation();
      var { Metric } = require_metric();
      var Gauge = class extends Metric {
        constructor(config) {
          super(config);
          this.type = "gauge";
        }
        /**
         * Set a gauge to a value
         * @param {object} labels - Object with labels and their values
         * @param {Number} value - Value to set the gauge to, must be positive
         * @returns {void}
         */
        set(labels, value) {
          value = getValueArg(labels, value);
          labels = getLabelArg(labels);
          set(this, labels, value);
        }
        /**
         * Reset gauge
         * @returns {void}
         */
        reset() {
          this.hashMap = {};
          if (this.labelNames.length === 0) {
            setValue(this.hashMap, 0, {});
          }
        }
        /**
         * Increment a gauge value
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @param {Number} value - Value to increment - if omitted, increment with 1
         * @returns {void}
         */
        inc(labels, value) {
          value = getValueArg(labels, value);
          labels = getLabelArg(labels);
          if (value === void 0) value = 1;
          setDelta(this, labels, value);
        }
        /**
         * Decrement a gauge value
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @param {Number} value - Value to decrement - if omitted, decrement with 1
         * @returns {void}
         */
        dec(labels, value) {
          value = getValueArg(labels, value);
          labels = getLabelArg(labels);
          if (value === void 0) value = 1;
          setDelta(this, labels, -value);
        }
        /**
         * Set the gauge to current unix epoch
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @returns {void}
         */
        setToCurrentTime(labels) {
          const now = Date.now() / 1e3;
          if (labels === void 0) {
            this.set(now);
          } else {
            this.set(labels, now);
          }
        }
        /**
         * Start a timer
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @returns {function} - Invoke this function to set the duration in seconds since you started the timer.
         * @example
         * var done = gauge.startTimer();
         * makeXHRRequest(function(err, response) {
         *	done(); //Duration of the request will be saved
         * });
         */
        startTimer(labels) {
          const start = process.hrtime();
          return (endLabels) => {
            const delta = process.hrtime(start);
            const value = delta[0] + delta[1] / 1e9;
            this.set(Object.assign({}, labels, endLabels), value);
            return value;
          };
        }
        async get() {
          if (this.collect) {
            const v = this.collect();
            if (v instanceof Promise) await v;
          }
          return {
            help: this.help,
            name: this.name,
            type: this.type,
            values: Object.values(this.hashMap),
            aggregator: this.aggregator
          };
        }
        _getValue(labels) {
          const hash = hashObject(labels || {}, this.sortedLabelNames);
          return this.hashMap[hash] ? this.hashMap[hash].value : 0;
        }
        labels(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          return {
            inc: this.inc.bind(this, labels),
            dec: this.dec.bind(this, labels),
            set: this.set.bind(this, labels),
            setToCurrentTime: this.setToCurrentTime.bind(this, labels),
            startTimer: this.startTimer.bind(this, labels)
          };
        }
        remove(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          removeLabels.call(this, this.hashMap, labels, this.sortedLabelNames);
        }
      };
      function set(gauge, labels, value) {
        if (typeof value !== "number") {
          throw new TypeError(`Value is not a valid number: ${util.format(value)}`);
        }
        validateLabel(gauge.labelNames, labels);
        setValue(gauge.hashMap, value, labels);
      }
      function setDelta(gauge, labels, delta) {
        if (typeof delta !== "number") {
          throw new TypeError(`Delta is not a valid number: ${util.format(delta)}`);
        }
        validateLabel(gauge.labelNames, labels);
        const hash = hashObject(labels, gauge.sortedLabelNames);
        setValueDelta(gauge.hashMap, delta, labels, hash);
      }
      function getLabelArg(labels) {
        return isObject(labels) ? labels : {};
      }
      function getValueArg(labels, value) {
        return isObject(labels) ? value : labels;
      }
      module.exports = Gauge;
    }
  });

  // ../../node_modules/bare-prom-client/lib/histogram.js
  var require_histogram = __commonJS({
    "../../node_modules/bare-prom-client/lib/histogram.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var util = __require("util");
      var {
        getLabels,
        hashObject,
        isObject,
        removeLabels,
        nowTimestamp
      } = require_util();
      var { validateLabel } = require_validation();
      var { Metric } = require_metric();
      var Exemplar = require_exemplar();
      var Histogram = class extends Metric {
        constructor(config) {
          super(config, {
            buckets: [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]
          });
          this.type = "histogram";
          this.defaultLabels = {};
          this.defaultExemplarLabelSet = {};
          this.enableExemplars = false;
          for (const label of this.labelNames) {
            if (label === "le") {
              throw new Error("le is a reserved label keyword");
            }
          }
          this.upperBounds = this.buckets;
          this.bucketValues = this.upperBounds.reduce((acc, upperBound) => {
            acc[upperBound] = 0;
            return acc;
          }, {});
          if (config.enableExemplars) {
            this.enableExemplars = true;
            this.bucketExemplars = this.upperBounds.reduce((acc, upperBound) => {
              acc[upperBound] = null;
              return acc;
            }, {});
            Object.freeze(this.bucketExemplars);
            this.observe = this.observeWithExemplar;
          } else {
            this.observe = this.observeWithoutExemplar;
          }
          Object.freeze(this.bucketValues);
          Object.freeze(this.upperBounds);
          if (this.labelNames.length === 0) {
            this.hashMap = {
              [hashObject({})]: createBaseValues(
                {},
                this.bucketValues,
                this.bucketExemplars
              )
            };
          }
        }
        /**
         * Observe a value in histogram
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @param {Number} value - Value to observe in the histogram
         * @returns {void}
         */
        observeWithoutExemplar(labels, value) {
          observe.call(this, labels === 0 ? 0 : labels || {})(value);
        }
        observeWithExemplar({
          labels = this.defaultLabels,
          value,
          exemplarLabels = this.defaultExemplarLabelSet
        } = {}) {
          observe.call(this, labels === 0 ? 0 : labels || {})(value);
          this.updateExemplar(labels, value, exemplarLabels);
        }
        updateExemplar(labels, value, exemplarLabels) {
          if (Object.keys(exemplarLabels).length === 0) return;
          const hash = hashObject(labels, this.sortedLabelNames);
          const bound = findBound(this.upperBounds, value);
          const { bucketExemplars } = this.hashMap[hash];
          let exemplar = bucketExemplars[bound];
          if (!isObject(exemplar)) {
            exemplar = new Exemplar();
            bucketExemplars[bound] = exemplar;
          }
          exemplar.validateExemplarLabelSet(exemplarLabels);
          exemplar.labelSet = exemplarLabels;
          exemplar.value = value;
          exemplar.timestamp = nowTimestamp();
        }
        async get() {
          const data = await this.getForPromString();
          data.values = data.values.map(splayLabels);
          return data;
        }
        async getForPromString() {
          if (this.collect) {
            const v = this.collect();
            if (v instanceof Promise) await v;
          }
          const data = Object.values(this.hashMap);
          const values = data.map(extractBucketValuesForExport(this)).reduce(addSumAndCountForExport(this), []);
          return {
            name: this.name,
            help: this.help,
            type: this.type,
            values,
            aggregator: this.aggregator
          };
        }
        reset() {
          this.hashMap = {};
        }
        /**
         * Initialize the metrics for the given combination of labels to zero
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @returns {void}
         */
        zero(labels) {
          const hash = hashObject(labels, this.sortedLabelNames);
          this.hashMap[hash] = createBaseValues(
            labels,
            this.bucketValues,
            this.bucketExemplars
          );
        }
        /**
         * Start a timer that could be used to logging durations
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @param {object} exemplarLabels - Object with labels for exemplar where key is the label key and value is label value. Can only be one level deep
         * @returns {function} - Function to invoke when you want to stop the timer and observe the duration in seconds
         * @example
         * var end = histogram.startTimer();
         * makeExpensiveXHRRequest(function(err, res) {
         * 	const duration = end(); //Observe the duration of expensiveXHRRequest and returns duration in seconds
         * 	console.log('Duration', duration);
         * });
         */
        startTimer(labels, exemplarLabels) {
          return this.enableExemplars ? startTimerWithExemplar.call(this, labels, exemplarLabels)() : startTimer.call(this, labels)();
        }
        labels(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          return {
            observe: observe.call(this, labels),
            startTimer: startTimer.call(this, labels)
          };
        }
        remove(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          removeLabels.call(this, this.hashMap, labels, this.sortedLabelNames);
        }
      };
      function startTimer(startLabels) {
        return () => {
          const start = process.hrtime();
          return (endLabels) => {
            const delta = process.hrtime(start);
            const value = delta[0] + delta[1] / 1e9;
            this.observe(Object.assign({}, startLabels, endLabels), value);
            return value;
          };
        };
      }
      function startTimerWithExemplar(startLabels, startExemplarLabels) {
        return () => {
          const start = process.hrtime();
          return (endLabels, endExemplarLabels) => {
            const delta = process.hrtime(start);
            const value = delta[0] + delta[1] / 1e9;
            this.observe({
              labels: Object.assign({}, startLabels, endLabels),
              value,
              exemplarLabels: Object.assign(
                {},
                startExemplarLabels,
                endExemplarLabels
              )
            });
            return value;
          };
        };
      }
      function setValuePair(labels, value, metricName, exemplar, sharedLabels = {}) {
        return {
          labels,
          sharedLabels,
          value,
          metricName,
          exemplar
        };
      }
      function findBound(upperBounds, value) {
        for (let i = 0; i < upperBounds.length; i++) {
          const bound = upperBounds[i];
          if (value <= bound) {
            return bound;
          }
        }
        return -1;
      }
      function observe(labels) {
        return (value) => {
          const labelValuePair = convertLabelsAndValues(labels, value);
          validateLabel(this.labelNames, labelValuePair.labels);
          if (!Number.isFinite(labelValuePair.value)) {
            throw new TypeError(
              `Value is not a valid number: ${util.format(labelValuePair.value)}`
            );
          }
          const hash = hashObject(labelValuePair.labels, this.sortedLabelNames);
          let valueFromMap = this.hashMap[hash];
          if (!valueFromMap) {
            valueFromMap = createBaseValues(
              labelValuePair.labels,
              this.bucketValues,
              this.bucketExemplars
            );
          }
          const b = findBound(this.upperBounds, labelValuePair.value);
          valueFromMap.sum += labelValuePair.value;
          valueFromMap.count += 1;
          if (Object.prototype.hasOwnProperty.call(valueFromMap.bucketValues, b)) {
            valueFromMap.bucketValues[b] += 1;
          }
          this.hashMap[hash] = valueFromMap;
        };
      }
      function createBaseValues(labels, bucketValues, bucketExemplars) {
        const result = {
          labels,
          bucketValues: { ...bucketValues },
          sum: 0,
          count: 0
        };
        if (bucketExemplars) {
          result.bucketExemplars = { ...bucketExemplars };
        }
        return result;
      }
      function convertLabelsAndValues(labels, value) {
        return isObject(labels) ? {
          labels,
          value
        } : {
          value: labels,
          labels: {}
        };
      }
      function extractBucketValuesForExport(histogram) {
        const name = `${histogram.name}_bucket`;
        return (bucketData) => {
          let acc = 0;
          const buckets = histogram.upperBounds.map((upperBound) => {
            acc += bucketData.bucketValues[upperBound];
            return setValuePair(
              { le: upperBound },
              acc,
              name,
              bucketData.bucketExemplars ? bucketData.bucketExemplars[upperBound] : null,
              bucketData.labels
            );
          });
          return { buckets, data: bucketData };
        };
      }
      function addSumAndCountForExport(histogram) {
        return (acc, d) => {
          acc.push(...d.buckets);
          const infLabel = { le: "+Inf" };
          acc.push(
            setValuePair(
              infLabel,
              d.data.count,
              `${histogram.name}_bucket`,
              d.data.bucketExemplars ? d.data.bucketExemplars["-1"] : null,
              d.data.labels
            ),
            setValuePair(
              {},
              d.data.sum,
              `${histogram.name}_sum`,
              void 0,
              d.data.labels
            ),
            setValuePair(
              {},
              d.data.count,
              `${histogram.name}_count`,
              void 0,
              d.data.labels
            )
          );
          return acc;
        };
      }
      function splayLabels(bucket) {
        const { sharedLabels, labels, ...newBucket } = bucket;
        for (const label of Object.keys(sharedLabels)) {
          labels[label] = sharedLabels[label];
        }
        newBucket.labels = labels;
        return newBucket;
      }
      module.exports = Histogram;
    }
  });

  // ../../node_modules/bintrees/lib/treebase.js
  var require_treebase = __commonJS({
    "../../node_modules/bintrees/lib/treebase.js"(exports, module) {
      function TreeBase() {
      }
      TreeBase.prototype.clear = function() {
        this._root = null;
        this.size = 0;
      };
      TreeBase.prototype.find = function(data) {
        var res = this._root;
        while (res !== null) {
          var c = this._comparator(data, res.data);
          if (c === 0) {
            return res.data;
          } else {
            res = res.get_child(c > 0);
          }
        }
        return null;
      };
      TreeBase.prototype.findIter = function(data) {
        var res = this._root;
        var iter = this.iterator();
        while (res !== null) {
          var c = this._comparator(data, res.data);
          if (c === 0) {
            iter._cursor = res;
            return iter;
          } else {
            iter._ancestors.push(res);
            res = res.get_child(c > 0);
          }
        }
        return null;
      };
      TreeBase.prototype.lowerBound = function(item) {
        var cur = this._root;
        var iter = this.iterator();
        var cmp = this._comparator;
        while (cur !== null) {
          var c = cmp(item, cur.data);
          if (c === 0) {
            iter._cursor = cur;
            return iter;
          }
          iter._ancestors.push(cur);
          cur = cur.get_child(c > 0);
        }
        for (var i = iter._ancestors.length - 1; i >= 0; --i) {
          cur = iter._ancestors[i];
          if (cmp(item, cur.data) < 0) {
            iter._cursor = cur;
            iter._ancestors.length = i;
            return iter;
          }
        }
        iter._ancestors.length = 0;
        return iter;
      };
      TreeBase.prototype.upperBound = function(item) {
        var iter = this.lowerBound(item);
        var cmp = this._comparator;
        while (iter.data() !== null && cmp(iter.data(), item) === 0) {
          iter.next();
        }
        return iter;
      };
      TreeBase.prototype.min = function() {
        var res = this._root;
        if (res === null) {
          return null;
        }
        while (res.left !== null) {
          res = res.left;
        }
        return res.data;
      };
      TreeBase.prototype.max = function() {
        var res = this._root;
        if (res === null) {
          return null;
        }
        while (res.right !== null) {
          res = res.right;
        }
        return res.data;
      };
      TreeBase.prototype.iterator = function() {
        return new Iterator(this);
      };
      TreeBase.prototype.each = function(cb) {
        var it = this.iterator(), data;
        while ((data = it.next()) !== null) {
          if (cb(data) === false) {
            return;
          }
        }
      };
      TreeBase.prototype.reach = function(cb) {
        var it = this.iterator(), data;
        while ((data = it.prev()) !== null) {
          if (cb(data) === false) {
            return;
          }
        }
      };
      function Iterator(tree) {
        this._tree = tree;
        this._ancestors = [];
        this._cursor = null;
      }
      Iterator.prototype.data = function() {
        return this._cursor !== null ? this._cursor.data : null;
      };
      Iterator.prototype.next = function() {
        if (this._cursor === null) {
          var root = this._tree._root;
          if (root !== null) {
            this._minNode(root);
          }
        } else {
          if (this._cursor.right === null) {
            var save;
            do {
              save = this._cursor;
              if (this._ancestors.length) {
                this._cursor = this._ancestors.pop();
              } else {
                this._cursor = null;
                break;
              }
            } while (this._cursor.right === save);
          } else {
            this._ancestors.push(this._cursor);
            this._minNode(this._cursor.right);
          }
        }
        return this._cursor !== null ? this._cursor.data : null;
      };
      Iterator.prototype.prev = function() {
        if (this._cursor === null) {
          var root = this._tree._root;
          if (root !== null) {
            this._maxNode(root);
          }
        } else {
          if (this._cursor.left === null) {
            var save;
            do {
              save = this._cursor;
              if (this._ancestors.length) {
                this._cursor = this._ancestors.pop();
              } else {
                this._cursor = null;
                break;
              }
            } while (this._cursor.left === save);
          } else {
            this._ancestors.push(this._cursor);
            this._maxNode(this._cursor.left);
          }
        }
        return this._cursor !== null ? this._cursor.data : null;
      };
      Iterator.prototype._minNode = function(start) {
        while (start.left !== null) {
          this._ancestors.push(start);
          start = start.left;
        }
        this._cursor = start;
      };
      Iterator.prototype._maxNode = function(start) {
        while (start.right !== null) {
          this._ancestors.push(start);
          start = start.right;
        }
        this._cursor = start;
      };
      module.exports = TreeBase;
    }
  });

  // ../../node_modules/bintrees/lib/rbtree.js
  var require_rbtree = __commonJS({
    "../../node_modules/bintrees/lib/rbtree.js"(exports, module) {
      var TreeBase = require_treebase();
      function Node(data) {
        this.data = data;
        this.left = null;
        this.right = null;
        this.red = true;
      }
      Node.prototype.get_child = function(dir) {
        return dir ? this.right : this.left;
      };
      Node.prototype.set_child = function(dir, val) {
        if (dir) {
          this.right = val;
        } else {
          this.left = val;
        }
      };
      function RBTree(comparator) {
        this._root = null;
        this._comparator = comparator;
        this.size = 0;
      }
      RBTree.prototype = new TreeBase();
      RBTree.prototype.insert = function(data) {
        var ret2 = false;
        if (this._root === null) {
          this._root = new Node(data);
          ret2 = true;
          this.size++;
        } else {
          var head = new Node(void 0);
          var dir = 0;
          var last = 0;
          var gp = null;
          var ggp = head;
          var p = null;
          var node = this._root;
          ggp.right = this._root;
          while (true) {
            if (node === null) {
              node = new Node(data);
              p.set_child(dir, node);
              ret2 = true;
              this.size++;
            } else if (is_red(node.left) && is_red(node.right)) {
              node.red = true;
              node.left.red = false;
              node.right.red = false;
            }
            if (is_red(node) && is_red(p)) {
              var dir2 = ggp.right === gp;
              if (node === p.get_child(last)) {
                ggp.set_child(dir2, single_rotate(gp, !last));
              } else {
                ggp.set_child(dir2, double_rotate(gp, !last));
              }
            }
            var cmp = this._comparator(node.data, data);
            if (cmp === 0) {
              break;
            }
            last = dir;
            dir = cmp < 0;
            if (gp !== null) {
              ggp = gp;
            }
            gp = p;
            p = node;
            node = node.get_child(dir);
          }
          this._root = head.right;
        }
        this._root.red = false;
        return ret2;
      };
      RBTree.prototype.remove = function(data) {
        if (this._root === null) {
          return false;
        }
        var head = new Node(void 0);
        var node = head;
        node.right = this._root;
        var p = null;
        var gp = null;
        var found = null;
        var dir = 1;
        while (node.get_child(dir) !== null) {
          var last = dir;
          gp = p;
          p = node;
          node = node.get_child(dir);
          var cmp = this._comparator(data, node.data);
          dir = cmp > 0;
          if (cmp === 0) {
            found = node;
          }
          if (!is_red(node) && !is_red(node.get_child(dir))) {
            if (is_red(node.get_child(!dir))) {
              var sr = single_rotate(node, dir);
              p.set_child(last, sr);
              p = sr;
            } else if (!is_red(node.get_child(!dir))) {
              var sibling = p.get_child(!last);
              if (sibling !== null) {
                if (!is_red(sibling.get_child(!last)) && !is_red(sibling.get_child(last))) {
                  p.red = false;
                  sibling.red = true;
                  node.red = true;
                } else {
                  var dir2 = gp.right === p;
                  if (is_red(sibling.get_child(last))) {
                    gp.set_child(dir2, double_rotate(p, last));
                  } else if (is_red(sibling.get_child(!last))) {
                    gp.set_child(dir2, single_rotate(p, last));
                  }
                  var gpc = gp.get_child(dir2);
                  gpc.red = true;
                  node.red = true;
                  gpc.left.red = false;
                  gpc.right.red = false;
                }
              }
            }
          }
        }
        if (found !== null) {
          found.data = node.data;
          p.set_child(p.right === node, node.get_child(node.left === null));
          this.size--;
        }
        this._root = head.right;
        if (this._root !== null) {
          this._root.red = false;
        }
        return found !== null;
      };
      function is_red(node) {
        return node !== null && node.red;
      }
      function single_rotate(root, dir) {
        var save = root.get_child(!dir);
        root.set_child(!dir, save.get_child(dir));
        save.set_child(dir, root);
        root.red = true;
        save.red = false;
        return save;
      }
      function double_rotate(root, dir) {
        root.set_child(!dir, single_rotate(root.get_child(!dir), !dir));
        return single_rotate(root, dir);
      }
      module.exports = RBTree;
    }
  });

  // ../../node_modules/bintrees/lib/bintree.js
  var require_bintree = __commonJS({
    "../../node_modules/bintrees/lib/bintree.js"(exports, module) {
      var TreeBase = require_treebase();
      function Node(data) {
        this.data = data;
        this.left = null;
        this.right = null;
      }
      Node.prototype.get_child = function(dir) {
        return dir ? this.right : this.left;
      };
      Node.prototype.set_child = function(dir, val) {
        if (dir) {
          this.right = val;
        } else {
          this.left = val;
        }
      };
      function BinTree(comparator) {
        this._root = null;
        this._comparator = comparator;
        this.size = 0;
      }
      BinTree.prototype = new TreeBase();
      BinTree.prototype.insert = function(data) {
        if (this._root === null) {
          this._root = new Node(data);
          this.size++;
          return true;
        }
        var dir = 0;
        var p = null;
        var node = this._root;
        while (true) {
          if (node === null) {
            node = new Node(data);
            p.set_child(dir, node);
            ret = true;
            this.size++;
            return true;
          }
          if (this._comparator(node.data, data) === 0) {
            return false;
          }
          dir = this._comparator(node.data, data) < 0;
          p = node;
          node = node.get_child(dir);
        }
      };
      BinTree.prototype.remove = function(data) {
        if (this._root === null) {
          return false;
        }
        var head = new Node(void 0);
        var node = head;
        node.right = this._root;
        var p = null;
        var found = null;
        var dir = 1;
        while (node.get_child(dir) !== null) {
          p = node;
          node = node.get_child(dir);
          var cmp = this._comparator(data, node.data);
          dir = cmp > 0;
          if (cmp === 0) {
            found = node;
          }
        }
        if (found !== null) {
          found.data = node.data;
          p.set_child(p.right === node, node.get_child(node.left === null));
          this._root = head.right;
          this.size--;
          return true;
        } else {
          return false;
        }
      };
      module.exports = BinTree;
    }
  });

  // ../../node_modules/bintrees/index.js
  var require_bintrees = __commonJS({
    "../../node_modules/bintrees/index.js"(exports, module) {
      module.exports = {
        RBTree: require_rbtree(),
        BinTree: require_bintree()
      };
    }
  });

  // ../../node_modules/tdigest/tdigest.js
  var require_tdigest = __commonJS({
    "../../node_modules/tdigest/tdigest.js"(exports, module) {
      var RBTree = require_bintrees().RBTree;
      function TDigest(delta, K, CX) {
        this.discrete = delta === false;
        this.delta = delta || 0.01;
        this.K = K === void 0 ? 25 : K;
        this.CX = CX === void 0 ? 1.1 : CX;
        this.centroids = new RBTree(compare_centroid_means);
        this.nreset = 0;
        this.reset();
      }
      TDigest.prototype.reset = function() {
        this.centroids.clear();
        this.n = 0;
        this.nreset += 1;
        this.last_cumulate = 0;
      };
      TDigest.prototype.size = function() {
        return this.centroids.size;
      };
      TDigest.prototype.toArray = function(everything) {
        var result = [];
        if (everything) {
          this._cumulate(true);
          this.centroids.each(function(c) {
            result.push(c);
          });
        } else {
          this.centroids.each(function(c) {
            result.push({ mean: c.mean, n: c.n });
          });
        }
        return result;
      };
      TDigest.prototype.summary = function() {
        var approx = this.discrete ? "exact " : "approximating ";
        var s = [
          approx + this.n + " samples using " + this.size() + " centroids",
          "min = " + this.percentile(0),
          "Q1  = " + this.percentile(0.25),
          "Q2  = " + this.percentile(0.5),
          "Q3  = " + this.percentile(0.75),
          "max = " + this.percentile(1)
        ];
        return s.join("\n");
      };
      function compare_centroid_means(a, b) {
        return a.mean > b.mean ? 1 : a.mean < b.mean ? -1 : 0;
      }
      function compare_centroid_mean_cumns(a, b) {
        return a.mean_cumn - b.mean_cumn;
      }
      TDigest.prototype.push = function(x, n) {
        n = n || 1;
        x = Array.isArray(x) ? x : [x];
        for (var i = 0; i < x.length; i++) {
          this._digest(x[i], n);
        }
      };
      TDigest.prototype.push_centroid = function(c) {
        c = Array.isArray(c) ? c : [c];
        for (var i = 0; i < c.length; i++) {
          this._digest(c[i].mean, c[i].n);
        }
      };
      TDigest.prototype._cumulate = function(exact) {
        if (this.n === this.last_cumulate || !exact && this.CX && this.CX > this.n / this.last_cumulate) {
          return;
        }
        var cumn = 0;
        this.centroids.each(function(c) {
          c.mean_cumn = cumn + c.n / 2;
          cumn = c.cumn = cumn + c.n;
        });
        this.n = this.last_cumulate = cumn;
      };
      TDigest.prototype.find_nearest = function(x) {
        if (this.size() === 0) {
          return null;
        }
        var iter = this.centroids.lowerBound({ mean: x });
        var c = iter.data() === null ? iter.prev() : iter.data();
        if (c.mean === x || this.discrete) {
          return c;
        }
        var prev = iter.prev();
        if (prev && Math.abs(prev.mean - x) < Math.abs(c.mean - x)) {
          return prev;
        } else {
          return c;
        }
      };
      TDigest.prototype._new_centroid = function(x, n, cumn) {
        var c = { mean: x, n, cumn };
        this.centroids.insert(c);
        this.n += n;
        return c;
      };
      TDigest.prototype._addweight = function(nearest, x, n) {
        if (x !== nearest.mean) {
          nearest.mean += n * (x - nearest.mean) / (nearest.n + n);
        }
        nearest.cumn += n;
        nearest.mean_cumn += n / 2;
        nearest.n += n;
        this.n += n;
      };
      TDigest.prototype._digest = function(x, n) {
        var min = this.centroids.min();
        var max = this.centroids.max();
        var nearest = this.find_nearest(x);
        if (nearest && nearest.mean === x) {
          this._addweight(nearest, x, n);
        } else if (nearest === min) {
          this._new_centroid(x, n, 0);
        } else if (nearest === max) {
          this._new_centroid(x, n, this.n);
        } else if (this.discrete) {
          this._new_centroid(x, n, nearest.cumn);
        } else {
          var p = nearest.mean_cumn / this.n;
          var max_n = Math.floor(4 * this.n * this.delta * p * (1 - p));
          if (max_n - nearest.n >= n) {
            this._addweight(nearest, x, n);
          } else {
            this._new_centroid(x, n, nearest.cumn);
          }
        }
        this._cumulate(false);
        if (!this.discrete && this.K && this.size() > this.K / this.delta) {
          this.compress();
        }
      };
      TDigest.prototype.bound_mean = function(x) {
        var iter = this.centroids.upperBound({ mean: x });
        var lower = iter.prev();
        var upper = lower.mean === x ? lower : iter.next();
        return [lower, upper];
      };
      TDigest.prototype.p_rank = function(x_or_xlist) {
        var xs = Array.isArray(x_or_xlist) ? x_or_xlist : [x_or_xlist];
        var ps = xs.map(this._p_rank, this);
        return Array.isArray(x_or_xlist) ? ps : ps[0];
      };
      TDigest.prototype._p_rank = function(x) {
        if (this.size() === 0) {
          return void 0;
        } else if (x < this.centroids.min().mean) {
          return 0;
        } else if (x > this.centroids.max().mean) {
          return 1;
        }
        this._cumulate(true);
        var bound = this.bound_mean(x);
        var lower = bound[0], upper = bound[1];
        if (this.discrete) {
          return lower.cumn / this.n;
        } else {
          var cumn = lower.mean_cumn;
          if (lower !== upper) {
            cumn += (x - lower.mean) * (upper.mean_cumn - lower.mean_cumn) / (upper.mean - lower.mean);
          }
          return cumn / this.n;
        }
      };
      TDigest.prototype.bound_mean_cumn = function(cumn) {
        this.centroids._comparator = compare_centroid_mean_cumns;
        var iter = this.centroids.upperBound({ mean_cumn: cumn });
        this.centroids._comparator = compare_centroid_means;
        var lower = iter.prev();
        var upper = lower && lower.mean_cumn === cumn ? lower : iter.next();
        return [lower, upper];
      };
      TDigest.prototype.percentile = function(p_or_plist) {
        var ps = Array.isArray(p_or_plist) ? p_or_plist : [p_or_plist];
        var qs = ps.map(this._percentile, this);
        return Array.isArray(p_or_plist) ? qs : qs[0];
      };
      TDigest.prototype._percentile = function(p) {
        if (this.size() === 0) {
          return void 0;
        }
        this._cumulate(true);
        var h = this.n * p;
        var bound = this.bound_mean_cumn(h);
        var lower = bound[0], upper = bound[1];
        if (upper === lower || lower === null || upper === null) {
          return (lower || upper).mean;
        } else if (!this.discrete) {
          return lower.mean + (h - lower.mean_cumn) * (upper.mean - lower.mean) / (upper.mean_cumn - lower.mean_cumn);
        } else if (h <= lower.cumn) {
          return lower.mean;
        } else {
          return upper.mean;
        }
      };
      function pop_random(choices) {
        var idx = Math.floor(Math.random() * choices.length);
        return choices.splice(idx, 1)[0];
      }
      TDigest.prototype.compress = function() {
        if (this.compressing) {
          return;
        }
        var points = this.toArray();
        this.reset();
        this.compressing = true;
        while (points.length > 0) {
          this.push_centroid(pop_random(points));
        }
        this._cumulate(true);
        this.compressing = false;
      };
      function Digest(config) {
        this.config = config || {};
        this.mode = this.config.mode || "auto";
        TDigest.call(this, this.mode === "cont" ? config.delta : false);
        this.digest_ratio = this.config.ratio || 0.9;
        this.digest_thresh = this.config.thresh || 1e3;
        this.n_unique = 0;
      }
      Digest.prototype = Object.create(TDigest.prototype);
      Digest.prototype.constructor = Digest;
      Digest.prototype.push = function(x_or_xlist) {
        TDigest.prototype.push.call(this, x_or_xlist);
        this.check_continuous();
      };
      Digest.prototype._new_centroid = function(x, n, cumn) {
        this.n_unique += 1;
        TDigest.prototype._new_centroid.call(this, x, n, cumn);
      };
      Digest.prototype._addweight = function(nearest, x, n) {
        if (nearest.n === 1) {
          this.n_unique -= 1;
        }
        TDigest.prototype._addweight.call(this, nearest, x, n);
      };
      Digest.prototype.check_continuous = function() {
        if (this.mode !== "auto" || this.size() < this.digest_thresh) {
          return false;
        }
        if (this.n_unique / this.size() > this.digest_ratio) {
          this.mode = "cont";
          this.discrete = false;
          this.delta = this.config.delta || 0.01;
          this.compress();
          return true;
        }
        return false;
      };
      module.exports = {
        "TDigest": TDigest,
        "Digest": Digest
      };
    }
  });

  // ../../node_modules/bare-prom-client/lib/timeWindowQuantiles.js
  var require_timeWindowQuantiles = __commonJS({
    "../../node_modules/bare-prom-client/lib/timeWindowQuantiles.js"(exports, module) {
      "use strict";
      var { TDigest } = require_tdigest();
      var TimeWindowQuantiles = class {
        constructor(maxAgeSeconds, ageBuckets) {
          this.maxAgeSeconds = maxAgeSeconds || 0;
          this.ageBuckets = ageBuckets || 0;
          this.shouldRotate = maxAgeSeconds && ageBuckets;
          this.ringBuffer = Array(ageBuckets).fill(new TDigest());
          this.currentBuffer = 0;
          this.lastRotateTimestampMillis = Date.now();
          this.durationBetweenRotatesMillis = maxAgeSeconds * 1e3 / ageBuckets || Infinity;
        }
        size() {
          const bucket = rotate.call(this);
          return bucket.size();
        }
        percentile(quantile) {
          const bucket = rotate.call(this);
          return bucket.percentile(quantile);
        }
        push(value) {
          rotate.call(this);
          this.ringBuffer.forEach((bucket) => {
            bucket.push(value);
          });
        }
        reset() {
          this.ringBuffer.forEach((bucket) => {
            bucket.reset();
          });
        }
        compress() {
          this.ringBuffer.forEach((bucket) => {
            bucket.compress();
          });
        }
      };
      function rotate() {
        let timeSinceLastRotateMillis = Date.now() - this.lastRotateTimestampMillis;
        while (timeSinceLastRotateMillis > this.durationBetweenRotatesMillis && this.shouldRotate) {
          this.ringBuffer[this.currentBuffer] = new TDigest();
          if (++this.currentBuffer >= this.ringBuffer.length) {
            this.currentBuffer = 0;
          }
          timeSinceLastRotateMillis -= this.durationBetweenRotatesMillis;
          this.lastRotateTimestampMillis += this.durationBetweenRotatesMillis;
        }
        return this.ringBuffer[this.currentBuffer];
      }
      module.exports = TimeWindowQuantiles;
    }
  });

  // ../../node_modules/bare-prom-client/lib/summary.js
  var require_summary = __commonJS({
    "../../node_modules/bare-prom-client/lib/summary.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var util = __require("util");
      var { getLabels, hashObject, removeLabels } = require_util();
      var { validateLabel } = require_validation();
      var { Metric } = require_metric();
      var timeWindowQuantiles = require_timeWindowQuantiles();
      var DEFAULT_COMPRESS_COUNT = 1e3;
      var Summary = class extends Metric {
        constructor(config) {
          super(config, {
            percentiles: [0.01, 0.05, 0.5, 0.9, 0.95, 0.99, 0.999],
            compressCount: DEFAULT_COMPRESS_COUNT,
            hashMap: {}
          });
          this.type = "summary";
          for (const label of this.labelNames) {
            if (label === "quantile")
              throw new Error("quantile is a reserved label keyword");
          }
          if (this.labelNames.length === 0) {
            this.hashMap = {
              [hashObject({})]: {
                labels: {},
                td: new timeWindowQuantiles(this.maxAgeSeconds, this.ageBuckets),
                count: 0,
                sum: 0
              }
            };
          }
        }
        /**
         * Observe a value
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @param {Number} value - Value to observe
         * @returns {void}
         */
        observe(labels, value) {
          observe.call(this, labels === 0 ? 0 : labels || {})(value);
        }
        async get() {
          if (this.collect) {
            const v = this.collect();
            if (v instanceof Promise) await v;
          }
          const hashKeys = Object.keys(this.hashMap);
          const values = [];
          hashKeys.forEach((hashKey) => {
            const s = this.hashMap[hashKey];
            if (s) {
              if (this.pruneAgedBuckets && s.td.size() === 0) {
                delete this.hashMap[hashKey];
              } else {
                extractSummariesForExport(s, this.percentiles).forEach((v) => {
                  values.push(v);
                });
                values.push(getSumForExport(s, this));
                values.push(getCountForExport(s, this));
              }
            }
          });
          return {
            name: this.name,
            help: this.help,
            type: this.type,
            values,
            aggregator: this.aggregator
          };
        }
        reset() {
          const data = Object.values(this.hashMap);
          data.forEach((s) => {
            s.td.reset();
            s.count = 0;
            s.sum = 0;
          });
        }
        /**
         * Start a timer that could be used to logging durations
         * @param {object} labels - Object with labels where key is the label key and value is label value. Can only be one level deep
         * @returns {function} - Function to invoke when you want to stop the timer and observe the duration in seconds
         * @example
         * var end = summary.startTimer();
         * makeExpensiveXHRRequest(function(err, res) {
         *	end(); //Observe the duration of expensiveXHRRequest
         * });
         */
        startTimer(labels) {
          return startTimer.call(this, labels)();
        }
        labels(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          return {
            observe: observe.call(this, labels),
            startTimer: startTimer.call(this, labels)
          };
        }
        remove(...args) {
          const labels = getLabels(this.labelNames, args);
          validateLabel(this.labelNames, labels);
          removeLabels.call(this, this.hashMap, labels, this.sortedLabelNames);
        }
      };
      function extractSummariesForExport(summaryOfLabels, percentiles) {
        summaryOfLabels.td.compress();
        return percentiles.map((percentile) => {
          const percentileValue = summaryOfLabels.td.percentile(percentile);
          return {
            labels: Object.assign({ quantile: percentile }, summaryOfLabels.labels),
            value: percentileValue ? percentileValue : 0
          };
        });
      }
      function getCountForExport(value, summary) {
        return {
          metricName: `${summary.name}_count`,
          labels: value.labels,
          value: value.count
        };
      }
      function getSumForExport(value, summary) {
        return {
          metricName: `${summary.name}_sum`,
          labels: value.labels,
          value: value.sum
        };
      }
      function startTimer(startLabels) {
        return () => {
          const start = process.hrtime();
          return (endLabels) => {
            const delta = process.hrtime(start);
            const value = delta[0] + delta[1] / 1e9;
            this.observe(Object.assign({}, startLabels, endLabels), value);
            return value;
          };
        };
      }
      function observe(labels) {
        return (value) => {
          const labelValuePair = convertLabelsAndValues(labels, value);
          validateLabel(this.labelNames, labels);
          if (!Number.isFinite(labelValuePair.value)) {
            throw new TypeError(
              `Value is not a valid number: ${util.format(labelValuePair.value)}`
            );
          }
          const hash = hashObject(labelValuePair.labels, this.sortedLabelNames);
          let summaryOfLabel = this.hashMap[hash];
          if (!summaryOfLabel) {
            summaryOfLabel = {
              labels: labelValuePair.labels,
              td: new timeWindowQuantiles(this.maxAgeSeconds, this.ageBuckets),
              count: 0,
              sum: 0
            };
          }
          summaryOfLabel.td.push(labelValuePair.value);
          summaryOfLabel.count++;
          if (summaryOfLabel.count % this.compressCount === 0) {
            summaryOfLabel.td.compress();
          }
          summaryOfLabel.sum += labelValuePair.value;
          this.hashMap[hash] = summaryOfLabel;
        };
      }
      function convertLabelsAndValues(labels, value) {
        if (value === void 0) {
          return {
            value: labels,
            labels: {}
          };
        }
        return {
          labels,
          value
        };
      }
      module.exports = Summary;
    }
  });

  // ../../node_modules/bare-prom-client/lib/pushgateway.js
  var require_pushgateway = __commonJS({
    "../../node_modules/bare-prom-client/lib/pushgateway.js"(exports, module) {
      "use strict";
      var url = __require("url");
      var http = __require("http");
      var https = __require("https");
      var { gzipSync } = __require("zlib");
      var { globalRegistry } = require_registry();
      var Pushgateway = class {
        constructor(gatewayUrl, options, registry) {
          if (!registry) {
            registry = globalRegistry;
          }
          this.registry = registry;
          this.gatewayUrl = gatewayUrl;
          const { requireJobName, ...requestOptions } = {
            requireJobName: true,
            ...options
          };
          this.requireJobName = requireJobName;
          this.requestOptions = requestOptions;
        }
        pushAdd(params = {}) {
          if (this.requireJobName && !params.jobName) {
            throw new Error("Missing jobName parameter");
          }
          return useGateway.call(this, "POST", params.jobName, params.groupings);
        }
        push(params = {}) {
          if (this.requireJobName && !params.jobName) {
            throw new Error("Missing jobName parameter");
          }
          return useGateway.call(this, "PUT", params.jobName, params.groupings);
        }
        delete(params = {}) {
          if (this.requireJobName && !params.jobName) {
            throw new Error("Missing jobName parameter");
          }
          return useGateway.call(this, "DELETE", params.jobName, params.groupings);
        }
      };
      async function useGateway(method, job, groupings) {
        const gatewayUrlParsed = url.parse(this.gatewayUrl);
        const gatewayUrlPath = gatewayUrlParsed.pathname && gatewayUrlParsed.pathname !== "/" ? gatewayUrlParsed.pathname : "";
        const jobPath = job ? `/job/${encodeURIComponent(job)}${generateGroupings(groupings)}` : "";
        const path = `${gatewayUrlPath}/metrics${jobPath}`;
        const target = url.resolve(this.gatewayUrl, path);
        const requestParams = url.parse(target);
        const httpModule = isHttps(requestParams.href) ? https : http;
        const options = Object.assign(requestParams, this.requestOptions, {
          method
        });
        return new Promise((resolve, reject) => {
          if (method === "DELETE" && options.headers) {
            delete options.headers["Content-Encoding"];
          }
          const req = httpModule.request(options, (resp) => {
            let body = "";
            resp.setEncoding("utf8");
            resp.on("data", (chunk) => {
              body += chunk;
            });
            resp.on("end", () => {
              if (resp.statusCode >= 400) {
                reject(
                  new Error(`push failed with status ${resp.statusCode}, ${body}`)
                );
              } else {
                resolve({ resp, body });
              }
            });
          });
          req.on("error", (err) => {
            reject(err);
          });
          req.on("timeout", () => {
            req.destroy(new Error("Pushgateway request timed out"));
          });
          if (method !== "DELETE") {
            this.registry.metrics().then((metrics2) => {
              if (options.headers && options.headers["Content-Encoding"] === "gzip") {
                metrics2 = gzipSync(metrics2);
              }
              req.write(metrics2);
              req.end();
            }).catch((err) => {
              reject(err);
            });
          } else {
            req.end();
          }
        });
      }
      function generateGroupings(groupings) {
        if (!groupings) {
          return "";
        }
        return Object.keys(groupings).map(
          (key) => `/${encodeURIComponent(key)}/${encodeURIComponent(groupings[key])}`
        ).join("");
      }
      function isHttps(href) {
        return href.search(/^https/) !== -1;
      }
      module.exports = Pushgateway;
    }
  });

  // ../../node_modules/bare-prom-client/lib/bucketGenerators.js
  var require_bucketGenerators = __commonJS({
    "../../node_modules/bare-prom-client/lib/bucketGenerators.js"(exports) {
      "use strict";
      exports.linearBuckets = (start, width, count) => {
        if (count < 1) {
          throw new Error("Linear buckets needs a positive count");
        }
        const buckets = new Array(count);
        for (let i = 0; i < count; i++) {
          buckets[i] = start + i * width;
        }
        return buckets;
      };
      exports.exponentialBuckets = (start, factor, count) => {
        if (start <= 0) {
          throw new Error("Exponential buckets needs a positive start");
        }
        if (count < 1) {
          throw new Error("Exponential buckets needs a positive count");
        }
        if (factor <= 1) {
          throw new Error("Exponential buckets needs a factor greater than 1");
        }
        const buckets = new Array(count);
        for (let i = 0; i < count; i++) {
          buckets[i] = start;
          start *= factor;
        }
        return buckets;
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/version.js
  var VERSION;
  var init_version = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/version.js"() {
      VERSION = "1.9.1";
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
  function _makeCompatibilityCheck(ownVersion) {
    const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
    const rejectedVersions = /* @__PURE__ */ new Set();
    const myVersionMatch = ownVersion.match(re);
    if (!myVersionMatch) {
      return () => false;
    }
    const ownVersionParsed = {
      major: +myVersionMatch[1],
      minor: +myVersionMatch[2],
      patch: +myVersionMatch[3],
      prerelease: myVersionMatch[4]
    };
    if (ownVersionParsed.prerelease != null) {
      return function isExactmatch(globalVersion) {
        return globalVersion === ownVersion;
      };
    }
    function _reject(v) {
      rejectedVersions.add(v);
      return false;
    }
    function _accept(v) {
      acceptedVersions.add(v);
      return true;
    }
    return function isCompatible2(globalVersion) {
      if (acceptedVersions.has(globalVersion)) {
        return true;
      }
      if (rejectedVersions.has(globalVersion)) {
        return false;
      }
      const globalVersionMatch = globalVersion.match(re);
      if (!globalVersionMatch) {
        return _reject(globalVersion);
      }
      const globalVersionParsed = {
        major: +globalVersionMatch[1],
        minor: +globalVersionMatch[2],
        patch: +globalVersionMatch[3],
        prerelease: globalVersionMatch[4]
      };
      if (globalVersionParsed.prerelease != null) {
        return _reject(globalVersion);
      }
      if (ownVersionParsed.major !== globalVersionParsed.major) {
        return _reject(globalVersion);
      }
      if (ownVersionParsed.major === 0) {
        if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
          return _accept(globalVersion);
        }
        return _reject(globalVersion);
      }
      if (ownVersionParsed.minor <= globalVersionParsed.minor) {
        return _accept(globalVersion);
      }
      return _reject(globalVersion);
    };
  }
  var re, isCompatible;
  var init_semver = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
      init_version();
      re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
      isCompatible = _makeCompatibilityCheck(VERSION);
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
  function registerGlobal(type, instance, diag3, allowOverride = false) {
    var _a;
    const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
      version: VERSION
    };
    if (!allowOverride && api[type]) {
      const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
      diag3.error(err.stack || err.message);
      return false;
    }
    if (api.version !== VERSION) {
      const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
      diag3.error(err.stack || err.message);
      return false;
    }
    api[type] = instance;
    diag3.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
    return true;
  }
  function getGlobal(type) {
    var _a, _b;
    const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
    if (!globalVersion || !isCompatible(globalVersion)) {
      return;
    }
    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
  }
  function unregisterGlobal(type, diag3) {
    diag3.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
    const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
    if (api) {
      delete api[type];
    }
  }
  var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
  var init_global_utils = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
      init_version();
      init_semver();
      major = VERSION.split(".")[0];
      GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
      _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
  function logProxy(funcName, namespace, args) {
    const logger = getGlobal("diag");
    if (!logger) {
      return;
    }
    return logger[funcName](namespace, ...args);
  }
  var DiagComponentLogger;
  var init_ComponentLogger = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
      init_global_utils();
      DiagComponentLogger = class {
        constructor(props) {
          this._namespace = props.namespace || "DiagComponentLogger";
        }
        debug(...args) {
          return logProxy("debug", this._namespace, args);
        }
        error(...args) {
          return logProxy("error", this._namespace, args);
        }
        info(...args) {
          return logProxy("info", this._namespace, args);
        }
        warn(...args) {
          return logProxy("warn", this._namespace, args);
        }
        verbose(...args) {
          return logProxy("verbose", this._namespace, args);
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/diag/types.js
  var DiagLogLevel;
  var init_types = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
      (function(DiagLogLevel2) {
        DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
        DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
        DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
        DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
        DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
        DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
        DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
      })(DiagLogLevel || (DiagLogLevel = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
  function createLogLevelDiagLogger(maxLevel, logger) {
    if (maxLevel < DiagLogLevel.NONE) {
      maxLevel = DiagLogLevel.NONE;
    } else if (maxLevel > DiagLogLevel.ALL) {
      maxLevel = DiagLogLevel.ALL;
    }
    logger = logger || {};
    function _filterFunc(funcName, theLevel) {
      const theFunc = logger[funcName];
      if (typeof theFunc === "function" && maxLevel >= theLevel) {
        return theFunc.bind(logger);
      }
      return function() {
      };
    }
    return {
      error: _filterFunc("error", DiagLogLevel.ERROR),
      warn: _filterFunc("warn", DiagLogLevel.WARN),
      info: _filterFunc("info", DiagLogLevel.INFO),
      debug: _filterFunc("debug", DiagLogLevel.DEBUG),
      verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
    };
  }
  var init_logLevelLogger = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
      init_types();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/api/diag.js
  var API_NAME, DiagAPI;
  var init_diag = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
      init_ComponentLogger();
      init_logLevelLogger();
      init_types();
      init_global_utils();
      API_NAME = "diag";
      DiagAPI = class _DiagAPI {
        /** Get the singleton instance of the DiagAPI API */
        static instance() {
          if (!this._instance) {
            this._instance = new _DiagAPI();
          }
          return this._instance;
        }
        /**
         * Private internal constructor
         * @private
         */
        constructor() {
          function _logProxy(funcName) {
            return function(...args) {
              const logger = getGlobal("diag");
              if (!logger)
                return;
              return logger[funcName](...args);
            };
          }
          const self2 = this;
          const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
            var _a, _b, _c;
            if (logger === self2) {
              const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
              self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
              return false;
            }
            if (typeof optionsOrLogLevel === "number") {
              optionsOrLogLevel = {
                logLevel: optionsOrLogLevel
              };
            }
            const oldLogger = getGlobal("diag");
            const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
              const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
              oldLogger.warn(`Current logger will be overwritten from ${stack}`);
              newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
            }
            return registerGlobal("diag", newLogger, self2, true);
          };
          self2.setLogger = setLogger;
          self2.disable = () => {
            unregisterGlobal(API_NAME, self2);
          };
          self2.createComponentLogger = (options) => {
            return new DiagComponentLogger(options);
          };
          self2.verbose = _logProxy("verbose");
          self2.debug = _logProxy("debug");
          self2.info = _logProxy("info");
          self2.warn = _logProxy("warn");
          self2.error = _logProxy("error");
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
  var BaggageImpl;
  var init_baggage_impl = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js"() {
      BaggageImpl = class _BaggageImpl {
        constructor(entries) {
          this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
        }
        getEntry(key) {
          const entry = this._entries.get(key);
          if (!entry) {
            return void 0;
          }
          return Object.assign({}, entry);
        }
        getAllEntries() {
          return Array.from(this._entries.entries());
        }
        setEntry(key, entry) {
          const newBaggage = new _BaggageImpl(this._entries);
          newBaggage._entries.set(key, entry);
          return newBaggage;
        }
        removeEntry(key) {
          const newBaggage = new _BaggageImpl(this._entries);
          newBaggage._entries.delete(key);
          return newBaggage;
        }
        removeEntries(...keys) {
          const newBaggage = new _BaggageImpl(this._entries);
          for (const key of keys) {
            newBaggage._entries.delete(key);
          }
          return newBaggage;
        }
        clear() {
          return new _BaggageImpl();
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
  var baggageEntryMetadataSymbol;
  var init_symbol = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js"() {
      baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/baggage/utils.js
  function createBaggage(entries = {}) {
    return new BaggageImpl(new Map(Object.entries(entries)));
  }
  function baggageEntryMetadataFromString(str) {
    if (typeof str !== "string") {
      diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
      str = "";
    }
    return {
      __TYPE__: baggageEntryMetadataSymbol,
      toString() {
        return str;
      }
    };
  }
  var diag;
  var init_utils = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/baggage/utils.js"() {
      init_diag();
      init_baggage_impl();
      init_symbol();
      diag = DiagAPI.instance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/context/context.js
  function createContextKey(description) {
    return Symbol.for(description);
  }
  var BaseContext, ROOT_CONTEXT;
  var init_context = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/context/context.js"() {
      BaseContext = class _BaseContext {
        /**
         * Construct a new context which inherits values from an optional parent context.
         *
         * @param parentContext a context from which to inherit values
         */
        constructor(parentContext) {
          const self2 = this;
          self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
          self2.getValue = (key) => self2._currentContext.get(key);
          self2.setValue = (key, value) => {
            const context2 = new _BaseContext(self2._currentContext);
            context2._currentContext.set(key, value);
            return context2;
          };
          self2.deleteValue = (key) => {
            const context2 = new _BaseContext(self2._currentContext);
            context2._currentContext.delete(key);
            return context2;
          };
        }
      };
      ROOT_CONTEXT = new BaseContext();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
  var consoleMap, _originalConsoleMethods, DiagConsoleLogger;
  var init_consoleLogger = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js"() {
      consoleMap = [
        { n: "error", c: "error" },
        { n: "warn", c: "warn" },
        { n: "info", c: "info" },
        { n: "debug", c: "debug" },
        { n: "verbose", c: "trace" }
      ];
      _originalConsoleMethods = {};
      if (typeof console !== "undefined") {
        const keys = [
          "error",
          "warn",
          "info",
          "debug",
          "trace",
          "log"
        ];
        for (const key of keys) {
          if (typeof console[key] === "function") {
            _originalConsoleMethods[key] = console[key];
          }
        }
      }
      DiagConsoleLogger = class {
        constructor() {
          function _consoleFunc(funcName) {
            return function(...args) {
              let theFunc = _originalConsoleMethods[funcName];
              if (typeof theFunc !== "function") {
                theFunc = _originalConsoleMethods["log"];
              }
              if (typeof theFunc !== "function" && console) {
                theFunc = console[funcName];
                if (typeof theFunc !== "function") {
                  theFunc = console.log;
                }
              }
              if (typeof theFunc === "function") {
                return theFunc.apply(console, args);
              }
            };
          }
          for (let i = 0; i < consoleMap.length; i++) {
            this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
          }
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
  function createNoopMeter() {
    return NOOP_METER;
  }
  var NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopGaugeMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
  var init_NoopMeter = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js"() {
      NoopMeter = class {
        constructor() {
        }
        /**
         * @see {@link Meter.createGauge}
         */
        createGauge(_name, _options) {
          return NOOP_GAUGE_METRIC;
        }
        /**
         * @see {@link Meter.createHistogram}
         */
        createHistogram(_name, _options) {
          return NOOP_HISTOGRAM_METRIC;
        }
        /**
         * @see {@link Meter.createCounter}
         */
        createCounter(_name, _options) {
          return NOOP_COUNTER_METRIC;
        }
        /**
         * @see {@link Meter.createUpDownCounter}
         */
        createUpDownCounter(_name, _options) {
          return NOOP_UP_DOWN_COUNTER_METRIC;
        }
        /**
         * @see {@link Meter.createObservableGauge}
         */
        createObservableGauge(_name, _options) {
          return NOOP_OBSERVABLE_GAUGE_METRIC;
        }
        /**
         * @see {@link Meter.createObservableCounter}
         */
        createObservableCounter(_name, _options) {
          return NOOP_OBSERVABLE_COUNTER_METRIC;
        }
        /**
         * @see {@link Meter.createObservableUpDownCounter}
         */
        createObservableUpDownCounter(_name, _options) {
          return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
        }
        /**
         * @see {@link Meter.addBatchObservableCallback}
         */
        addBatchObservableCallback(_callback, _observables) {
        }
        /**
         * @see {@link Meter.removeBatchObservableCallback}
         */
        removeBatchObservableCallback(_callback) {
        }
      };
      NoopMetric = class {
      };
      NoopCounterMetric = class extends NoopMetric {
        add(_value, _attributes) {
        }
      };
      NoopUpDownCounterMetric = class extends NoopMetric {
        add(_value, _attributes) {
        }
      };
      NoopGaugeMetric = class extends NoopMetric {
        record(_value, _attributes) {
        }
      };
      NoopHistogramMetric = class extends NoopMetric {
        record(_value, _attributes) {
        }
      };
      NoopObservableMetric = class {
        addCallback(_callback) {
        }
        removeCallback(_callback) {
        }
      };
      NoopObservableCounterMetric = class extends NoopObservableMetric {
      };
      NoopObservableGaugeMetric = class extends NoopObservableMetric {
      };
      NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
      };
      NOOP_METER = new NoopMeter();
      NOOP_COUNTER_METRIC = new NoopCounterMetric();
      NOOP_GAUGE_METRIC = new NoopGaugeMetric();
      NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
      NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
      NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
      NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
      NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
  var ValueType;
  var init_Metric = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/metrics/Metric.js"() {
      (function(ValueType2) {
        ValueType2[ValueType2["INT"] = 0] = "INT";
        ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
      })(ValueType || (ValueType = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
  var defaultTextMapGetter, defaultTextMapSetter;
  var init_TextMapPropagator = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js"() {
      defaultTextMapGetter = {
        get(carrier, key) {
          if (carrier == null) {
            return void 0;
          }
          return carrier[key];
        },
        keys(carrier) {
          if (carrier == null) {
            return [];
          }
          return Object.keys(carrier);
        }
      };
      defaultTextMapSetter = {
        set(carrier, key, value) {
          if (carrier == null) {
            return;
          }
          carrier[key] = value;
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
  var NoopContextManager;
  var init_NoopContextManager = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
      init_context();
      NoopContextManager = class {
        active() {
          return ROOT_CONTEXT;
        }
        with(_context, fn, thisArg, ...args) {
          return fn.call(thisArg, ...args);
        }
        bind(_context, target) {
          return target;
        }
        enable() {
          return this;
        }
        disable() {
          return this;
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/api/context.js
  var API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
  var init_context2 = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/api/context.js"() {
      init_NoopContextManager();
      init_global_utils();
      init_diag();
      API_NAME2 = "context";
      NOOP_CONTEXT_MANAGER = new NoopContextManager();
      ContextAPI = class _ContextAPI {
        /** Empty private constructor prevents end users from constructing a new instance of the API */
        constructor() {
        }
        /** Get the singleton instance of the Context API */
        static getInstance() {
          if (!this._instance) {
            this._instance = new _ContextAPI();
          }
          return this._instance;
        }
        /**
         * Set the current context manager.
         *
         * @returns true if the context manager was successfully registered, else false
         */
        setGlobalContextManager(contextManager) {
          return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
        }
        /**
         * Get the currently active context
         */
        active() {
          return this._getContextManager().active();
        }
        /**
         * Execute a function with an active context
         *
         * @param context context to be active during function execution
         * @param fn function to execute in a context
         * @param thisArg optional receiver to be used for calling fn
         * @param args optional arguments forwarded to fn
         */
        with(context2, fn, thisArg, ...args) {
          return this._getContextManager().with(context2, fn, thisArg, ...args);
        }
        /**
         * Bind a context to a target function or event emitter
         *
         * @param context context to bind to the event emitter or function. Defaults to the currently active context
         * @param target function or event emitter to bind
         */
        bind(context2, target) {
          return this._getContextManager().bind(context2, target);
        }
        _getContextManager() {
          return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
        }
        /** Disable and remove the global context manager */
        disable() {
          this._getContextManager().disable();
          unregisterGlobal(API_NAME2, DiagAPI.instance());
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
  var TraceFlags;
  var init_trace_flags = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
      (function(TraceFlags2) {
        TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
        TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
      })(TraceFlags || (TraceFlags = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
  var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
  var init_invalid_span_constants = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
      init_trace_flags();
      INVALID_SPANID = "0000000000000000";
      INVALID_TRACEID = "00000000000000000000000000000000";
      INVALID_SPAN_CONTEXT = {
        traceId: INVALID_TRACEID,
        spanId: INVALID_SPANID,
        traceFlags: TraceFlags.NONE
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
  var NonRecordingSpan;
  var init_NonRecordingSpan = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
      init_invalid_span_constants();
      NonRecordingSpan = class {
        constructor(spanContext = INVALID_SPAN_CONTEXT) {
          this._spanContext = spanContext;
        }
        // Returns a SpanContext.
        spanContext() {
          return this._spanContext;
        }
        // By default does nothing
        setAttribute(_key, _value) {
          return this;
        }
        // By default does nothing
        setAttributes(_attributes) {
          return this;
        }
        // By default does nothing
        addEvent(_name, _attributes) {
          return this;
        }
        addLink(_link) {
          return this;
        }
        addLinks(_links) {
          return this;
        }
        // By default does nothing
        setStatus(_status) {
          return this;
        }
        // By default does nothing
        updateName(_name) {
          return this;
        }
        // By default does nothing
        end(_endTime) {
        }
        // isRecording always returns false for NonRecordingSpan.
        isRecording() {
          return false;
        }
        // By default does nothing
        recordException(_exception, _time) {
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
  function getSpan(context2) {
    return context2.getValue(SPAN_KEY) || void 0;
  }
  function getActiveSpan() {
    return getSpan(ContextAPI.getInstance().active());
  }
  function setSpan(context2, span) {
    return context2.setValue(SPAN_KEY, span);
  }
  function deleteSpan(context2) {
    return context2.deleteValue(SPAN_KEY);
  }
  function setSpanContext(context2, spanContext) {
    return setSpan(context2, new NonRecordingSpan(spanContext));
  }
  function getSpanContext(context2) {
    var _a;
    return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
  }
  var SPAN_KEY;
  var init_context_utils = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
      init_context();
      init_NonRecordingSpan();
      init_context2();
      SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
  function isValidHex(id, length) {
    if (typeof id !== "string" || id.length !== length)
      return false;
    let r = 0;
    for (let i = 0; i < id.length; i += 4) {
      r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
    }
    return r === length;
  }
  function isValidTraceId(traceId) {
    return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
  }
  function isValidSpanId(spanId) {
    return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
  }
  function isSpanContextValid(spanContext) {
    return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
  }
  function wrapSpanContext(spanContext) {
    return new NonRecordingSpan(spanContext);
  }
  var isHex;
  var init_spancontext_utils = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
      init_invalid_span_constants();
      init_NonRecordingSpan();
      isHex = new Uint8Array([
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        1,
        1,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        1,
        1,
        1,
        1,
        1
      ]);
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
  function isSpanContext(spanContext) {
    return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
  }
  var contextApi, NoopTracer;
  var init_NoopTracer = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
      init_context2();
      init_context_utils();
      init_NonRecordingSpan();
      init_spancontext_utils();
      contextApi = ContextAPI.getInstance();
      NoopTracer = class {
        // startSpan starts a noop span.
        startSpan(name, options, context2 = contextApi.active()) {
          const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
          if (root) {
            return new NonRecordingSpan();
          }
          const parentFromContext = context2 && getSpanContext(context2);
          if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
            return new NonRecordingSpan(parentFromContext);
          } else {
            return new NonRecordingSpan();
          }
        }
        startActiveSpan(name, arg2, arg3, arg4) {
          let opts;
          let ctx;
          let fn;
          if (arguments.length < 2) {
            return;
          } else if (arguments.length === 2) {
            fn = arg2;
          } else if (arguments.length === 3) {
            opts = arg2;
            fn = arg3;
          } else {
            opts = arg2;
            ctx = arg3;
            fn = arg4;
          }
          const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
          const span = this.startSpan(name, opts, parentContext);
          const contextWithSpanSet = setSpan(parentContext, span);
          return contextApi.with(contextWithSpanSet, fn, void 0, span);
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
  var NOOP_TRACER, ProxyTracer;
  var init_ProxyTracer = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
      init_NoopTracer();
      NOOP_TRACER = new NoopTracer();
      ProxyTracer = class {
        constructor(provider, name, version, options) {
          this._provider = provider;
          this.name = name;
          this.version = version;
          this.options = options;
        }
        startSpan(name, options, context2) {
          return this._getTracer().startSpan(name, options, context2);
        }
        startActiveSpan(_name, _options, _context, _fn) {
          const tracer = this._getTracer();
          return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
        }
        /**
         * Try to get a tracer from the proxy tracer provider.
         * If the proxy tracer provider has no delegate, return a noop tracer.
         */
        _getTracer() {
          if (this._delegate) {
            return this._delegate;
          }
          const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
          if (!tracer) {
            return NOOP_TRACER;
          }
          this._delegate = tracer;
          return this._delegate;
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
  var NoopTracerProvider;
  var init_NoopTracerProvider = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
      init_NoopTracer();
      NoopTracerProvider = class {
        getTracer(_name, _version, _options) {
          return new NoopTracer();
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
  var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
  var init_ProxyTracerProvider = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
      init_ProxyTracer();
      init_NoopTracerProvider();
      NOOP_TRACER_PROVIDER = new NoopTracerProvider();
      ProxyTracerProvider = class {
        /**
         * Get a {@link ProxyTracer}
         */
        getTracer(name, version, options) {
          var _a;
          return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
        }
        getDelegate() {
          var _a;
          return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
        }
        /**
         * Set the delegate tracer provider
         */
        setDelegate(delegate) {
          this._delegate = delegate;
        }
        getDelegateTracer(name, version, options) {
          var _a;
          return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
  var SamplingDecision;
  var init_SamplingResult = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js"() {
      (function(SamplingDecision2) {
        SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
        SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
        SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
      })(SamplingDecision || (SamplingDecision = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
  var SpanKind;
  var init_span_kind = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js"() {
      (function(SpanKind2) {
        SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
        SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
        SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
        SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
        SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
      })(SpanKind || (SpanKind = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/status.js
  var SpanStatusCode;
  var init_status = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
      (function(SpanStatusCode2) {
        SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
        SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
        SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
      })(SpanStatusCode || (SpanStatusCode = {}));
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-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_tracestate_validators = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js"() {
      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/api/build/esm/trace/internal/tracestate-impl.js
  var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceStateImpl;
  var init_tracestate_impl = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js"() {
      init_tracestate_validators();
      MAX_TRACE_STATE_ITEMS = 32;
      MAX_TRACE_STATE_LEN = 512;
      LIST_MEMBERS_SEPARATOR = ",";
      LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
      TraceStateImpl = class _TraceStateImpl {
        constructor(rawTraceState) {
          this._internalState = /* @__PURE__ */ new Map();
          if (rawTraceState)
            this._parse(rawTraceState);
        }
        set(key, value) {
          const traceState = this._clone();
          if (traceState._internalState.has(key)) {
            traceState._internalState.delete(key);
          }
          traceState._internalState.set(key, value);
          return traceState;
        }
        unset(key) {
          const traceState = this._clone();
          traceState._internalState.delete(key);
          return traceState;
        }
        get(key) {
          return this._internalState.get(key);
        }
        serialize() {
          return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
            agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
            return agg;
          }, []).join(LIST_MEMBERS_SEPARATOR);
        }
        _parse(rawTraceState) {
          if (rawTraceState.length > MAX_TRACE_STATE_LEN)
            return;
          this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
            const listMember = part.trim();
            const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
            if (i !== -1) {
              const key = listMember.slice(0, i);
              const value = listMember.slice(i + 1, part.length);
              if (validateKey(key) && validateValue(value)) {
                agg.set(key, value);
              } 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));
          }
        }
        // @ts-expect-error TS6133 Accessed in tests only.
        _keys() {
          return Array.from(this._internalState.keys()).reverse();
        }
        _clone() {
          const traceState = new _TraceStateImpl();
          traceState._internalState = new Map(this._internalState);
          return traceState;
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js
  function createTraceState(rawTraceState) {
    return new TraceStateImpl(rawTraceState);
  }
  var init_utils2 = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js"() {
      init_tracestate_impl();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/context-api.js
  var context;
  var init_context_api = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/context-api.js"() {
      init_context2();
      context = ContextAPI.getInstance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/diag-api.js
  var diag2;
  var init_diag_api = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
      init_diag();
      diag2 = DiagAPI.instance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
  var NoopMeterProvider, NOOP_METER_PROVIDER;
  var init_NoopMeterProvider = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js"() {
      init_NoopMeter();
      NoopMeterProvider = class {
        getMeter(_name, _version, _options) {
          return NOOP_METER;
        }
      };
      NOOP_METER_PROVIDER = new NoopMeterProvider();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/api/metrics.js
  var API_NAME3, MetricsAPI;
  var init_metrics = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/api/metrics.js"() {
      init_NoopMeterProvider();
      init_global_utils();
      init_diag();
      API_NAME3 = "metrics";
      MetricsAPI = class _MetricsAPI {
        /** Empty private constructor prevents end users from constructing a new instance of the API */
        constructor() {
        }
        /** Get the singleton instance of the Metrics API */
        static getInstance() {
          if (!this._instance) {
            this._instance = new _MetricsAPI();
          }
          return this._instance;
        }
        /**
         * Set the current global meter provider.
         * Returns true if the meter provider was successfully registered, else false.
         */
        setGlobalMeterProvider(provider) {
          return registerGlobal(API_NAME3, provider, DiagAPI.instance());
        }
        /**
         * Returns the global meter provider.
         */
        getMeterProvider() {
          return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
        }
        /**
         * Returns a meter from the global meter provider.
         */
        getMeter(name, version, options) {
          return this.getMeterProvider().getMeter(name, version, options);
        }
        /** Remove the global meter provider */
        disable() {
          unregisterGlobal(API_NAME3, DiagAPI.instance());
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/metrics-api.js
  var metrics;
  var init_metrics_api = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/metrics-api.js"() {
      init_metrics();
      metrics = MetricsAPI.getInstance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
  var NoopTextMapPropagator;
  var init_NoopTextMapPropagator = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js"() {
      NoopTextMapPropagator = class {
        /** Noop inject function does nothing */
        inject(_context, _carrier) {
        }
        /** Noop extract function does nothing and returns the input context */
        extract(context2, _carrier) {
          return context2;
        }
        fields() {
          return [];
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
  function getBaggage(context2) {
    return context2.getValue(BAGGAGE_KEY) || void 0;
  }
  function getActiveBaggage() {
    return getBaggage(ContextAPI.getInstance().active());
  }
  function setBaggage(context2, baggage) {
    return context2.setValue(BAGGAGE_KEY, baggage);
  }
  function deleteBaggage(context2) {
    return context2.deleteValue(BAGGAGE_KEY);
  }
  var BAGGAGE_KEY;
  var init_context_helpers = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js"() {
      init_context2();
      init_context();
      BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/api/propagation.js
  var API_NAME4, NOOP_TEXT_MAP_PROPAGATOR, PropagationAPI;
  var init_propagation = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/api/propagation.js"() {
      init_global_utils();
      init_NoopTextMapPropagator();
      init_TextMapPropagator();
      init_context_helpers();
      init_utils();
      init_diag();
      API_NAME4 = "propagation";
      NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
      PropagationAPI = class _PropagationAPI {
        /** Empty private constructor prevents end users from constructing a new instance of the API */
        constructor() {
          this.createBaggage = createBaggage;
          this.getBaggage = getBaggage;
          this.getActiveBaggage = getActiveBaggage;
          this.setBaggage = setBaggage;
          this.deleteBaggage = deleteBaggage;
        }
        /** Get the singleton instance of the Propagator API */
        static getInstance() {
          if (!this._instance) {
            this._instance = new _PropagationAPI();
          }
          return this._instance;
        }
        /**
         * Set the current propagator.
         *
         * @returns true if the propagator was successfully registered, else false
         */
        setGlobalPropagator(propagator) {
          return registerGlobal(API_NAME4, propagator, DiagAPI.instance());
        }
        /**
         * Inject context into a carrier to be propagated inter-process
         *
         * @param context Context carrying tracing data to inject
         * @param carrier carrier to inject context into
         * @param setter Function used to set values on the carrier
         */
        inject(context2, carrier, setter = defaultTextMapSetter) {
          return this._getGlobalPropagator().inject(context2, carrier, setter);
        }
        /**
         * Extract context from a carrier
         *
         * @param context Context which the newly created context will inherit from
         * @param carrier Carrier to extract context from
         * @param getter Function used to extract keys from a carrier
         */
        extract(context2, carrier, getter = defaultTextMapGetter) {
          return this._getGlobalPropagator().extract(context2, carrier, getter);
        }
        /**
         * Return a list of all fields which may be used by the propagator.
         */
        fields() {
          return this._getGlobalPropagator().fields();
        }
        /** Remove the global propagator */
        disable() {
          unregisterGlobal(API_NAME4, DiagAPI.instance());
        }
        _getGlobalPropagator() {
          return getGlobal(API_NAME4) || NOOP_TEXT_MAP_PROPAGATOR;
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/propagation-api.js
  var propagation;
  var init_propagation_api = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/propagation-api.js"() {
      init_propagation();
      propagation = PropagationAPI.getInstance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/api/trace.js
  var API_NAME5, TraceAPI;
  var init_trace = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/api/trace.js"() {
      init_global_utils();
      init_ProxyTracerProvider();
      init_spancontext_utils();
      init_context_utils();
      init_diag();
      API_NAME5 = "trace";
      TraceAPI = class _TraceAPI {
        /** Empty private constructor prevents end users from constructing a new instance of the API */
        constructor() {
          this._proxyTracerProvider = new ProxyTracerProvider();
          this.wrapSpanContext = wrapSpanContext;
          this.isSpanContextValid = isSpanContextValid;
          this.deleteSpan = deleteSpan;
          this.getSpan = getSpan;
          this.getActiveSpan = getActiveSpan;
          this.getSpanContext = getSpanContext;
          this.setSpan = setSpan;
          this.setSpanContext = setSpanContext;
        }
        /** Get the singleton instance of the Trace API */
        static getInstance() {
          if (!this._instance) {
            this._instance = new _TraceAPI();
          }
          return this._instance;
        }
        /**
         * Set the current global tracer.
         *
         * @returns true if the tracer provider was successfully registered, else false
         */
        setGlobalTracerProvider(provider) {
          const success = registerGlobal(API_NAME5, this._proxyTracerProvider, DiagAPI.instance());
          if (success) {
            this._proxyTracerProvider.setDelegate(provider);
          }
          return success;
        }
        /**
         * Returns the global tracer provider.
         */
        getTracerProvider() {
          return getGlobal(API_NAME5) || this._proxyTracerProvider;
        }
        /**
         * Returns a tracer from the global tracer provider.
         */
        getTracer(name, version) {
          return this.getTracerProvider().getTracer(name, version);
        }
        /** Remove the global tracer provider */
        disable() {
          unregisterGlobal(API_NAME5, DiagAPI.instance());
          this._proxyTracerProvider = new ProxyTracerProvider();
        }
      };
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/trace-api.js
  var trace;
  var init_trace_api = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/trace-api.js"() {
      init_trace();
      trace = TraceAPI.getInstance();
    }
  });

  // ../../node_modules/@opentelemetry/api/build/esm/index.js
  var esm_exports = {};
  __export(esm_exports, {
    DiagConsoleLogger: () => DiagConsoleLogger,
    DiagLogLevel: () => DiagLogLevel,
    INVALID_SPANID: () => INVALID_SPANID,
    INVALID_SPAN_CONTEXT: () => INVALID_SPAN_CONTEXT,
    INVALID_TRACEID: () => INVALID_TRACEID,
    ProxyTracer: () => ProxyTracer,
    ProxyTracerProvider: () => ProxyTracerProvider,
    ROOT_CONTEXT: () => ROOT_CONTEXT,
    SamplingDecision: () => SamplingDecision,
    SpanKind: () => SpanKind,
    SpanStatusCode: () => SpanStatusCode,
    TraceFlags: () => TraceFlags,
    ValueType: () => ValueType,
    baggageEntryMetadataFromString: () => baggageEntryMetadataFromString,
    context: () => context,
    createContextKey: () => createContextKey,
    createNoopMeter: () => createNoopMeter,
    createTraceState: () => createTraceState,
    default: () => esm_default,
    defaultTextMapGetter: () => defaultTextMapGetter,
    defaultTextMapSetter: () => defaultTextMapSetter,
    diag: () => diag2,
    isSpanContextValid: () => isSpanContextValid,
    isValidSpanId: () => isValidSpanId,
    isValidTraceId: () => isValidTraceId,
    metrics: () => metrics,
    propagation: () => propagation,
    trace: () => trace
  });
  var esm_default;
  var init_esm = __esm({
    "../../node_modules/@opentelemetry/api/build/esm/index.js"() {
      init_utils();
      init_context();
      init_consoleLogger();
      init_types();
      init_NoopMeter();
      init_Metric();
      init_TextMapPropagator();
      init_ProxyTracer();
      init_ProxyTracerProvider();
      init_SamplingResult();
      init_span_kind();
      init_status();
      init_trace_flags();
      init_utils2();
      init_spancontext_utils();
      init_invalid_span_constants();
      init_context_api();
      init_diag_api();
      init_metrics_api();
      init_propagation_api();
      init_trace_api();
      esm_default = {
        context,
        diag: diag2,
        metrics,
        propagation,
        trace
      };
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processCpuTotal.js
  var require_processCpuTotal = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processCpuTotal.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var OtelApi = (init_esm(), __toCommonJS(esm_exports));
      var Counter = require_counter();
      var PROCESS_CPU_USER_SECONDS = "process_cpu_user_seconds_total";
      var PROCESS_CPU_SYSTEM_SECONDS = "process_cpu_system_seconds_total";
      var PROCESS_CPU_SECONDS = "process_cpu_seconds_total";
      module.exports = (registry, config = {}) => {
        const registers = registry ? [registry] : void 0;
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const exemplars = config.enableExemplars ? config.enableExemplars : false;
        const labelNames = Object.keys(labels);
        let lastCpuUsage = process.cpuUsage();
        const cpuUserUsageCounter = new Counter({
          name: namePrefix + PROCESS_CPU_USER_SECONDS,
          help: "Total user CPU time spent in seconds.",
          enableExemplars: exemplars,
          registers,
          labelNames,
          // Use this one metric's `collect` to set all metrics' values.
          collect() {
            const cpuUsage = process.cpuUsage();
            const userUsageMicros = cpuUsage.user - lastCpuUsage.user;
            const systemUsageMicros = cpuUsage.system - lastCpuUsage.system;
            lastCpuUsage = cpuUsage;
            if (this.enableExemplars) {
              let exemplarLabels = {};
              const currentSpan = OtelApi.trace.getSpan(OtelApi.context.active());
              if (currentSpan) {
                exemplarLabels = {
                  traceId: currentSpan.spanContext().traceId,
                  spanId: currentSpan.spanContext().spanId
                };
              }
              cpuUserUsageCounter.inc({
                labels,
                value: userUsageMicros / 1e6,
                exemplarLabels
              });
              cpuSystemUsageCounter.inc({
                labels,
                value: systemUsageMicros / 1e6,
                exemplarLabels
              });
              cpuUsageCounter.inc({
                labels,
                value: (userUsageMicros + systemUsageMicros) / 1e6,
                exemplarLabels
              });
            } else {
              cpuUserUsageCounter.inc(labels, userUsageMicros / 1e6);
              cpuSystemUsageCounter.inc(labels, systemUsageMicros / 1e6);
              cpuUsageCounter.inc(
                labels,
                (userUsageMicros + systemUsageMicros) / 1e6
              );
            }
          }
        });
        const cpuSystemUsageCounter = new Counter({
          name: namePrefix + PROCESS_CPU_SYSTEM_SECONDS,
          help: "Total system CPU time spent in seconds.",
          enableExemplars: exemplars,
          registers,
          labelNames
        });
        const cpuUsageCounter = new Counter({
          name: namePrefix + PROCESS_CPU_SECONDS,
          help: "Total user and system CPU time spent in seconds.",
          enableExemplars: exemplars,
          registers,
          labelNames
        });
      };
      module.exports.metricNames = [
        PROCESS_CPU_USER_SECONDS,
        PROCESS_CPU_SYSTEM_SECONDS,
        PROCESS_CPU_SECONDS
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processStartTime.js
  var require_processStartTime = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processStartTime.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var startInSeconds = Math.round(Date.now() / 1e3 - process.uptime());
      var PROCESS_START_TIME = "process_start_time_seconds";
      module.exports = (registry, config = {}) => {
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + PROCESS_START_TIME,
          help: "Start time of the process since unix epoch in seconds.",
          registers: registry ? [registry] : void 0,
          labelNames,
          aggregator: "omit",
          collect() {
            this.set(labels, startInSeconds);
          }
        });
      };
      module.exports.metricNames = [PROCESS_START_TIME];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/osMemoryHeapLinux.js
  var require_osMemoryHeapLinux = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/osMemoryHeapLinux.js"(exports, module) {
      "use strict";
      var Gauge = require_gauge();
      var fs = __require("fs");
      var values = ["VmSize", "VmRSS", "VmData"];
      var PROCESS_RESIDENT_MEMORY = "process_resident_memory_bytes";
      var PROCESS_VIRTUAL_MEMORY = "process_virtual_memory_bytes";
      var PROCESS_HEAP = "process_heap_bytes";
      function structureOutput(input) {
        return input.split("\n").reduce((acc, string) => {
          if (!values.some((value2) => string.startsWith(value2))) {
            return acc;
          }
          const split = string.split(":");
          let value = split[1].trim();
          value = value.substr(0, value.length - 3);
          value = Number(value) * 1024;
          acc[split[0]] = value;
          return acc;
        }, {});
      }
      module.exports = (registry, config = {}) => {
        const registers = registry ? [registry] : void 0;
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        const residentMemGauge = new Gauge({
          name: namePrefix + PROCESS_RESIDENT_MEMORY,
          help: "Resident memory size in bytes.",
          registers,
          labelNames,
          // Use this one metric's `collect` to set all metrics' values.
          collect() {
            try {
              const stat = fs.readFileSync("/proc/self/status", "utf8");
              const structuredOutput = structureOutput(stat);
              residentMemGauge.set(labels, structuredOutput.VmRSS);
              virtualMemGauge.set(labels, structuredOutput.VmSize);
              heapSizeMemGauge.set(labels, structuredOutput.VmData);
            } catch {
            }
          }
        });
        const virtualMemGauge = new Gauge({
          name: namePrefix + PROCESS_VIRTUAL_MEMORY,
          help: "Virtual memory size in bytes.",
          registers,
          labelNames
        });
        const heapSizeMemGauge = new Gauge({
          name: namePrefix + PROCESS_HEAP,
          help: "Process heap size in bytes.",
          registers,
          labelNames
        });
      };
      module.exports.metricNames = [
        PROCESS_RESIDENT_MEMORY,
        PROCESS_VIRTUAL_MEMORY,
        PROCESS_HEAP
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/helpers/safeMemoryUsage.js
  var require_safeMemoryUsage = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/helpers/safeMemoryUsage.js"(exports, module) {
      "use strict";
      var process = __require("process");
      function safeMemoryUsage() {
        try {
          return process.memoryUsage();
        } catch {
          return;
        }
      }
      module.exports = safeMemoryUsage;
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/osMemoryHeap.js
  var require_osMemoryHeap = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/osMemoryHeap.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var linuxVariant = require_osMemoryHeapLinux();
      var safeMemoryUsage = require_safeMemoryUsage();
      var PROCESS_RESIDENT_MEMORY = "process_resident_memory_bytes";
      function notLinuxVariant(registry, config = {}) {
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + PROCESS_RESIDENT_MEMORY,
          help: "Resident memory size in bytes.",
          registers: registry ? [registry] : void 0,
          labelNames,
          collect() {
            const memUsage = safeMemoryUsage();
            if (memUsage) {
              this.set(labels, memUsage.rss);
            }
          }
        });
      }
      module.exports = (registry, config) => process.platform === "linux" ? linuxVariant(registry, config) : notLinuxVariant(registry, config);
      module.exports.metricNames = process.platform === "linux" ? linuxVariant.metricNames : [PROCESS_RESIDENT_MEMORY];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processOpenFileDescriptors.js
  var require_processOpenFileDescriptors = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processOpenFileDescriptors.js"(exports, module) {
      "use strict";
      var Gauge = require_gauge();
      var fs = __require("fs");
      var process = __require("process");
      var PROCESS_OPEN_FDS = "process_open_fds";
      module.exports = (registry, config = {}) => {
        if (process.platform !== "linux") {
          return;
        }
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + PROCESS_OPEN_FDS,
          help: "Number of open file descriptors.",
          registers: registry ? [registry] : void 0,
          labelNames,
          collect() {
            try {
              const fds = fs.readdirSync("/proc/self/fd");
              this.set(labels, fds.length - 1);
            } catch {
            }
          }
        });
      };
      module.exports.metricNames = [PROCESS_OPEN_FDS];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processMaxFileDescriptors.js
  var require_processMaxFileDescriptors = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processMaxFileDescriptors.js"(exports, module) {
      "use strict";
      var Gauge = require_gauge();
      var fs = __require("fs");
      var PROCESS_MAX_FDS = "process_max_fds";
      var maxFds;
      module.exports = (registry, config = {}) => {
        if (maxFds === void 0) {
          try {
            const limits = fs.readFileSync("/proc/self/limits", "utf8");
            const lines = limits.split("\n");
            for (const line of lines) {
              if (line.startsWith("Max open files")) {
                const parts = line.split(/  +/);
                maxFds = Number(parts[1]);
                break;
              }
            }
          } catch {
            return;
          }
        }
        if (maxFds === void 0) return;
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + PROCESS_MAX_FDS,
          help: "Maximum number of open file descriptors.",
          registers: registry ? [registry] : void 0,
          labelNames,
          collect() {
            if (maxFds !== void 0) this.set(labels, maxFds);
          }
        });
      };
      module.exports.metricNames = [PROCESS_MAX_FDS];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/eventLoopLag.js
  var require_eventLoopLag = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/eventLoopLag.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var perf_hooks;
      try {
        perf_hooks = __require("perf_hooks");
      } catch {
      }
      var NODEJS_EVENTLOOP_LAG = "nodejs_eventloop_lag_seconds";
      var NODEJS_EVENTLOOP_LAG_MIN = "nodejs_eventloop_lag_min_seconds";
      var NODEJS_EVENTLOOP_LAG_MAX = "nodejs_eventloop_lag_max_seconds";
      var NODEJS_EVENTLOOP_LAG_MEAN = "nodejs_eventloop_lag_mean_seconds";
      var NODEJS_EVENTLOOP_LAG_STDDEV = "nodejs_eventloop_lag_stddev_seconds";
      var NODEJS_EVENTLOOP_LAG_P50 = "nodejs_eventloop_lag_p50_seconds";
      var NODEJS_EVENTLOOP_LAG_P90 = "nodejs_eventloop_lag_p90_seconds";
      var NODEJS_EVENTLOOP_LAG_P99 = "nodejs_eventloop_lag_p99_seconds";
      function reportEventloopLag(start, gauge, labels) {
        const delta = process.hrtime(start);
        const nanosec = delta[0] * 1e9 + delta[1];
        const seconds = nanosec / 1e9;
        gauge.set(labels, seconds);
      }
      module.exports = (registry, config = {}) => {
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        const registers = registry ? [registry] : void 0;
        let collect = () => {
          const start = process.hrtime();
          setImmediate(reportEventloopLag, start, lag, labels);
        };
        if (perf_hooks && perf_hooks.monitorEventLoopDelay) {
          try {
            const histogram = perf_hooks.monitorEventLoopDelay({
              resolution: config.eventLoopMonitoringPrecision
            });
            histogram.enable();
            collect = () => {
              const start = process.hrtime();
              setImmediate(reportEventloopLag, start, lag, labels);
              lagMin.set(labels, histogram.min / 1e9);
              lagMax.set(labels, histogram.max / 1e9);
              lagMean.set(labels, histogram.mean / 1e9);
              lagStddev.set(labels, histogram.stddev / 1e9);
              lagP50.set(labels, histogram.percentile(50) / 1e9);
              lagP90.set(labels, histogram.percentile(90) / 1e9);
              lagP99.set(labels, histogram.percentile(99) / 1e9);
              histogram.reset();
            };
          } catch (e) {
            if (e.code === "ERR_NOT_IMPLEMENTED") {
              return;
            }
            throw e;
          }
        }
        const lag = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG,
          help: "Lag of event loop in seconds.",
          registers,
          labelNames,
          aggregator: "average",
          // Use this one metric's `collect` to set all metrics' values.
          collect
        });
        const lagMin = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_MIN,
          help: "The minimum recorded event loop delay.",
          registers,
          labelNames,
          aggregator: "min"
        });
        const lagMax = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_MAX,
          help: "The maximum recorded event loop delay.",
          registers,
          labelNames,
          aggregator: "max"
        });
        const lagMean = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_MEAN,
          help: "The mean of the recorded event loop delays.",
          registers,
          labelNames,
          aggregator: "average"
        });
        const lagStddev = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_STDDEV,
          help: "The standard deviation of the recorded event loop delays.",
          registers,
          labelNames,
          aggregator: "average"
        });
        const lagP50 = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_P50,
          help: "The 50th percentile of the recorded event loop delays.",
          registers,
          labelNames,
          aggregator: "average"
        });
        const lagP90 = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_P90,
          help: "The 90th percentile of the recorded event loop delays.",
          registers,
          labelNames,
          aggregator: "average"
        });
        const lagP99 = new Gauge({
          name: namePrefix + NODEJS_EVENTLOOP_LAG_P99,
          help: "The 99th percentile of the recorded event loop delays.",
          registers,
          labelNames,
          aggregator: "average"
        });
      };
      module.exports.metricNames = [
        NODEJS_EVENTLOOP_LAG,
        NODEJS_EVENTLOOP_LAG_MIN,
        NODEJS_EVENTLOOP_LAG_MAX,
        NODEJS_EVENTLOOP_LAG_MEAN,
        NODEJS_EVENTLOOP_LAG_STDDEV,
        NODEJS_EVENTLOOP_LAG_P50,
        NODEJS_EVENTLOOP_LAG_P90,
        NODEJS_EVENTLOOP_LAG_P99
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/helpers/processMetricsHelpers.js
  var require_processMetricsHelpers = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/helpers/processMetricsHelpers.js"(exports, module) {
      "use strict";
      function aggregateByObjectName(list) {
        const data = {};
        for (let i = 0; i < list.length; i++) {
          const listElement = list[i];
          if (!listElement || typeof listElement.constructor === "undefined") {
            continue;
          }
          if (Object.hasOwnProperty.call(data, listElement.constructor.name)) {
            data[listElement.constructor.name] += 1;
          } else {
            data[listElement.constructor.name] = 1;
          }
        }
        return data;
      }
      function updateMetrics(gauge, data, labels) {
        gauge.reset();
        for (const key in data) {
          gauge.set(Object.assign({ type: key }, labels || {}), data[key]);
        }
      }
      module.exports = {
        aggregateByObjectName,
        updateMetrics
      };
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processHandles.js
  var require_processHandles = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processHandles.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var { aggregateByObjectName } = require_processMetricsHelpers();
      var { updateMetrics } = require_processMetricsHelpers();
      var Gauge = require_gauge();
      var NODEJS_ACTIVE_HANDLES = "nodejs_active_handles";
      var NODEJS_ACTIVE_HANDLES_TOTAL = "nodejs_active_handles_total";
      module.exports = (registry, config = {}) => {
        if (typeof process._getActiveHandles !== "function") {
          return;
        }
        const registers = registry ? [registry] : void 0;
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_HANDLES,
          help: "Number of active libuv handles grouped by handle type. Every handle type is C++ class name.",
          labelNames: ["type", ...labelNames],
          registers,
          collect() {
            const handles = process._getActiveHandles();
            updateMetrics(this, aggregateByObjectName(handles), labels);
          }
        });
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_HANDLES_TOTAL,
          help: "Total number of active handles.",
          registers,
          labelNames,
          collect() {
            const handles = process._getActiveHandles();
            this.set(labels, handles.length);
          }
        });
      };
      module.exports.metricNames = [
        NODEJS_ACTIVE_HANDLES,
        NODEJS_ACTIVE_HANDLES_TOTAL
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processRequests.js
  var require_processRequests = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processRequests.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var { aggregateByObjectName } = require_processMetricsHelpers();
      var { updateMetrics } = require_processMetricsHelpers();
      var NODEJS_ACTIVE_REQUESTS = "nodejs_active_requests";
      var NODEJS_ACTIVE_REQUESTS_TOTAL = "nodejs_active_requests_total";
      module.exports = (registry, config = {}) => {
        if (typeof process._getActiveRequests !== "function") {
          return;
        }
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_REQUESTS,
          help: "Number of active libuv requests grouped by request type. Every request type is C++ class name.",
          labelNames: ["type", ...labelNames],
          registers: registry ? [registry] : void 0,
          collect() {
            const requests = process._getActiveRequests();
            updateMetrics(this, aggregateByObjectName(requests), labels);
          }
        });
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_REQUESTS_TOTAL,
          help: "Total number of active requests.",
          registers: registry ? [registry] : void 0,
          labelNames,
          collect() {
            const requests = process._getActiveRequests();
            this.set(labels, requests.length);
          }
        });
      };
      module.exports.metricNames = [
        NODEJS_ACTIVE_REQUESTS,
        NODEJS_ACTIVE_REQUESTS_TOTAL
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/processResources.js
  var require_processResources = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/processResources.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var { updateMetrics } = require_processMetricsHelpers();
      var NODEJS_ACTIVE_RESOURCES = "nodejs_active_resources";
      var NODEJS_ACTIVE_RESOURCES_TOTAL = "nodejs_active_resources_total";
      module.exports = (registry, config = {}) => {
        if (typeof process.getActiveResourcesInfo !== "function") {
          return;
        }
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_RESOURCES,
          help: "Number of active resources that are currently keeping the event loop alive, grouped by async resource type.",
          labelNames: ["type", ...labelNames],
          registers: registry ? [registry] : void 0,
          collect() {
            const resources = process.getActiveResourcesInfo();
            const data = {};
            for (let i = 0; i < resources.length; i++) {
              const resource = resources[i];
              if (Object.hasOwn(data, resource)) {
                data[resource] += 1;
              } else {
                data[resource] = 1;
              }
            }
            updateMetrics(this, data, labels);
          }
        });
        new Gauge({
          name: namePrefix + NODEJS_ACTIVE_RESOURCES_TOTAL,
          help: "Total number of active resources.",
          registers: registry ? [registry] : void 0,
          labelNames,
          collect() {
            const resources = process.getActiveResourcesInfo();
            this.set(labels, resources.length);
          }
        });
      };
      module.exports.metricNames = [
        NODEJS_ACTIVE_RESOURCES,
        NODEJS_ACTIVE_RESOURCES_TOTAL
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/heapSizeAndUsed.js
  var require_heapSizeAndUsed = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/heapSizeAndUsed.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var safeMemoryUsage = require_safeMemoryUsage();
      var NODEJS_HEAP_SIZE_TOTAL = "nodejs_heap_size_total_bytes";
      var NODEJS_HEAP_SIZE_USED = "nodejs_heap_size_used_bytes";
      var NODEJS_EXTERNAL_MEMORY = "nodejs_external_memory_bytes";
      module.exports = (registry, config = {}) => {
        if (typeof process.memoryUsage !== "function") {
          return;
        }
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        const registers = registry ? [registry] : void 0;
        const namePrefix = config.prefix ? config.prefix : "";
        const collect = () => {
          const memUsage = safeMemoryUsage();
          if (memUsage) {
            heapSizeTotal.set(labels, memUsage.heapTotal);
            heapSizeUsed.set(labels, memUsage.heapUsed);
            if (memUsage.external !== void 0) {
              externalMemUsed.set(labels, memUsage.external);
            }
          }
        };
        const heapSizeTotal = new Gauge({
          name: namePrefix + NODEJS_HEAP_SIZE_TOTAL,
          help: "Process heap size from Node.js in bytes.",
          registers,
          labelNames,
          // Use this one metric's `collect` to set all metrics' values.
          collect
        });
        const heapSizeUsed = new Gauge({
          name: namePrefix + NODEJS_HEAP_SIZE_USED,
          help: "Process heap size used from Node.js in bytes.",
          registers,
          labelNames
        });
        const externalMemUsed = new Gauge({
          name: namePrefix + NODEJS_EXTERNAL_MEMORY,
          help: "Node.js external memory size in bytes.",
          registers,
          labelNames
        });
      };
      module.exports.metricNames = [
        NODEJS_HEAP_SIZE_TOTAL,
        NODEJS_HEAP_SIZE_USED,
        NODEJS_EXTERNAL_MEMORY
      ];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/heapSpacesSizeAndUsed.js
  var require_heapSpacesSizeAndUsed = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/heapSpacesSizeAndUsed.js"(exports, module) {
      "use strict";
      var Gauge = require_gauge();
      var v8 = __require("v8");
      var METRICS = ["total", "used", "available"];
      var NODEJS_HEAP_SIZE = {};
      METRICS.forEach((metricType) => {
        NODEJS_HEAP_SIZE[metricType] = `nodejs_heap_space_size_${metricType}_bytes`;
      });
      module.exports = (registry, config = {}) => {
        try {
          v8.getHeapSpaceStatistics();
        } catch (e) {
          if (e.code === "ERR_NOT_IMPLEMENTED") {
            return;
          }
          throw e;
        }
        const registers = registry ? [registry] : void 0;
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = ["space", ...Object.keys(labels)];
        const gauges = {};
        METRICS.forEach((metricType) => {
          gauges[metricType] = new Gauge({
            name: namePrefix + NODEJS_HEAP_SIZE[metricType],
            help: `Process heap space size ${metricType} from Node.js in bytes.`,
            labelNames,
            registers
          });
        });
        gauges.total.collect = () => {
          for (const space of v8.getHeapSpaceStatistics()) {
            const spaceName = space.space_name.substr(
              0,
              space.space_name.indexOf("_space")
            );
            gauges.total.set({ space: spaceName, ...labels }, space.space_size);
            gauges.used.set({ space: spaceName, ...labels }, space.space_used_size);
            gauges.available.set(
              { space: spaceName, ...labels },
              space.space_available_size
            );
          }
        };
      };
      module.exports.metricNames = Object.values(NODEJS_HEAP_SIZE);
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/version.js
  var require_version = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/version.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Gauge = require_gauge();
      var version = process.version;
      var versionSegments = version.slice(1).split(".").map(Number);
      var NODE_VERSION_INFO = "nodejs_version_info";
      module.exports = (registry, config = {}) => {
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        new Gauge({
          name: namePrefix + NODE_VERSION_INFO,
          help: "Node.js version info.",
          labelNames: ["version", "major", "minor", "patch", ...labelNames],
          registers: registry ? [registry] : void 0,
          aggregator: "first",
          collect() {
            this.labels(
              version,
              versionSegments[0],
              versionSegments[1],
              versionSegments[2],
              ...Object.values(labels)
            ).set(1);
          }
        });
      };
      module.exports.metricNames = [NODE_VERSION_INFO];
    }
  });

  // ../../node_modules/bare-prom-client/lib/metrics/gc.js
  var require_gc = __commonJS({
    "../../node_modules/bare-prom-client/lib/metrics/gc.js"(exports, module) {
      "use strict";
      var Histogram = require_histogram();
      var perf_hooks;
      try {
        perf_hooks = __require("perf_hooks");
      } catch {
      }
      var NODEJS_GC_DURATION_SECONDS = "nodejs_gc_duration_seconds";
      var DEFAULT_GC_DURATION_BUCKETS = [1e-3, 0.01, 0.1, 1, 2, 5];
      var kinds = [];
      if (perf_hooks && perf_hooks.constants) {
        kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR] = "major";
        kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR] = "minor";
        kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL] = "incremental";
        kinds[perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB] = "weakcb";
      }
      module.exports = (registry, config = {}) => {
        if (!perf_hooks) {
          return;
        }
        const namePrefix = config.prefix ? config.prefix : "";
        const labels = config.labels ? config.labels : {};
        const labelNames = Object.keys(labels);
        const buckets = config.gcDurationBuckets ? config.gcDurationBuckets : DEFAULT_GC_DURATION_BUCKETS;
        const gcHistogram = new Histogram({
          name: namePrefix + NODEJS_GC_DURATION_SECONDS,
          help: "Garbage collection duration by kind, one of major, minor, incremental or weakcb.",
          labelNames: ["kind", ...labelNames],
          enableExemplars: false,
          buckets,
          registers: registry ? [registry] : void 0
        });
        const obs = new perf_hooks.PerformanceObserver((list) => {
          const entry = list.getEntries()[0];
          const kind = entry.detail ? kinds[entry.detail.kind] : kinds[entry.kind];
          gcHistogram.observe(Object.assign({ kind }, labels), entry.duration / 1e3);
        });
        obs.observe({ entryTypes: ["gc"] });
      };
      module.exports.metricNames = [NODEJS_GC_DURATION_SECONDS];
    }
  });

  // ../../node_modules/bare-prom-client/lib/defaultMetrics.js
  var require_defaultMetrics = __commonJS({
    "../../node_modules/bare-prom-client/lib/defaultMetrics.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var { isObject } = require_util();
      var processCpuTotal = require_processCpuTotal();
      var processStartTime = require_processStartTime();
      var osMemoryHeap = require_osMemoryHeap();
      var processOpenFileDescriptors = require_processOpenFileDescriptors();
      var processMaxFileDescriptors = require_processMaxFileDescriptors();
      var eventLoopLag = require_eventLoopLag();
      var processHandles = require_processHandles();
      var processRequests = require_processRequests();
      var processResources = require_processResources();
      var heapSizeAndUsed = require_heapSizeAndUsed();
      var heapSpacesSizeAndUsed = require_heapSpacesSizeAndUsed();
      var version = require_version();
      var gc = require_gc();
      var metrics2 = {
        processCpuTotal,
        processStartTime,
        osMemoryHeap,
        processOpenFileDescriptors,
        processMaxFileDescriptors,
        eventLoopLag,
        ...typeof process.getActiveResourcesInfo === "function" ? { processResources } : {},
        processHandles,
        processRequests,
        heapSizeAndUsed,
        heapSpacesSizeAndUsed,
        version,
        gc
      };
      var metricsList = Object.keys(metrics2);
      module.exports = function collectDefaultMetrics(config) {
        if (config !== null && config !== void 0 && !isObject(config)) {
          throw new TypeError("config must be null, undefined, or an object");
        }
        config = { eventLoopMonitoringPrecision: 10, ...config };
        for (const metric of Object.values(metrics2)) {
          metric(config.register, config);
        }
      };
      module.exports.metricsList = metricsList;
    }
  });

  // ../../node_modules/bare-prom-client/lib/metricAggregators.js
  var require_metricAggregators = __commonJS({
    "../../node_modules/bare-prom-client/lib/metricAggregators.js"(exports) {
      "use strict";
      var { Grouper, hashObject } = require_util();
      function AggregatorFactory(aggregatorFn) {
        return (metrics2) => {
          if (metrics2.length === 0) return;
          const result = {
            help: metrics2[0].help,
            name: metrics2[0].name,
            type: metrics2[0].type,
            values: [],
            aggregator: metrics2[0].aggregator
          };
          const byLabels = new Grouper();
          metrics2.forEach((metric) => {
            metric.values.forEach((value) => {
              const key = hashObject(value.labels);
              byLabels.add(`${value.metricName}_${key}`, value);
            });
          });
          byLabels.forEach((values) => {
            if (values.length === 0) return;
            const valObj = {
              value: aggregatorFn(values),
              labels: values[0].labels
            };
            if (values[0].metricName) {
              valObj.metricName = values[0].metricName;
            }
            result.values.push(valObj);
          });
          return result;
        };
      }
      exports.AggregatorFactory = AggregatorFactory;
      exports.aggregators = {
        /**
         * @return The sum of values.
         */
        sum: AggregatorFactory((v) => v.reduce((p, c) => p + c.value, 0)),
        /**
         * @return The first value.
         */
        first: AggregatorFactory((v) => v[0].value),
        /**
         * @return {undefined} Undefined; omits the metric.
         */
        omit: () => {
        },
        /**
         * @return The arithmetic mean of the values.
         */
        average: AggregatorFactory(
          (v) => v.reduce((p, c) => p + c.value, 0) / v.length
        ),
        /**
         * @return The minimum of the values.
         */
        min: AggregatorFactory(
          (v) => v.reduce((p, c) => Math.min(p, c.value), Infinity)
        ),
        /**
         * @return The maximum of the values.
         */
        max: AggregatorFactory(
          (v) => v.reduce((p, c) => Math.max(p, c.value), -Infinity)
        )
      };
    }
  });

  // ../../node_modules/bare-prom-client/lib/cluster.js
  var require_cluster = __commonJS({
    "../../node_modules/bare-prom-client/lib/cluster.js"(exports, module) {
      "use strict";
      var process = __require("process");
      var Registry = require_registry();
      var { Grouper } = require_util();
      var { aggregators } = require_metricAggregators();
      var cluster = () => {
        const data = __require("cluster");
        cluster = () => data;
        return data;
      };
      var GET_METRICS_REQ = "prom-client:getMetricsReq";
      var GET_METRICS_RES = "prom-client:getMetricsRes";
      var registries = [Registry.globalRegistry];
      var requestCtr = 0;
      var listenersAdded = false;
      var requests = /* @__PURE__ */ new Map();
      var AggregatorRegistry = class extends Registry {
        constructor(regContentType = Registry.PROMETHEUS_CONTENT_TYPE) {
          super(regContentType);
          addListeners();
        }
        /**
         * Gets aggregated metrics for all workers. The optional callback and
         * returned Promise resolve with the same value; either may be used.
         * @return {Promise<string>} Promise that resolves with the aggregated
         *   metrics.
         */
        clusterMetrics() {
          const requestId = requestCtr++;
          return new Promise((resolve, reject) => {
            let settled = false;
            function done(err, result) {
              if (settled) return;
              settled = true;
              if (err) reject(err);
              else resolve(result);
            }
            const request = {
              responses: [],
              pending: 0,
              done,
              errorTimeout: setTimeout(() => {
                const err = new Error("Operation timed out.");
                request.done(err);
              }, 5e3)
            };
            requests.set(requestId, request);
            const message = {
              type: GET_METRICS_REQ,
              requestId
            };
            for (const id in cluster().workers) {
              if (cluster().workers[id].isConnected()) {
                cluster().workers[id].send(message);
                request.pending++;
              }
            }
            if (request.pending === 0) {
              clearTimeout(request.errorTimeout);
              process.nextTick(() => done(null, ""));
            }
          });
        }
        get contentType() {
          return super.contentType;
        }
        /**
         * Creates a new Registry instance from an array of metrics that were
         * created by `registry.getMetricsAsJSON()`. Metrics are aggregated using
         * the method specified by their `aggregator` property, or by summation if
         * `aggregator` is undefined.
         * @param {Array} metricsArr Array of metrics, each of which created by
         *   `registry.getMetricsAsJSON()`.
         * @param {string} registryType content type of the new registry. Defaults
         * to PROMETHEUS_CONTENT_TYPE.
         * @return {Registry} aggregated registry.
         */
        static aggregate(metricsArr, registryType = Registry.PROMETHEUS_CONTENT_TYPE) {
          const aggregatedRegistry = new Registry();
          const metricsByName = new Grouper();
          aggregatedRegistry.setContentType(registryType);
          metricsArr.forEach((metrics2) => {
            metrics2.forEach((metric) => {
              metricsByName.add(metric.name, metric);
            });
          });
          metricsByName.forEach((metrics2) => {
            const aggregatorName = metrics2[0].aggregator;
            const aggregatorFn = aggregators[aggregatorName];
            if (typeof aggregatorFn !== "function") {
              throw new Error(`'${aggregatorName}' is not a defined aggregator.`);
            }
            const aggregatedMetric = aggregatorFn(metrics2);
            if (aggregatedMetric) {
              const aggregatedMetricWrapper = Object.assign(
                {
                  get: () => aggregatedMetric
                },
                aggregatedMetric
              );
              aggregatedRegistry.registerMetric(aggregatedMetricWrapper);
            }
          });
          return aggregatedRegistry;
        }
        /**
         * Sets the registry or registries to be aggregated. Call from workers to
         * use a registry/registries other than the default global registry.
         * @param {Array<Registry>|Registry} regs Registry or registries to be
         *   aggregated.
         * @return {void}
         */
        static setRegistries(regs) {
          if (!Array.isArray(regs)) regs = [regs];
          regs.forEach((reg) => {
            if (!(reg instanceof Registry)) {
              throw new TypeError(`Expected Registry, got ${typeof reg}`);
            }
          });
          registries = regs;
        }
      };
      function addListeners() {
        if (listenersAdded) return;
        listenersAdded = true;
        if (cluster().isMaster) {
          cluster().on("message", (worker, message) => {
            if (message.type === GET_METRICS_RES) {
              const request = requests.get(message.requestId);
              if (message.error) {
                request.done(new Error(message.error));
                return;
              }
              message.metrics.forEach((registry) => request.responses.push(registry));
              request.pending--;
              if (request.pending === 0) {
                requests.delete(message.requestId);
                clearTimeout(request.errorTimeout);
                const registry = AggregatorRegistry.aggregate(request.responses);
                const promString = registry.metrics();
                request.done(null, promString);
              }
            }
          });
        }
        if (cluster().isWorker) {
          process.on("message", (message) => {
            if (message.type === GET_METRICS_REQ) {
              Promise.all(registries.map((r) => r.getMetricsAsJSON())).then((metrics2) => {
                process.send({
                  type: GET_METRICS_RES,
                  requestId: message.requestId,
                  metrics: metrics2
                });
              }).catch((error) => {
                process.send({
                  type: GET_METRICS_RES,
                  requestId: message.requestId,
                  error: error.message
                });
              });
            }
          });
        }
      }
      module.exports = AggregatorRegistry;
    }
  });

  // ../../node_modules/bare-prom-client/index.js
  var require_bare_prom_client = __commonJS({
    "../../node_modules/bare-prom-client/index.js"(exports) {
      "use strict";
      exports.register = require_registry().globalRegistry;
      exports.Registry = require_registry();
      Object.defineProperty(exports, "contentType", {
        configurable: false,
        enumerable: true,
        get() {
          return exports.register.contentType;
        },
        set(value) {
          exports.register.setContentType(value);
        }
      });
      exports.prometheusContentType = exports.Registry.PROMETHEUS_CONTENT_TYPE;
      exports.openMetricsContentType = exports.Registry.OPENMETRICS_CONTENT_TYPE;
      exports.validateMetricName = require_validation().validateMetricName;
      exports.Counter = require_counter();
      exports.Gauge = require_gauge();
      exports.Histogram = require_histogram();
      exports.Summary = require_summary();
      exports.Pushgateway = require_pushgateway();
      exports.linearBuckets = require_bucketGenerators().linearBuckets;
      exports.exponentialBuckets = require_bucketGenerators().exponentialBuckets;
      exports.collectDefaultMetrics = require_defaultMetrics();
      exports.aggregators = require_metricAggregators().aggregators;
      exports.AggregatorRegistry = require_cluster();
    }
  });

  // ../../bare-lib-entry-barePromClient.js
  var bare_lib_entry_barePromClient_exports = {};
  __export(bare_lib_entry_barePromClient_exports, {
    default: () => bare_lib_entry_barePromClient_default
  });
  var import_bare_prom_client = __toESM(require_bare_prom_client());
  var bare_lib_entry_barePromClient_default = import_bare_prom_client.default;
  return __toCommonJS(bare_lib_entry_barePromClient_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["barePromClient"]=v;})();