autotel-subscribers 4.0.0

package/dist/mixpanel.js

@@ -0,0 +1,2932 @@
+import process2 from 'process';
+import os from 'os';
+import tty from 'tty';
+
+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.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports$1, module) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/common.js"(exports$1, module) {
+    function setup(env2) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env2).forEach((key) => {
+        createDebug[key] = env2[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/browser.js"(exports$1, module) {
+    exports$1.formatArgs = formatArgs;
+    exports$1.save = save;
+    exports$1.load = load;
+    exports$1.useColors = useColors;
+    exports$1.storage = localstorage();
+    exports$1.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports$1.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports$1.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports$1.storage.setItem("debug", namespaces);
+        } else {
+          exports$1.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports$1.storage.getItem("debug") || exports$1.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports$1);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/supports-color@10.2.2/node_modules/supports-color/index.js
+var supports_color_exports = {};
+__export(supports_color_exports, {
+  createSupportsColor: () => createSupportsColor,
+  default: () => supports_color_default
+});
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if (!("FORCE_COLOR" in env)) {
+    return;
+  }
+  if (env.FORCE_COLOR === "true") {
+    return 1;
+  }
+  if (env.FORCE_COLOR === "false") {
+    return 0;
+  }
+  if (env.FORCE_COLOR.length === 0) {
+    return 1;
+  }
+  const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  if (![0, 1, 2, 3].includes(level)) {
+    return;
+  }
+  return level;
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "../../node_modules/.pnpm/supports-color@10.2.2/node_modules/supports-color/index.js"() {
+    ({ env } = process2);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/node.js"(exports$1, module) {
+    var tty2 = __require("tty");
+    var util = __require("util");
+    exports$1.init = init;
+    exports$1.log = log;
+    exports$1.formatArgs = formatArgs;
+    exports$1.save = save;
+    exports$1.load = load;
+    exports$1.useColors = useColors;
+    exports$1.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports$1.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
+      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
+        exports$1.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports$1.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports$1.inspectOpts ? Boolean(exports$1.inspectOpts.colors) : tty2.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports$1.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports$1.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports$1.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports$1.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports$1);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/index.js"(exports$1, module) {
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js
+var require_helpers = __commonJS({
+  "../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js"(exports$1) {
+    var __createBinding = exports$1 && exports$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports$1 && exports$1.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports$1 && exports$1.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.req = exports$1.json = exports$1.toBuffer = void 0;
+    var http = __importStar(__require("http"));
+    var https = __importStar(__require("https"));
+    async function toBuffer(stream) {
+      let length = 0;
+      const chunks = [];
+      for await (const chunk of stream) {
+        length += chunk.length;
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks, length);
+    }
+    exports$1.toBuffer = toBuffer;
+    async function json(stream) {
+      const buf = await toBuffer(stream);
+      const str = buf.toString("utf8");
+      try {
+        return JSON.parse(str);
+      } catch (_err) {
+        const err = _err;
+        err.message += ` (input: ${str})`;
+        throw err;
+      }
+    }
+    exports$1.json = json;
+    function req(url, opts = {}) {
+      const href = typeof url === "string" ? url : url.href;
+      const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
+      const promise = new Promise((resolve, reject) => {
+        req2.once("response", resolve).once("error", reject).end();
+      });
+      req2.then = promise.then.bind(promise);
+      return req2;
+    }
+    exports$1.req = req;
+  }
+});
+
+// ../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js"(exports$1) {
+    var __createBinding = exports$1 && exports$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports$1 && exports$1.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports$1 && exports$1.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports$1 && exports$1.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.Agent = void 0;
+    var net = __importStar(__require("net"));
+    var http = __importStar(__require("http"));
+    var https_1 = __require("https");
+    __exportStar(require_helpers(), exports$1);
+    var INTERNAL = Symbol("AgentBaseInternalState");
+    var Agent = class extends http.Agent {
+      constructor(opts) {
+        super(opts);
+        this[INTERNAL] = {};
+      }
+      /**
+       * Determine whether this is an `http` or `https` request.
+       */
+      isSecureEndpoint(options) {
+        if (options) {
+          if (typeof options.secureEndpoint === "boolean") {
+            return options.secureEndpoint;
+          }
+          if (typeof options.protocol === "string") {
+            return options.protocol === "https:";
+          }
+        }
+        const { stack } = new Error();
+        if (typeof stack !== "string")
+          return false;
+        return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+      }
+      // In order to support async signatures in `connect()` and Node's native
+      // connection pooling in `http.Agent`, the array of sockets for each origin
+      // has to be updated synchronously. This is so the length of the array is
+      // accurate when `addRequest()` is next called. We achieve this by creating a
+      // fake socket and adding it to `sockets[origin]` and incrementing
+      // `totalSocketCount`.
+      incrementSockets(name) {
+        if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+          return null;
+        }
+        if (!this.sockets[name]) {
+          this.sockets[name] = [];
+        }
+        const fakeSocket = new net.Socket({ writable: false });
+        this.sockets[name].push(fakeSocket);
+        this.totalSocketCount++;
+        return fakeSocket;
+      }
+      decrementSockets(name, socket) {
+        if (!this.sockets[name] || socket === null) {
+          return;
+        }
+        const sockets = this.sockets[name];
+        const index = sockets.indexOf(socket);
+        if (index !== -1) {
+          sockets.splice(index, 1);
+          this.totalSocketCount--;
+          if (sockets.length === 0) {
+            delete this.sockets[name];
+          }
+        }
+      }
+      // In order to properly update the socket pool, we need to call `getName()` on
+      // the core `https.Agent` if it is a secureEndpoint.
+      getName(options) {
+        const secureEndpoint = this.isSecureEndpoint(options);
+        if (secureEndpoint) {
+          return https_1.Agent.prototype.getName.call(this, options);
+        }
+        return super.getName(options);
+      }
+      createSocket(req, options, cb) {
+        const connectOpts = {
+          ...options,
+          secureEndpoint: this.isSecureEndpoint(options)
+        };
+        const name = this.getName(connectOpts);
+        const fakeSocket = this.incrementSockets(name);
+        Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+          this.decrementSockets(name, fakeSocket);
+          if (socket instanceof http.Agent) {
+            try {
+              return socket.addRequest(req, connectOpts);
+            } catch (err) {
+              return cb(err);
+            }
+          }
+          this[INTERNAL].currentSocket = socket;
+          super.createSocket(req, options, cb);
+        }, (err) => {
+          this.decrementSockets(name, fakeSocket);
+          cb(err);
+        });
+      }
+      createConnection() {
+        const socket = this[INTERNAL].currentSocket;
+        this[INTERNAL].currentSocket = void 0;
+        if (!socket) {
+          throw new Error("No socket was returned in the `connect()` function");
+        }
+        return socket;
+      }
+      get defaultPort() {
+        return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+      }
+      set defaultPort(v) {
+        if (this[INTERNAL]) {
+          this[INTERNAL].defaultPort = v;
+        }
+      }
+      get protocol() {
+        return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+      }
+      set protocol(v) {
+        if (this[INTERNAL]) {
+          this[INTERNAL].protocol = v;
+        }
+      }
+    };
+    exports$1.Agent = Agent;
+  }
+});
+
+// ../../node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@10.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS({
+  "../../node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@10.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports$1) {
+    var __importDefault = exports$1 && exports$1.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.parseProxyResponse = void 0;
+    var debug_1 = __importDefault(require_src());
+    var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+    function parseProxyResponse(socket) {
+      return new Promise((resolve, reject) => {
+        let buffersLength = 0;
+        const buffers = [];
+        function read() {
+          const b = socket.read();
+          if (b)
+            ondata(b);
+          else
+            socket.once("readable", read);
+        }
+        function cleanup() {
+          socket.removeListener("end", onend);
+          socket.removeListener("error", onerror);
+          socket.removeListener("readable", read);
+        }
+        function onend() {
+          cleanup();
+          debug("onend");
+          reject(new Error("Proxy connection ended before receiving CONNECT response"));
+        }
+        function onerror(err) {
+          cleanup();
+          debug("onerror %o", err);
+          reject(err);
+        }
+        function ondata(b) {
+          buffers.push(b);
+          buffersLength += b.length;
+          const buffered = Buffer.concat(buffers, buffersLength);
+          const endOfHeaders = buffered.indexOf("\r\n\r\n");
+          if (endOfHeaders === -1) {
+            debug("have not received end of HTTP headers yet...");
+            read();
+            return;
+          }
+          const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+          const firstLine = headerParts.shift();
+          if (!firstLine) {
+            socket.destroy();
+            return reject(new Error("No header received from proxy CONNECT response"));
+          }
+          const firstLineParts = firstLine.split(" ");
+          const statusCode = +firstLineParts[1];
+          const statusText = firstLineParts.slice(2).join(" ");
+          const headers = {};
+          for (const header of headerParts) {
+            if (!header)
+              continue;
+            const firstColon = header.indexOf(":");
+            if (firstColon === -1) {
+              socket.destroy();
+              return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+            }
+            const key = header.slice(0, firstColon).toLowerCase();
+            const value = header.slice(firstColon + 1).trimStart();
+            const current = headers[key];
+            if (typeof current === "string") {
+              headers[key] = [current, value];
+            } else if (Array.isArray(current)) {
+              current.push(value);
+            } else {
+              headers[key] = value;
+            }
+          }
+          debug("got proxy server response: %o %o", firstLine, headers);
+          cleanup();
+          resolve({
+            connect: {
+              statusCode,
+              statusText,
+              headers
+            },
+            buffered
+          });
+        }
+        socket.on("error", onerror);
+        socket.on("end", onend);
+        read();
+      });
+    }
+    exports$1.parseProxyResponse = parseProxyResponse;
+  }
+});
+
+// ../../node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@10.2.2/node_modules/https-proxy-agent/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/https-proxy-agent@7.0.6_supports-color@10.2.2/node_modules/https-proxy-agent/dist/index.js"(exports$1) {
+    var __createBinding = exports$1 && exports$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports$1 && exports$1.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports$1 && exports$1.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports$1 && exports$1.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.HttpsProxyAgent = void 0;
+    var net = __importStar(__require("net"));
+    var tls = __importStar(__require("tls"));
+    var assert_1 = __importDefault(__require("assert"));
+    var debug_1 = __importDefault(require_src());
+    var agent_base_1 = require_dist();
+    var url_1 = __require("url");
+    var parse_proxy_response_1 = require_parse_proxy_response();
+    var debug = (0, debug_1.default)("https-proxy-agent");
+    var setServernameFromNonIpHost = (options) => {
+      if (options.servername === void 0 && options.host && !net.isIP(options.host)) {
+        return {
+          ...options,
+          servername: options.host
+        };
+      }
+      return options;
+    };
+    var HttpsProxyAgent = class extends agent_base_1.Agent {
+      constructor(proxy, opts) {
+        super(opts);
+        this.options = { path: void 0 };
+        this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+        this.proxyHeaders = opts?.headers ?? {};
+        debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+        const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+        const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+        this.connectOpts = {
+          // Attempt to negotiate http/1.1 for proxy servers that support http/2
+          ALPNProtocols: ["http/1.1"],
+          ...opts ? omit(opts, "headers") : null,
+          host,
+          port
+        };
+      }
+      /**
+       * Called when the node-core HTTP client library is creating a
+       * new HTTP request.
+       */
+      async connect(req, opts) {
+        const { proxy } = this;
+        if (!opts.host) {
+          throw new TypeError('No "host" provided');
+        }
+        let socket;
+        if (proxy.protocol === "https:") {
+          debug("Creating `tls.Socket`: %o", this.connectOpts);
+          socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+        } else {
+          debug("Creating `net.Socket`: %o", this.connectOpts);
+          socket = net.connect(this.connectOpts);
+        }
+        const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+        const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+        let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+        if (proxy.username || proxy.password) {
+          const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+          headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+        }
+        headers.Host = `${host}:${opts.port}`;
+        if (!headers["Proxy-Connection"]) {
+          headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+        }
+        for (const name of Object.keys(headers)) {
+          payload += `${name}: ${headers[name]}\r
+`;
+        }
+        const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+        socket.write(`${payload}\r
+`);
+        const { connect, buffered } = await proxyResponsePromise;
+        req.emit("proxyConnect", connect);
+        this.emit("proxyConnect", connect, req);
+        if (connect.statusCode === 200) {
+          req.once("socket", resume);
+          if (opts.secureEndpoint) {
+            debug("Upgrading socket connection to TLS");
+            return tls.connect({
+              ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+              socket
+            });
+          }
+          return socket;
+        }
+        socket.destroy();
+        const fakeSocket = new net.Socket({ writable: false });
+        fakeSocket.readable = true;
+        req.once("socket", (s) => {
+          debug("Replaying proxy buffer for failed request");
+          (0, assert_1.default)(s.listenerCount("data") > 0);
+          s.push(buffered);
+          s.push(null);
+        });
+        return fakeSocket;
+      }
+    };
+    HttpsProxyAgent.protocols = ["http", "https"];
+    exports$1.HttpsProxyAgent = HttpsProxyAgent;
+    function resume(socket) {
+      socket.resume();
+    }
+    function omit(obj, ...keys) {
+      const ret = {};
+      let key;
+      for (key in obj) {
+        if (!keys.includes(key)) {
+          ret[key] = obj[key];
+        }
+      }
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/package.json"(exports$1, module) {
+    module.exports = {
+      name: "mixpanel",
+      description: "A simple server-side API for mixpanel",
+      keywords: [
+        "mixpanel",
+        "analytics",
+        "api",
+        "stats"
+      ],
+      version: "0.19.1",
+      homepage: "https://github.com/mixpanel/mixpanel-node",
+      author: "Carl Sverre",
+      license: "MIT",
+      main: "lib/mixpanel-node",
+      directories: {
+        lib: "lib"
+      },
+      repository: {
+        type: "git",
+        url: "git+ssh://git@github.com/mixpanel/mixpanel-node.git"
+      },
+      engines: {
+        node: ">=10.0"
+      },
+      scripts: {
+        test: "vitest"
+      },
+      types: "./lib/mixpanel-node.d.ts",
+      devDependencies: {
+        "@types/node": "^24.10.1",
+        "@vitest/coverage-v8": "^4.0.8",
+        nock: "^14.0.10",
+        proxyquire: "^2.1.3",
+        typescript: "^5.9.3",
+        vitest: "^4.0.8"
+      },
+      dependencies: {
+        "https-proxy-agent": "7.0.6"
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/utils.js"(exports$1) {
+    exports$1.async_all = function(requests, handler, callback) {
+      var total = requests.length, errors = null, results = [], done = function(err, result) {
+        if (err) {
+          errors = errors || [];
+          errors.push(err);
+        }
+        results.push(result);
+        if (--total === 0) {
+          callback(errors, results);
+        }
+      };
+      if (total === 0) {
+        callback(errors, results);
+      } else {
+        for (var i = 0, l = requests.length; i < l; i++) {
+          handler(requests[i], done);
+        }
+      }
+    };
+    exports$1.ensure_timestamp = function(time) {
+      if (!(time instanceof Date || typeof time === "number")) {
+        throw new Error("`time` property must be a Date or Unix timestamp and is only required for `import` endpoint");
+      }
+      return time instanceof Date ? time.getTime() : time;
+    };
+    exports$1.assert_logger = function(logger) {
+      if (typeof logger !== "object") {
+        throw new TypeError(`"logger" must be a valid Logger object`);
+      }
+      ["trace", "debug", "info", "warn", "error"].forEach((method) => {
+        if (typeof logger[method] !== "function") {
+          throw new TypeError(`Logger object missing "${method}" method`);
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/profile_helpers.js
+var require_profile_helpers = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/profile_helpers.js"(exports$1) {
+    var { ensure_timestamp } = require_utils();
+    function merge_modifiers(data, modifiers) {
+      if (modifiers) {
+        if (modifiers.$ignore_alias) {
+          data.$ignore_alias = modifiers.$ignore_alias;
+        }
+        if (modifiers.$ignore_time) {
+          data.$ignore_time = modifiers.$ignore_time;
+        }
+        if (modifiers.hasOwnProperty("$ip")) {
+          data.$ip = modifiers.$ip;
+        }
+        if (modifiers.hasOwnProperty("$time")) {
+          data.$time = ensure_timestamp(modifiers.$time);
+        }
+        if (modifiers.hasOwnProperty("$latitude") && modifiers.hasOwnProperty("$longitude")) {
+          data.$latitude = modifiers.$latitude;
+          data.$longitude = modifiers.$longitude;
+        }
+      }
+      return data;
+    }
+    exports$1.merge_modifiers = merge_modifiers;
+    exports$1.ProfileHelpers = (Base = Object) => class extends Base {
+      get token() {
+        return this.mixpanel.token;
+      }
+      get config() {
+        return this.mixpanel.config;
+      }
+      _set(prop, to, modifiers, callback, { identifiers, set_once = false }) {
+        let $set = {};
+        if (typeof prop === "object") {
+          if (typeof to === "object") {
+            callback = modifiers;
+            modifiers = to;
+          } else {
+            callback = to;
+          }
+          $set = prop;
+        } else {
+          $set[prop] = to;
+          if (typeof modifiers === "function" || !modifiers) {
+            callback = modifiers;
+          }
+        }
+        let data = {
+          "$token": this.token,
+          ...identifiers
+        };
+        const set_key = set_once ? "$set_once" : "$set";
+        data[set_key] = $set;
+        if ("ip" in $set) {
+          data.$ip = $set.ip;
+          delete $set.ip;
+        }
+        if ($set.$ignore_time) {
+          data.$ignore_time = $set.$ignore_time;
+          delete $set.$ignore_time;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.config.debug) {
+          this.mixpanel.config.logger.debug(`Sending the following data to Mixpanel (${this.endpoint})`, { data });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: this.endpoint, data }, callback);
+      }
+      _delete_profile({ identifiers, modifiers, callback }) {
+        let data = {
+          "$delete": "",
+          "$token": this.token,
+          ...identifiers
+        };
+        if (typeof modifiers === "function") {
+          callback = modifiers;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.config.debug) {
+          this.mixpanel.config.logger.debug("Deleting profile", { identifiers });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: this.endpoint, data }, callback);
+      }
+      _remove({ identifiers, data, modifiers, callback }) {
+        let $remove = {};
+        if (typeof data !== "object" || Array.isArray(data)) {
+          if (this.config.debug) {
+            this.mixpanel.config.logger.error("Invalid value passed to #remove - data must be an object with scalar values");
+          }
+          return;
+        }
+        for (const [key, val] of Object.entries(data)) {
+          if (typeof val === "string" || typeof val === "number") {
+            $remove[key] = val;
+          } else {
+            if (this.config.debug) {
+              this.mixpanel.config.logger.error(
+                "Invalid argument passed to #remove - values must be scalar",
+                { key, value: val }
+              );
+            }
+            return;
+          }
+        }
+        if (Object.keys($remove).length === 0) {
+          return;
+        }
+        data = {
+          "$remove": $remove,
+          "$token": this.token,
+          ...identifiers
+        };
+        if (typeof modifiers === "function") {
+          callback = modifiers;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.config.debug) {
+          this.mixpanel.config.logger.debug(
+            `Sending the following data to Mixpanel (${this.endpoint})`,
+            { data }
+          );
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: this.endpoint, data }, callback);
+      }
+      _union({ identifiers, data, modifiers, callback }) {
+        let $union = {};
+        if (typeof data !== "object" || Array.isArray(data)) {
+          if (this.config.debug) {
+            this.mixpanel.config.logger.error("Invalid value passed to #union - data must be an object with scalar or array values");
+          }
+          return;
+        }
+        for (const [key, val] of Object.entries(data)) {
+          if (Array.isArray(val)) {
+            var merge_values = val.filter(function(v) {
+              return typeof v === "string" || typeof v === "number";
+            });
+            if (merge_values.length > 0) {
+              $union[key] = merge_values;
+            }
+          } else if (typeof val === "string" || typeof val === "number") {
+            $union[key] = [val];
+          } else {
+            if (this.config.debug) {
+              this.mixpanel.config.logger.error(
+                "Invalid argument passed to #union - values must be a scalar value or array",
+                { key, value: val }
+              );
+            }
+          }
+        }
+        if (Object.keys($union).length === 0) {
+          return;
+        }
+        data = {
+          "$union": $union,
+          "$token": this.token,
+          ...identifiers
+        };
+        if (typeof modifiers === "function") {
+          callback = modifiers;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.config.debug) {
+          this.mixpanel.config.logger.debug(
+            `Sending the following data to Mixpanel (${this.endpoint})`,
+            { data }
+          );
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: this.endpoint, data }, callback);
+      }
+      _unset({ identifiers, prop, modifiers, callback }) {
+        let $unset = [];
+        if (Array.isArray(prop)) {
+          $unset = prop;
+        } else if (typeof prop === "string") {
+          $unset = [prop];
+        } else {
+          if (this.config.debug) {
+            this.mixpanel.config.logger.error(
+              "Invalid argument passed to #unset - must be a string or array",
+              { prop }
+            );
+          }
+          return;
+        }
+        let data = {
+          "$unset": $unset,
+          "$token": this.token,
+          ...identifiers
+        };
+        if (typeof modifiers === "function") {
+          callback = modifiers;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.config.debug) {
+          this.mixpanel.config.logger.debug(
+            `Sending the following data to Mixpanel (${this.endpoint})`,
+            { data }
+          );
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: this.endpoint, data }, callback);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/groups.js
+var require_groups = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/groups.js"(exports$1) {
+    var { ProfileHelpers } = require_profile_helpers();
+    var MixpanelGroups = class extends ProfileHelpers() {
+      constructor(mp_instance) {
+        super();
+        this.mixpanel = mp_instance;
+        this.endpoint = "/groups";
+      }
+      /** groups.set_once(group_key, group_id, prop, to, modifiers, callback)
+          ---
+          The same as groups.set, but adds a property value to a group only if it has not been set before.
+      */
+      set_once(group_key, group_id, prop, to, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._set(prop, to, modifiers, callback, { identifiers, set_once: true });
+      }
+      /**
+              groups.set(group_key, group_id, prop, to, modifiers, callback)
+              ---
+              set properties on a group profile
+      
+              usage:
+      
+                  mixpanel.groups.set('company', 'Acme Inc.', '$name', 'Acme Inc.');
+      
+                  mixpanel.groups.set('company', 'Acme Inc.', {
+                      'Industry': 'widgets',
+                      '$name': 'Acme Inc.',
+                  });
+          */
+      set(group_key, group_id, prop, to, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._set(prop, to, modifiers, callback, { identifiers });
+      }
+      /**
+           groups.delete_group(group_key, group_id, modifiers, callback)
+              ---
+              delete a group profile permanently
+      
+              usage:
+      
+              mixpanel.groups.delete_group('company', 'Acme Inc.');
+              */
+      delete_group(group_key, group_id, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._delete_profile({ identifiers, modifiers, callback });
+      }
+      /**
+           groups.remove(group_key, group_id, data, modifiers, callback)
+              ---
+              remove a value from a list-valued group profile property.
+      
+              usage:
+      
+              mixpanel.groups.remove('company', 'Acme Inc.', {'products': 'anvil'});
+      
+              mixpanel.groups.remove('company', 'Acme Inc.', {
+                  'products': 'anvil',
+                  'customer segments': 'coyotes'
+              });
+              */
+      remove(group_key, group_id, data, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._remove({ identifiers, data, modifiers, callback });
+      }
+      /**
+           groups.union(group_key, group_id, data, modifiers, callback)
+              ---
+              merge value(s) into a list-valued group profile property.
+      
+              usage:
+      
+              mixpanel.groups.union('company', 'Acme Inc.', {'products': 'anvil'});
+      
+              mixpanel.groups.union('company', 'Acme Inc.', {'products': ['anvil'], 'customer segments': ['coyotes']});
+              */
+      union(group_key, group_id, data, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._union({ identifiers, data, modifiers, callback });
+      }
+      /**
+           groups.unset(group_key, group_id, prop, modifiers, callback)
+              ---
+              delete a property on a group profile
+      
+              usage:
+      
+              mixpanel.groups.unset('company', 'Acme Inc.', 'products');
+      
+              mixpanel.groups.unset('company', 'Acme Inc.', ['products', 'customer segments']);
+              */
+      unset(group_key, group_id, prop, modifiers, callback) {
+        const identifiers = { $group_key: group_key, $group_id: group_id };
+        this._unset({ identifiers, prop, modifiers, callback });
+      }
+    };
+    exports$1.MixpanelGroups = MixpanelGroups;
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/people.js
+var require_people = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/people.js"(exports$1) {
+    var { merge_modifiers, ProfileHelpers } = require_profile_helpers();
+    var MixpanelPeople = class extends ProfileHelpers() {
+      constructor(mp_instance) {
+        super();
+        this.mixpanel = mp_instance;
+        this.endpoint = "/engage";
+      }
+      /** people.set_once(distinct_id, prop, to, modifiers, callback)
+              ---
+              The same as people.set but in the words of mixpanel:
+              mixpanel.people.set_once
+      
+              " This method allows you to set a user attribute, only if
+                  it is not currently set. It can be called multiple times
+                  safely, so is perfect for storing things like the first date
+                  you saw a user, or the referrer that brought them to your
+                  website for the first time. "
+      
+          */
+      set_once(distinct_id, prop, to, modifiers, callback) {
+        const identifiers = { $distinct_id: distinct_id };
+        this._set(prop, to, modifiers, callback, { identifiers, set_once: true });
+      }
+      /**
+              people.set(distinct_id, prop, to, modifiers, callback)
+              ---
+              set properties on an user record in engage
+      
+              usage:
+      
+                  mixpanel.people.set('bob', 'gender', 'm');
+      
+                  mixpanel.people.set('joe', {
+                      'company': 'acme',
+                      'plan': 'premium'
+                  });
+          */
+      set(distinct_id, prop, to, modifiers, callback) {
+        const identifiers = { $distinct_id: distinct_id };
+        this._set(prop, to, modifiers, callback, { identifiers });
+      }
+      /**
+              people.increment(distinct_id, prop, by, modifiers, callback)
+              ---
+              increment/decrement properties on an user record in engage
+      
+              usage:
+      
+                  mixpanel.people.increment('bob', 'page_views', 1);
+      
+                  // or, for convenience, if you're just incrementing a counter by 1, you can
+                  // simply do
+                  mixpanel.people.increment('bob', 'page_views');
+      
+                  // to decrement a counter, pass a negative number
+                  mixpanel.people.increment('bob', 'credits_left', -1);
+      
+                  // like mixpanel.people.set(), you can increment multiple properties at once:
+                  mixpanel.people.increment('bob', {
+                      counter1: 1,
+                      counter2: 3,
+                      counter3: -2
+                  });
+          */
+      increment(distinct_id, prop, by, modifiers, callback) {
+        var $add = {};
+        if (typeof prop === "object") {
+          if (typeof by === "object") {
+            callback = modifiers;
+            modifiers = by;
+          } else {
+            callback = by;
+          }
+          for (const [key, val] of Object.entries(prop)) {
+            if (isNaN(parseFloat(val))) {
+              if (this.mixpanel.config.debug) {
+                this.mixpanel.config.logger.error(
+                  "Invalid increment value passed to mixpanel.people.increment - must be a number",
+                  { key, value: val }
+                );
+              }
+            } else {
+              $add[key] = val;
+            }
+          }
+        } else {
+          if (typeof by === "number" || !by) {
+            by = by || 1;
+            $add[prop] = by;
+            if (typeof modifiers === "function") {
+              callback = modifiers;
+            }
+          } else if (typeof by === "function") {
+            callback = by;
+            $add[prop] = 1;
+          } else {
+            callback = modifiers;
+            modifiers = typeof by === "object" ? by : {};
+            $add[prop] = 1;
+          }
+        }
+        var data = {
+          "$add": $add,
+          "$token": this.mixpanel.token,
+          "$distinct_id": distinct_id
+        };
+        data = merge_modifiers(data, modifiers);
+        if (this.mixpanel.config.debug) {
+          this.mixpanel.config.logger.debug("Sending the following data to Mixpanel (Engage)", { data });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: "/engage", data }, callback);
+      }
+      /**
+              people.append(distinct_id, prop, value, modifiers, callback)
+              ---
+              Append a value to a list-valued people analytics property.
+      
+              usage:
+      
+                  // append a value to a list, creating it if needed
+                  mixpanel.people.append('bob', 'pages_visited', 'homepage');
+      
+                  // like mixpanel.people.set(), you can append multiple properties at once:
+                  mixpanel.people.append('bob', {
+                      list1: 'bob',
+                      list2: 123
+                  });
+          */
+      append(distinct_id, prop, value, modifiers, callback) {
+        var $append = {};
+        if (typeof prop === "object") {
+          if (typeof value === "object") {
+            callback = modifiers;
+            modifiers = value;
+          } else {
+            callback = value;
+          }
+          Object.keys(prop).forEach(function(key) {
+            $append[key] = prop[key];
+          });
+        } else {
+          $append[prop] = value;
+          if (typeof modifiers === "function") {
+            callback = modifiers;
+          }
+        }
+        var data = {
+          "$append": $append,
+          "$token": this.mixpanel.token,
+          "$distinct_id": distinct_id
+        };
+        data = merge_modifiers(data, modifiers);
+        if (this.mixpanel.config.debug) {
+          this.mixpanel.config.logger.debug("Sending the following data to Mixpanel (Engage)", { data });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: "/engage", data }, callback);
+      }
+      /**
+              people.track_charge(distinct_id, amount, properties, modifiers, callback)
+              ---
+              Record that you have charged the current user a certain
+              amount of money.
+      
+              usage:
+      
+                  // charge a user $29.99
+                  mixpanel.people.track_charge('bob', 29.99);
+      
+                  // charge a user $19 on the 1st of february
+                  mixpanel.people.track_charge('bob', 19, { '$time': new Date('feb 1 2012') });
+          */
+      track_charge(distinct_id, amount, properties, modifiers, callback) {
+        if (typeof properties === "function" || !properties) {
+          callback = properties || void 0;
+          properties = {};
+        } else {
+          if (typeof modifiers === "function" || !modifiers) {
+            callback = modifiers || void 0;
+            if (properties.$ignore_time || properties.hasOwnProperty("$ip")) {
+              modifiers = {};
+              Object.keys(properties).forEach(function(key) {
+                modifiers[key] = properties[key];
+                delete properties[key];
+              });
+            }
+          }
+        }
+        if (typeof amount !== "number") {
+          amount = parseFloat(amount);
+          if (isNaN(amount)) {
+            this.mixpanel.config.logger.error("Invalid value passed to mixpanel.people.track_charge - must be a number");
+            return;
+          }
+        }
+        properties.$amount = amount;
+        if (properties.hasOwnProperty("$time")) {
+          var time = properties.$time;
+          if (Object.prototype.toString.call(time) === "[object Date]") {
+            properties.$time = time.toISOString();
+          }
+        }
+        var data = {
+          "$append": { "$transactions": properties },
+          "$token": this.mixpanel.token,
+          "$distinct_id": distinct_id
+        };
+        data = merge_modifiers(data, modifiers);
+        if (this.mixpanel.config.debug) {
+          this.mixpanel.config.logger.debug("Sending the following data to Mixpanel (Engage)", { data });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: "/engage", data }, callback);
+      }
+      /**
+              people.clear_charges(distinct_id, modifiers, callback)
+              ---
+              Clear all the current user's transactions.
+      
+              usage:
+      
+                  mixpanel.people.clear_charges('bob');
+          */
+      clear_charges(distinct_id, modifiers, callback) {
+        var data = {
+          "$set": { "$transactions": [] },
+          "$token": this.mixpanel.token,
+          "$distinct_id": distinct_id
+        };
+        if (typeof modifiers === "function") {
+          callback = modifiers;
+        }
+        data = merge_modifiers(data, modifiers);
+        if (this.mixpanel.config.debug) {
+          this.mixpanel.config.logger.debug("Clearing this user's charges", { "$distinct_id": distinct_id });
+        }
+        this.mixpanel.send_request({ method: "GET", endpoint: "/engage", data }, callback);
+      }
+      /**
+              people.delete_user(distinct_id, modifiers, callback)
+              ---
+              delete an user record in engage
+      
+              usage:
+      
+                  mixpanel.people.delete_user('bob');
+          */
+      delete_user(distinct_id, modifiers, callback) {
+        const identifiers = { $distinct_id: distinct_id };
+        this._delete_profile({ identifiers, modifiers, callback });
+      }
+      /**
+              people.remove(distinct_id, data, modifiers, callback)
+              ---
+              remove a value from a list-valued user profile property.
+      
+              usage:
+      
+                  mixpanel.people.remove('bob', {'browsers': 'firefox'});
+      
+                  mixpanel.people.remove('bob', {'browsers': 'chrome', 'os': 'linux'});
+          */
+      remove(distinct_id, data, modifiers, callback) {
+        const identifiers = { "$distinct_id": distinct_id };
+        this._remove({ identifiers, data, modifiers, callback });
+      }
+      /**
+              people.union(distinct_id, data, modifiers, callback)
+              ---
+              merge value(s) into a list-valued people analytics property.
+      
+              usage:
+      
+                  mixpanel.people.union('bob', {'browsers': 'firefox'});
+      
+                  mixpanel.people.union('bob', {'browsers': ['chrome'], os: ['linux']});
+          */
+      union(distinct_id, data, modifiers, callback) {
+        const identifiers = { $distinct_id: distinct_id };
+        this._union({ identifiers, data, modifiers, callback });
+      }
+      /**
+              people.unset(distinct_id, prop, modifiers, callback)
+              ---
+              delete a property on an user record in engage
+      
+              usage:
+      
+                  mixpanel.people.unset('bob', 'page_views');
+      
+                  mixpanel.people.unset('bob', ['page_views', 'last_login']);
+          */
+      unset(distinct_id, prop, modifiers, callback) {
+        const identifiers = { $distinct_id: distinct_id };
+        this._unset({ identifiers, prop, modifiers, callback });
+      }
+    };
+    exports$1.MixpanelPeople = MixpanelPeople;
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/utils.js"(exports$1, module) {
+    var crypto = __require("crypto");
+    var EXPOSURE_EVENT = "$experiment_started";
+    var REQUEST_HEADERS = {
+      "Content-Type": "application/json"
+    };
+    function _fnv1a64(data) {
+      const FNV_PRIME = BigInt("0x100000001B3");
+      let hash = BigInt("0xCBF29CE484222325");
+      for (let i = 0; i < data.length; i++) {
+        hash ^= BigInt(data[i]);
+        hash *= FNV_PRIME;
+        hash &= BigInt("0xFFFFFFFFFFFFFFFF");
+      }
+      return hash;
+    }
+    function normalizedHash(key, salt) {
+      const combined = Buffer.from(key + salt, "utf-8");
+      const hashValue = _fnv1a64(combined);
+      return Number(hashValue % BigInt(100)) / 100;
+    }
+    function prepareCommonQueryParams(token, sdkVersion) {
+      return {
+        mp_lib: "node",
+        $lib_version: sdkVersion,
+        token
+      };
+    }
+    function generateTraceparent() {
+      const version = "00";
+      const traceId = crypto.randomBytes(16).toString("hex");
+      const parentId = crypto.randomBytes(8).toString("hex");
+      const traceFlags = "01";
+      return `${version}-${traceId}-${parentId}-${traceFlags}`;
+    }
+    module.exports = {
+      EXPOSURE_EVENT,
+      REQUEST_HEADERS,
+      normalizedHash,
+      prepareCommonQueryParams,
+      generateTraceparent
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/flags.js
+var require_flags = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/flags.js"(exports$1, module) {
+    var https = __require("https");
+    var packageInfo = require_package();
+    var { prepareCommonQueryParams, generateTraceparent, EXPOSURE_EVENT, REQUEST_HEADERS } = require_utils2();
+    var FeatureFlagsProvider = class {
+      /**
+       * @param {Object} providerConfig - Configuration object with token, api_host, request_timeout_in_seconds
+       * @param {string} endpoint - API endpoint path (e.g., '/flags' or '/flags/definitions')
+       * @param {Function} tracker - Function to track events (signature: track(distinct_id, event, properties, callback))
+       * @param {string} evaluationMode - The feature flag evaluation mode
+       * @param {CustomLogger} logger - Logger instance
+       */
+      constructor(providerConfig, endpoint, tracker, evaluationMode, logger) {
+        this.providerConfig = providerConfig;
+        this.endpoint = endpoint;
+        this.tracker = tracker;
+        this.evaluationMode = evaluationMode;
+        this.logger = logger;
+      }
+      /**
+       * Common HTTP request handler for flags API endpoints
+       * @param {Object} additionalParams - Additional query parameters to append
+       * @returns {Promise<Object>} - Parsed JSON response
+       */
+      async callFlagsEndpoint(additionalParams = null) {
+        return new Promise((resolve, reject) => {
+          const commonParams = prepareCommonQueryParams(this.providerConfig.token, packageInfo.version);
+          const params = new URLSearchParams(commonParams);
+          if (additionalParams) {
+            for (const [key, value] of Object.entries(additionalParams)) {
+              params.append(key, value);
+            }
+          }
+          const path = `${this.endpoint}?${params.toString()}`;
+          const requestOptions = {
+            host: this.providerConfig.api_host,
+            port: 443,
+            path,
+            method: "GET",
+            headers: {
+              ...REQUEST_HEADERS,
+              "Authorization": "Basic " + Buffer.from(this.providerConfig.token + ":").toString("base64"),
+              "traceparent": generateTraceparent()
+            },
+            timeout: this.providerConfig.request_timeout_in_seconds * 1e3
+          };
+          const request = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+              data += chunk;
+            });
+            res.on("end", () => {
+              if (res.statusCode !== 200) {
+                this.logger?.error(`HTTP ${res.statusCode} error calling flags endpoint: ${data}`);
+                return reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+              }
+              try {
+                const result = JSON.parse(data);
+                resolve(result);
+              } catch (parseErr) {
+                this.logger?.error(`Failed to parse JSON response: ${parseErr.message}`);
+                reject(parseErr);
+              }
+            });
+          });
+          request.on("error", (err) => {
+            this.logger?.error(`Network error calling flags endpoint: ${err.message}`);
+            reject(err);
+          });
+          request.on("timeout", () => {
+            this.logger?.error(`Request timeout calling flags endpoint`);
+            request.destroy();
+            reject(new Error("Request timeout"));
+          });
+          request.end();
+        });
+      }
+      /**
+       * Manually tracks a feature flag exposure event to Mixpanel
+       * This provides flexibility for reporting individual exposure events when using getAllVariants
+       * If using getVariantValue or getVariant, exposure events are tracked automatically by default.
+       * @param {string} flagKey - The key of the feature flag
+       * @param {SelectedVariant} variant - The selected variant for the feature flag
+       * @param {FlagContext} context - The user context used to evaluate the feature flag
+       * @param {number|null} latencyMs - Optionally included latency in milliseconds that assignment took.
+       */
+      trackExposureEvent(flagKey, selectedVariant, context, latencyMs = null) {
+        if (!context.distinct_id) {
+          this.logger?.error("Cannot track exposure event without a distinct_id in the context");
+          return;
+        }
+        const properties = {
+          "distinct_id": context.distinct_id,
+          "Experiment name": flagKey,
+          "Variant name": selectedVariant.variant_key,
+          "$experiment_type": "feature_flag",
+          "Flag evaluation mode": this.evaluationMode
+        };
+        if (latencyMs !== null && latencyMs !== void 0) {
+          properties["Variant fetch latency (ms)"] = latencyMs;
+        }
+        if (selectedVariant.experiment_id !== void 0) {
+          properties["$experiment_id"] = selectedVariant.experiment_id;
+        }
+        if (selectedVariant.is_experiment_active !== void 0) {
+          properties["$is_experiment_active"] = selectedVariant.is_experiment_active;
+        }
+        if (selectedVariant.is_qa_tester !== void 0) {
+          properties["$is_qa_tester"] = selectedVariant.is_qa_tester;
+        }
+        this.tracker(EXPOSURE_EVENT, properties, (err) => {
+          if (err) {
+            this.logger?.error(`[flags]Failed to track exposure event for flag '${flagKey}': ${err.message}`);
+          }
+        });
+      }
+    };
+    module.exports = FeatureFlagsProvider;
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/local_flags.js
+var require_local_flags = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/local_flags.js"(exports$1, module) {
+    var FeatureFlagsProvider = require_flags();
+    var { normalizedHash } = require_utils2();
+    var LocalFeatureFlagsProvider = class extends FeatureFlagsProvider {
+      /**
+       * @param {string} token - Mixpanel project token
+       * @param {LocalFlagsConfig} config - Local flags configuration
+       * @param {Function} tracker - Function to track events (signature: track(distinct_id, event, properties, callback))
+       * @param {CustomLogger} logger - Logger
+       */
+      constructor(token, config, tracker, logger) {
+        const mergedConfig = {
+          api_host: "api.mixpanel.com",
+          request_timeout_in_seconds: 10,
+          enable_polling: true,
+          polling_interval_in_seconds: 60,
+          ...config
+        };
+        const providerConfig = {
+          token,
+          api_host: mergedConfig.api_host,
+          request_timeout_in_seconds: mergedConfig.request_timeout_in_seconds
+        };
+        super(providerConfig, "/flags/definitions", tracker, "local", logger);
+        this.config = mergedConfig;
+        this.flagDefinitions = /* @__PURE__ */ new Map();
+        this.pollingInterval = null;
+      }
+      /**
+       * Start polling for flag definitions.
+       * Fetches immediately and then at regular intervals if polling is enabled
+       * @returns {Promise<void>}
+       */
+      async startPollingForDefinitions() {
+        try {
+          await this._fetchFlagDefinitions();
+          if (this.config.enable_polling && !this.pollingInterval) {
+            this.pollingInterval = setInterval(async () => {
+              try {
+                await this._fetchFlagDefinitions();
+              } catch (err) {
+                this.logger?.error(`Error polling for flag definition: ${err.message}`);
+              }
+            }, this.config.polling_interval_in_seconds * 1e3);
+          }
+        } catch (err) {
+          this.logger?.error(`Initial flag definitions fetch failed: ${err.message}`);
+        }
+      }
+      /**
+       * Stop polling for flag definitions
+       */
+      stopPollingForDefinitions() {
+        if (this.pollingInterval) {
+          clearInterval(this.pollingInterval);
+          this.pollingInterval = null;
+        } else {
+          this.logger?.warn("stopPollingForDefinitions called but polling was not active");
+        }
+      }
+      /**
+       * Check if a feature flag is enabled
+       * This method is intended only for flags defined as Mixpanel Feature Gates (boolean flags)
+       * This checks that the variant value of a selected variant is concretely the boolean 'true'
+       * It does not coerce other truthy values.
+       * @param {string} flagKey - Feature flag key
+       * @param {FlagContext} context - Evaluation context (must include distinct_id)
+       * @returns {boolean}
+       */
+      isEnabled(flagKey, context) {
+        const value = this.getVariantValue(flagKey, false, context);
+        return value === true;
+      }
+      /**
+       * Get the variant value for a feature flag
+       * @param {string} flagKey - Feature flag key
+       * @param {*} fallbackValue - Value to return if the user context is not in the rollout for a flag or if evaluation fails
+       * @param {FlagContext} context - Evaluation context
+       * @param {boolean} [reportExposure=true] - Whether to track exposure event
+       * @returns {*} The variant value
+       */
+      getVariantValue(flagKey, fallbackValue, context, reportExposure = true) {
+        const result = this.getVariant(flagKey, { variant_value: fallbackValue }, context, reportExposure);
+        return result.variant_value;
+      }
+      /**
+       * Get the complete variant information for a feature flag
+       * @param {string} flagKey - Feature flag key
+       * @param {SelectedVariant} fallbackVariant - Variant to return if flag evaluation fails
+       * @param {FlagContext} context - Evaluation context (must include distinct_id)
+       * @param {boolean} [reportExposure=true] - Whether to track exposure event
+       * @returns {SelectedVariant}
+       */
+      getVariant(flagKey, fallbackVariant, context, reportExposure = true) {
+        const flag = this.flagDefinitions.get(flagKey);
+        if (!flag) {
+          this.logger?.warn(`Cannot find flag definition for key: '${flagKey}`);
+          return fallbackVariant;
+        }
+        if (!Object.hasOwn(context, flag.context)) {
+          this.logger?.warn(
+            `The variant assignment key, '${flag.context}' for flag, '${flagKey}' is not present in the supplied user context dictionary`
+          );
+          return fallbackVariant;
+        }
+        const contextValue = context[flag.context];
+        let selectedVariant = null;
+        const testUserVariant = this._getVariantOverrideForTestUser(flag, context);
+        if (testUserVariant) {
+          selectedVariant = testUserVariant;
+        } else {
+          const rollout = this._getAssignedRollout(flag, contextValue, context);
+          if (rollout) {
+            selectedVariant = this._getAssignedVariant(flag, contextValue, flagKey, rollout);
+          }
+        }
+        if (selectedVariant) {
+          if (reportExposure) {
+            this.trackExposureEvent(flagKey, selectedVariant, context);
+          }
+          return selectedVariant;
+        }
+        return fallbackVariant;
+      }
+      /**
+       * Get all feature flag variants for the current user context
+       * Exposure events are not automatically tracked when this method is used
+       * @param {FlagContext} context - Evaluation context (must include distinct_id)
+       * @returns {{[key: string]: SelectedVariant}}
+       */
+      getAllVariants(context) {
+        const variants = {};
+        for (const flagKey of this.flagDefinitions.keys()) {
+          const variant = this.getVariant(flagKey, null, context, false);
+          if (variant !== null) {
+            variants[flagKey] = variant;
+          }
+        }
+        return variants;
+      }
+      /**
+       * Fetch flag definitions from API.
+       * @returns {Promise<LocalFlagsResponse>}
+       */
+      async _fetchFlagDefinitions() {
+        const response = await this.callFlagsEndpoint();
+        const newDefinitions = /* @__PURE__ */ new Map();
+        response.flags.forEach((flag) => {
+          newDefinitions.set(flag.key, flag);
+        });
+        this.flagDefinitions = newDefinitions;
+        return response;
+      }
+      /**
+       * Find a variant by key (case-insensitive) and return complete SelectedVariant
+       * @param {string} variantKey - Variant key to find
+       * @param {ExperimentationFlag} flag - Flag definition
+       * @returns {SelectedVariant|null}
+       */
+      _getMatchingVariant(variantKey, flag) {
+        for (const variant of flag.ruleset.variants) {
+          if (variantKey.toLowerCase() === variant.key.toLowerCase()) {
+            return {
+              variant_key: variant.key,
+              variant_value: variant.value,
+              experiment_id: flag.experiment_id,
+              is_experiment_active: flag.is_experiment_active
+            };
+          }
+        }
+        return null;
+      }
+      _getVariantOverrideForTestUser(flag, context) {
+        if (!flag.ruleset.test?.users) {
+          return null;
+        }
+        const distinctId = context.distinct_id;
+        if (!distinctId) {
+          return null;
+        }
+        const variantKey = flag.ruleset.test.users[distinctId];
+        if (!variantKey) {
+          return null;
+        }
+        let selected_variant = this._getMatchingVariant(variantKey, flag);
+        if (selected_variant) {
+          selected_variant.is_qa_tester = true;
+        }
+        return selected_variant;
+      }
+      _getAssignedRollout(flag, contextValue, context) {
+        for (let index = 0; index < flag.ruleset.rollout.length; index++) {
+          const rollout = flag.ruleset.rollout[index];
+          let salt;
+          if (flag.hash_salt !== null && flag.hash_salt !== void 0) {
+            salt = flag.key + flag.hash_salt + index.toString();
+          } else {
+            salt = flag.key + "rollout";
+          }
+          const rolloutHash = normalizedHash(String(contextValue), salt);
+          if (rolloutHash < rollout.rollout_percentage && this._isRuntimeEvaluationSatisfied(rollout, context)) {
+            return rollout;
+          }
+        }
+        return null;
+      }
+      _getAssignedVariant(flag, contextValue, flagKey, rollout) {
+        if (rollout.variant_override) {
+          const variant = this._getMatchingVariant(rollout.variant_override.key, flag);
+          if (variant) {
+            return { ...variant, is_qa_tester: false };
+          }
+        }
+        const storedSalt = flag.hash_salt !== null && flag.hash_salt !== void 0 ? flag.hash_salt : "";
+        const salt = flagKey + storedSalt + "variant";
+        const variantHash = normalizedHash(String(contextValue), salt);
+        const variants = flag.ruleset.variants.map((v) => ({ ...v }));
+        if (rollout.variant_splits) {
+          for (const variant of variants) {
+            if (variant.key in rollout.variant_splits) {
+              variant.split = rollout.variant_splits[variant.key];
+            }
+          }
+        }
+        let selected = variants[0];
+        let cumulative = 0;
+        for (const variant of variants) {
+          selected = variant;
+          cumulative += variant.split || 0;
+          if (variantHash < cumulative) {
+            break;
+          }
+        }
+        return {
+          variant_key: selected.key,
+          variant_value: selected.value,
+          experiment_id: flag.experiment_id,
+          is_experiment_active: flag.is_experiment_active,
+          is_qa_tester: false
+        };
+      }
+      _isRuntimeEvaluationSatisfied(rollout, context) {
+        if (!rollout.runtime_evaluation_definition) {
+          return true;
+        }
+        const customProperties = context.custom_properties;
+        if (!customProperties || typeof customProperties !== "object") {
+          return false;
+        }
+        for (const [key, expectedValue] of Object.entries(rollout.runtime_evaluation_definition)) {
+          if (!(key in customProperties)) {
+            return false;
+          }
+          const actualValue = customProperties[key];
+          if (String(actualValue).toLowerCase() !== String(expectedValue).toLowerCase()) {
+            return false;
+          }
+        }
+        return true;
+      }
+    };
+    module.exports = LocalFeatureFlagsProvider;
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/remote_flags.js
+var require_remote_flags = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/remote_flags.js"(exports$1, module) {
+    var FeatureFlagsProvider = require_flags();
+    var RemoteFeatureFlagsProvider = class extends FeatureFlagsProvider {
+      /**
+       * @param {string} token - Mixpanel project token
+       * @param {RemoteFlagsConfig} config - Remote flags configuration
+       * @param {Function} tracker - Function to track events (signature: track(distinct_id, event, properties, callback))
+       * @param {CustomLogger} logger - Logger instance
+       */
+      constructor(token, config, tracker, logger) {
+        const mergedConfig = {
+          api_host: "api.mixpanel.com",
+          request_timeout_in_seconds: 10,
+          ...config
+        };
+        const providerConfig = {
+          token,
+          api_host: mergedConfig.api_host,
+          request_timeout_in_seconds: mergedConfig.request_timeout_in_seconds
+        };
+        super(providerConfig, "/flags", tracker, "remote", logger);
+      }
+      /**
+       * Get the variant value for a feature flag
+       * If the user context is eligible for the rollout, one of the flag variants will be selected and an exposure event will be tracked to Mixpanel.
+       * If the user context is not eligible, the fallback value is returned.
+       * @param {string} flagKey - Feature flag key
+       * @param {*} fallbackValue - Value to return if flag evaluation fails
+       * @param {FlagContext} context - Evaluation context
+       * @param {boolean} reportExposure - Whether to track exposure event
+       * @returns {Promise<*>} - Variant value
+       */
+      async getVariantValue(flagKey, fallbackValue, context, reportExposure = true) {
+        try {
+          const selectedVariant = await this.getVariant(flagKey, { variant_value: fallbackValue }, context, reportExposure);
+          return selectedVariant.variant_value;
+        } catch (err) {
+          this.logger?.error(`Failed to get variant value for flag '${flagKey}': ${err.message}`);
+          return fallbackValue;
+        }
+      }
+      /**
+       * Get the complete variant information for a feature flag
+       * If the user context is eligible for the rollout, one of the flag variants will be selected and an exposure event will be tracked to Mixpanel.
+       * If the user context is not eligible, the fallback value is returned.
+       * @param {string} flagKey - Feature flag key
+       * @param {SelectedVariant} fallbackVariant - Variant to return if flag evaluation fails
+       * @param {FlagContext} context - Evaluation context
+       * @param {boolean} reportExposure - Whether to track exposure event in the event that the user context is eligible for the rollout.
+       * @returns {Promise<SelectedVariant>} - Selected variant
+       */
+      async getVariant(flagKey, fallbackVariant, context, reportExposure = true) {
+        try {
+          const startTime = Date.now();
+          const response = await this._fetchFlags(context, flagKey);
+          const latencyMs = Date.now() - startTime;
+          const flags = response.flags || {};
+          const selectedVariant = flags[flagKey];
+          if (!selectedVariant) {
+            return fallbackVariant;
+          }
+          if (reportExposure) {
+            this.trackExposureEvent(flagKey, selectedVariant, context, latencyMs);
+          }
+          return selectedVariant;
+        } catch (err) {
+          this.logger?.error(`Failed to get variant for flag '${flagKey}': ${err.message}`);
+          return fallbackVariant;
+        }
+      }
+      /**
+       * This method is intended only for flags defined as Mixpanel Feature Gates (boolean flags)
+       * This checks that the variant value of a selected variant is concretely the boolean 'true'
+       * It does not coerce other truthy values.
+       * @param {string} flagKey - Feature flag key
+       * @param {FlagContext} context - User's evaluation context
+       * @returns {Promise<boolean>} - Whether the flag is enabled
+       */
+      async isEnabled(flagKey, context) {
+        try {
+          const value = await this.getVariantValue(flagKey, false, context);
+          return value === true;
+        } catch (err) {
+          this.logger?.error(`Failed to check if flag '${flagKey}' is enabled: ${err.message}`);
+          return false;
+        }
+      }
+      /**
+       * Get all feature flag variants for the current user context from remote server
+       * Exposure events are not automatically tracked when this method is used
+       * @param {FlagContext} context - User's evaluation context
+       * @returns {Promise<{[key: string]: SelectedVariant}|null>} - Dictionary mapping flag keys to variants, or null if the call fails
+       */
+      async getAllVariants(context) {
+        try {
+          const response = await this._fetchFlags(context);
+          return response.flags || {};
+        } catch (err) {
+          this.logger?.error(`Failed to get all remote variants: ${err.message}`);
+          return null;
+        }
+      }
+      /**
+       * Fetch flags from remote flags evaluation API
+       * @param {FlagContext} context - Evaluation context
+       * @param {string} [flagKey] - Optional flag key (if omitted, fetches all flags)
+       * @returns {Promise<RemoteFlagsResponse>} - API response containing flags dictionary
+       */
+      _fetchFlags(context, flagKey = null) {
+        const additionalParams = {
+          context: JSON.stringify(context)
+        };
+        if (flagKey !== null) {
+          additionalParams.flag_key = flagKey;
+        }
+        return this.callFlagsEndpoint(additionalParams);
+      }
+    };
+    module.exports = RemoteFeatureFlagsProvider;
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/index.js
+var require_flags2 = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/flags/index.js"(exports$1, module) {
+    var LocalFeatureFlagsProvider = require_local_flags();
+    var RemoteFeatureFlagsProvider = require_remote_flags();
+    module.exports = {
+      LocalFeatureFlagsProvider,
+      RemoteFeatureFlagsProvider
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/mixpanel-node.js
+var require_mixpanel_node = __commonJS({
+  "../../node_modules/.pnpm/mixpanel@0.19.1/node_modules/mixpanel/lib/mixpanel-node.js"(exports$1, module) {
+    var querystring = __require("querystring");
+    var Buffer2 = __require("buffer").Buffer;
+    var http = __require("http");
+    var https = __require("https");
+    var HttpsProxyAgent = require_dist2();
+    var url = __require("url");
+    var packageInfo = require_package();
+    var { async_all, ensure_timestamp, assert_logger } = require_utils();
+    var { MixpanelGroups } = require_groups();
+    var { MixpanelPeople } = require_people();
+    var { LocalFeatureFlagsProvider, RemoteFeatureFlagsProvider } = require_flags2();
+    var DEFAULT_CONFIG = {
+      test: false,
+      debug: false,
+      verbose: false,
+      host: "api.mixpanel.com",
+      protocol: "https",
+      path: "",
+      keepAlive: true,
+      // set this to true to automatically geolocate based on the client's ip.
+      // e.g., when running under electron
+      geolocate: false,
+      logger: console
+    };
+    var create_client = function(token, config) {
+      if (!token) {
+        throw new Error("The Mixpanel Client needs a Mixpanel token: `init(token)`");
+      }
+      const metrics = {
+        token,
+        config: { ...DEFAULT_CONFIG }
+      };
+      const { keepAlive } = metrics.config;
+      const MAX_BATCH_SIZE = 50;
+      const REQUEST_LIBS = { http, https };
+      const REQUEST_AGENTS = {
+        http: new http.Agent({ keepAlive }),
+        https: new https.Agent({ keepAlive })
+      };
+      const proxyPath = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+      const proxyAgent = proxyPath ? new HttpsProxyAgent(Object.assign(url.parse(proxyPath), {
+        keepAlive
+      })) : null;
+      metrics.send_request = function(options, callback) {
+        callback = callback || function() {
+        };
+        let content = Buffer2.from(JSON.stringify(options.data)).toString("base64");
+        const endpoint = options.endpoint;
+        const method = (options.method || "GET").toUpperCase();
+        let query_params = {
+          "ip": metrics.config.geolocate ? 1 : 0,
+          "verbose": metrics.config.verbose ? 1 : 0
+        };
+        const key = metrics.config.key;
+        const secret = metrics.config.secret;
+        const request_lib = REQUEST_LIBS[metrics.config.protocol];
+        let request_options = {
+          host: metrics.config.host,
+          port: metrics.config.port,
+          headers: {},
+          method
+        };
+        let request;
+        if (!request_lib) {
+          throw new Error(
+            "Mixpanel Initialization Error: Unsupported protocol " + metrics.config.protocol + ". Supported protocols are: " + Object.keys(REQUEST_LIBS)
+          );
+        }
+        if (method === "POST") {
+          content = "data=" + content;
+          request_options.headers["Content-Type"] = "application/x-www-form-urlencoded";
+          request_options.headers["Content-Length"] = Buffer2.byteLength(content);
+        } else if (method === "GET") {
+          query_params.data = content;
+        }
+        if (secret) {
+          if (request_lib !== https) {
+            throw new Error("Must use HTTPS if authenticating with API Secret");
+          }
+          const encoded = Buffer2.from(secret + ":").toString("base64");
+          request_options.headers["Authorization"] = "Basic " + encoded;
+        } else if (key) {
+          query_params.api_key = key;
+        } else if (endpoint === "/import") {
+          throw new Error("The Mixpanel Client needs a Mixpanel API Secret when importing old events: `init(token, { secret: ... })`");
+        }
+        request_options.agent = proxyAgent || REQUEST_AGENTS[metrics.config.protocol];
+        if (metrics.config.test) {
+          query_params.test = 1;
+        }
+        request_options.path = metrics.config.path + endpoint + "?" + querystring.stringify(query_params);
+        request = request_lib.request(request_options, function(res) {
+          var data = "";
+          res.on("data", function(chunk2) {
+            data += chunk2;
+          });
+          res.on("end", function() {
+            var e;
+            if (metrics.config.verbose) {
+              try {
+                var result = JSON.parse(data);
+                if (result.status != 1) {
+                  e = new Error("Mixpanel Server Error: " + result.error);
+                }
+              } catch (ex) {
+                e = new Error("Could not parse response from Mixpanel");
+              }
+            } else {
+              e = data !== "1" ? new Error("Mixpanel Server Error: " + data) : void 0;
+            }
+            callback(e);
+          });
+        });
+        request.on("error", function(e) {
+          if (metrics.config.debug) {
+            metrics.config.logger.error("Got Error: " + e.message);
+          }
+          callback(e);
+        });
+        if (method === "POST") {
+          request.write(content);
+        }
+        request.end();
+      };
+      metrics.send_event_request = function(endpoint, event, properties, callback) {
+        properties.token = metrics.token;
+        properties.mp_lib = "node";
+        properties.$lib_version = packageInfo.version;
+        var data = {
+          event,
+          properties
+        };
+        if (metrics.config.debug) {
+          metrics.config.logger.debug("Sending the following event to Mixpanel", { data });
+        }
+        metrics.send_request({ method: "GET", endpoint, data }, callback);
+      };
+      var chunk = function(arr, size) {
+        var chunks = [], i = 0, total = arr.length;
+        while (i < total) {
+          chunks.push(arr.slice(i, i += size));
+        }
+        return chunks;
+      };
+      var send_batch_requests = function(options, callback) {
+        var event_list = options.event_list, endpoint = options.endpoint, max_batch_size = options.max_batch_size ? Math.min(MAX_BATCH_SIZE, options.max_batch_size) : MAX_BATCH_SIZE, max_concurrent_requests = options.max_concurrent_requests || options.max_batch_size > MAX_BATCH_SIZE && Math.ceil(options.max_batch_size / MAX_BATCH_SIZE), event_batches = chunk(event_list, max_batch_size), request_batches = max_concurrent_requests ? chunk(event_batches, max_concurrent_requests) : [event_batches], total_event_batches = event_batches.length, total_request_batches = request_batches.length;
+        function send_event_batch(batch, cb) {
+          if (batch.length > 0) {
+            batch = batch.map(function(event) {
+              event.properties;
+              if (endpoint === "/import" || event.properties.time) {
+                event.properties.time = ensure_timestamp(event.properties.time);
+              }
+              event.properties.token = event.properties.token || metrics.token;
+              return event;
+            });
+            metrics.send_request({ method: "POST", endpoint, data: batch }, cb);
+          }
+        }
+        function send_next_request_batch(index) {
+          var request_batch = request_batches[index], cb = function(errors, results) {
+            index += 1;
+            if (index === total_request_batches) {
+              callback && callback(errors, results);
+            } else {
+              send_next_request_batch(index);
+            }
+          };
+          async_all(request_batch, send_event_batch, cb);
+        }
+        send_next_request_batch(0);
+        if (metrics.config.debug) {
+          metrics.config.logger.debug(
+            "Sending " + event_list.length + " events to Mixpanel in " + total_event_batches + " batches of events and " + total_request_batches + " batches of requests"
+          );
+        }
+      };
+      metrics.track = function(event, properties, callback) {
+        if (!properties || typeof properties === "function") {
+          callback = properties;
+          properties = {};
+        }
+        if (properties.time) {
+          properties.time = ensure_timestamp(properties.time);
+        }
+        metrics.send_event_request("/track", event, properties, callback);
+      };
+      metrics.track_batch = function(event_list, options, callback) {
+        options = options || {};
+        if (typeof options === "function") {
+          callback = options;
+          options = {};
+        }
+        var batch_options = {
+          event_list,
+          endpoint: "/track",
+          max_concurrent_requests: options.max_concurrent_requests,
+          max_batch_size: options.max_batch_size
+        };
+        send_batch_requests(batch_options, callback);
+      };
+      metrics.import = function(event, time, properties, callback) {
+        if (!properties || typeof properties === "function") {
+          callback = properties;
+          properties = {};
+        }
+        properties.time = ensure_timestamp(time);
+        metrics.send_event_request("/import", event, properties, callback);
+      };
+      metrics.import_batch = function(event_list, options, callback) {
+        var batch_options;
+        if (typeof options === "function" || !options) {
+          callback = options;
+          options = {};
+        }
+        batch_options = {
+          event_list,
+          endpoint: "/import",
+          max_concurrent_requests: options.max_concurrent_requests,
+          max_batch_size: options.max_batch_size
+        };
+        send_batch_requests(batch_options, callback);
+      };
+      metrics.alias = function(distinct_id, alias, callback) {
+        var properties = {
+          distinct_id,
+          alias
+        };
+        metrics.track("$create_alias", properties, callback);
+      };
+      metrics.groups = new MixpanelGroups(metrics);
+      metrics.people = new MixpanelPeople(metrics);
+      metrics.set_config = function(config2) {
+        if (config2 && config2.logger !== void 0) {
+          assert_logger(config2.logger);
+        }
+        Object.assign(metrics.config, config2);
+        if (config2.host) {
+          const [host, port] = config2.host.split(":");
+          metrics.config.host = host;
+          if (port) {
+            metrics.config.port = Number(port);
+          }
+        }
+      };
+      if (config) {
+        metrics.set_config(config);
+      }
+      if (config && config.local_flags_config) {
+        metrics.local_flags = new LocalFeatureFlagsProvider(
+          token,
+          config.local_flags_config,
+          metrics.track.bind(metrics),
+          config.logger
+        );
+      }
+      if (config && config.remote_flags_config) {
+        metrics.remote_flags = new RemoteFeatureFlagsProvider(
+          token,
+          config.remote_flags_config,
+          metrics.track.bind(metrics),
+          config.logger
+        );
+      }
+      return metrics;
+    };
+    module.exports = {
+      init: create_client
+    };
+  }
+});
+
+// src/mixpanel.ts
+var MixpanelSubscriber = class {
+  name = "MixpanelSubscriber";
+  version = "1.0.0";
+  mixpanel;
+  enabled;
+  config;
+  initPromise = null;
+  constructor(config) {
+    this.enabled = config.enabled ?? true;
+    this.config = config;
+    if (this.enabled) {
+      this.initPromise = this.initialize();
+    }
+  }
+  async initialize() {
+    try {
+      const Mixpanel = await Promise.resolve().then(() => __toESM(require_mixpanel_node(), 1));
+      this.mixpanel = Mixpanel.default.init(this.config.token);
+    } catch (error) {
+      console.error(
+        "Mixpanel subscriber failed to initialize. Install mixpanel: pnpm add mixpanel",
+        error
+      );
+      this.enabled = false;
+    }
+  }
+  async ensureInitialized() {
+    if (this.initPromise) {
+      await this.initPromise;
+      this.initPromise = null;
+    }
+  }
+  async trackEvent(name, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    const distinctId = attributes?.userId || attributes?.user_id || "anonymous";
+    this.mixpanel?.track(name, {
+      distinct_id: distinctId,
+      ...attributes
+    });
+  }
+  async trackFunnelStep(funnelName, step, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    const distinctId = attributes?.userId || attributes?.user_id || "anonymous";
+    this.mixpanel?.track(`${funnelName}.${step}`, {
+      distinct_id: distinctId,
+      funnel: funnelName,
+      step,
+      ...attributes
+    });
+  }
+  async trackOutcome(operationName, outcome, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    const distinctId = attributes?.userId || attributes?.user_id || "anonymous";
+    this.mixpanel?.track(`${operationName}.${outcome}`, {
+      distinct_id: distinctId,
+      operation: operationName,
+      outcome,
+      ...attributes
+    });
+  }
+  async trackValue(name, value, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    const distinctId = attributes?.userId || attributes?.user_id || "anonymous";
+    this.mixpanel?.track(name, {
+      distinct_id: distinctId,
+      value,
+      ...attributes
+    });
+  }
+};
+
+export { MixpanelSubscriber };
+//# sourceMappingURL=mixpanel.js.map
+//# sourceMappingURL=mixpanel.js.map