autotel-subscribers 4.0.0

package/dist/amplitude.js

@@ -0,0 +1,2463 @@
+import * as http from 'http';
+import * as https from 'https';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+var extendStatics, __assign;
+var init_tslib_es6 = __esm({
+  "../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs"() {
+    extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+        d2.__proto__ = b2;
+      } || function(d2, b2) {
+        for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+      };
+      return extendStatics(d, b);
+    };
+    __assign = function() {
+      __assign = Object.assign || function __assign2(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/event/event.js
+var IdentifyOperation, SpecialEventType;
+var init_event = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/event/event.js"() {
+    (function(IdentifyOperation3) {
+      IdentifyOperation3["SET"] = "$set";
+      IdentifyOperation3["SET_ONCE"] = "$setOnce";
+      IdentifyOperation3["ADD"] = "$add";
+      IdentifyOperation3["APPEND"] = "$append";
+      IdentifyOperation3["PREPEND"] = "$prepend";
+      IdentifyOperation3["REMOVE"] = "$remove";
+      IdentifyOperation3["PREINSERT"] = "$preInsert";
+      IdentifyOperation3["POSTINSERT"] = "$postInsert";
+      IdentifyOperation3["UNSET"] = "$unset";
+      IdentifyOperation3["CLEAR_ALL"] = "$clearAll";
+    })(IdentifyOperation || (IdentifyOperation = {}));
+    (function(SpecialEventType2) {
+      SpecialEventType2["IDENTIFY"] = "$identify";
+      SpecialEventType2["GROUP_IDENTIFY"] = "$groupidentify";
+      SpecialEventType2["REVENUE"] = "revenue_amount";
+    })(SpecialEventType || (SpecialEventType = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/constants.js
+var UNSET_VALUE, AMPLITUDE_PREFIX, STORAGE_PREFIX, DEFAULT_INSTANCE_NAME, AMPLITUDE_SERVER_URL, EU_AMPLITUDE_SERVER_URL, AMPLITUDE_BATCH_SERVER_URL, EU_AMPLITUDE_BATCH_SERVER_URL;
+var init_constants = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/constants.js"() {
+    UNSET_VALUE = "-";
+    AMPLITUDE_PREFIX = "AMP";
+    STORAGE_PREFIX = "".concat(AMPLITUDE_PREFIX, "_unsent");
+    DEFAULT_INSTANCE_NAME = "$default_instance";
+    AMPLITUDE_SERVER_URL = "https://api2.amplitude.com/2/httpapi";
+    EU_AMPLITUDE_SERVER_URL = "https://api.eu.amplitude.com/2/httpapi";
+    AMPLITUDE_BATCH_SERVER_URL = "https://api2.amplitude.com/batch";
+    EU_AMPLITUDE_BATCH_SERVER_URL = "https://api.eu.amplitude.com/batch";
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/valid-properties.js
+var MAX_PROPERTY_KEYS, isValidObject, isValidProperties;
+var init_valid_properties = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/valid-properties.js"() {
+    init_tslib_es6();
+    MAX_PROPERTY_KEYS = 1e3;
+    isValidObject = function(properties) {
+      if (Object.keys(properties).length > MAX_PROPERTY_KEYS) {
+        return false;
+      }
+      for (var key in properties) {
+        var value = properties[key];
+        if (!isValidProperties(key, value))
+          return false;
+      }
+      return true;
+    };
+    isValidProperties = function(property, value) {
+      var e_1, _a;
+      if (typeof property !== "string")
+        return false;
+      if (Array.isArray(value)) {
+        var isValid = true;
+        try {
+          for (var value_1 = __values(value), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
+            var valueElement = value_1_1.value;
+            if (Array.isArray(valueElement)) {
+              return false;
+            } else if (typeof valueElement === "object") {
+              isValid = isValid && isValidObject(valueElement);
+            } else if (!["number", "string"].includes(typeof valueElement)) {
+              return false;
+            }
+            if (!isValid) {
+              return false;
+            }
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (value_1_1 && !value_1_1.done && (_a = value_1.return)) _a.call(value_1);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      } else if (value === null || value === void 0) {
+        return false;
+      } else if (typeof value === "object") {
+        return isValidObject(value);
+      } else if (!["number", "string", "boolean"].includes(typeof value)) {
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/identify.js
+var Identify, IdentifyOperation2, OrderedIdentifyOperations;
+var init_identify = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/identify.js"() {
+    init_tslib_es6();
+    init_constants();
+    init_valid_properties();
+    Identify = /** @class */
+    (function() {
+      function Identify2() {
+        this._propertySet = /* @__PURE__ */ new Set();
+        this._properties = {};
+      }
+      Identify2.prototype.getUserProperties = function() {
+        return __assign({}, this._properties);
+      };
+      Identify2.prototype.set = function(property, value) {
+        this._safeSet(IdentifyOperation2.SET, property, value);
+        return this;
+      };
+      Identify2.prototype.setOnce = function(property, value) {
+        this._safeSet(IdentifyOperation2.SET_ONCE, property, value);
+        return this;
+      };
+      Identify2.prototype.append = function(property, value) {
+        this._safeSet(IdentifyOperation2.APPEND, property, value);
+        return this;
+      };
+      Identify2.prototype.prepend = function(property, value) {
+        this._safeSet(IdentifyOperation2.PREPEND, property, value);
+        return this;
+      };
+      Identify2.prototype.postInsert = function(property, value) {
+        this._safeSet(IdentifyOperation2.POSTINSERT, property, value);
+        return this;
+      };
+      Identify2.prototype.preInsert = function(property, value) {
+        this._safeSet(IdentifyOperation2.PREINSERT, property, value);
+        return this;
+      };
+      Identify2.prototype.remove = function(property, value) {
+        this._safeSet(IdentifyOperation2.REMOVE, property, value);
+        return this;
+      };
+      Identify2.prototype.add = function(property, value) {
+        this._safeSet(IdentifyOperation2.ADD, property, value);
+        return this;
+      };
+      Identify2.prototype.unset = function(property) {
+        this._safeSet(IdentifyOperation2.UNSET, property, UNSET_VALUE);
+        return this;
+      };
+      Identify2.prototype.clearAll = function() {
+        this._properties = {};
+        this._properties[IdentifyOperation2.CLEAR_ALL] = UNSET_VALUE;
+        return this;
+      };
+      Identify2.prototype._safeSet = function(operation, property, value) {
+        if (this._validate(operation, property, value)) {
+          var userPropertyMap = this._properties[operation];
+          if (userPropertyMap === void 0) {
+            userPropertyMap = {};
+            this._properties[operation] = userPropertyMap;
+          }
+          userPropertyMap[property] = value;
+          this._propertySet.add(property);
+          return true;
+        }
+        return false;
+      };
+      Identify2.prototype._validate = function(operation, property, value) {
+        if (this._properties[IdentifyOperation2.CLEAR_ALL] !== void 0) {
+          return false;
+        }
+        if (this._propertySet.has(property)) {
+          return false;
+        }
+        if (operation === IdentifyOperation2.ADD) {
+          return typeof value === "number";
+        }
+        if (operation !== IdentifyOperation2.UNSET && operation !== IdentifyOperation2.REMOVE) {
+          return isValidProperties(property, value);
+        }
+        return true;
+      };
+      return Identify2;
+    })();
+    (function(IdentifyOperation3) {
+      IdentifyOperation3["SET"] = "$set";
+      IdentifyOperation3["SET_ONCE"] = "$setOnce";
+      IdentifyOperation3["ADD"] = "$add";
+      IdentifyOperation3["APPEND"] = "$append";
+      IdentifyOperation3["PREPEND"] = "$prepend";
+      IdentifyOperation3["REMOVE"] = "$remove";
+      IdentifyOperation3["PREINSERT"] = "$preInsert";
+      IdentifyOperation3["POSTINSERT"] = "$postInsert";
+      IdentifyOperation3["UNSET"] = "$unset";
+      IdentifyOperation3["CLEAR_ALL"] = "$clearAll";
+    })(IdentifyOperation2 || (IdentifyOperation2 = {}));
+    OrderedIdentifyOperations = [
+      IdentifyOperation2.CLEAR_ALL,
+      IdentifyOperation2.UNSET,
+      IdentifyOperation2.SET,
+      IdentifyOperation2.SET_ONCE,
+      IdentifyOperation2.ADD,
+      IdentifyOperation2.APPEND,
+      IdentifyOperation2.PREPEND,
+      IdentifyOperation2.PREINSERT,
+      IdentifyOperation2.POSTINSERT,
+      IdentifyOperation2.REMOVE
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/messages.js
+var SUCCESS_MESSAGE, UNEXPECTED_ERROR_MESSAGE, MAX_RETRIES_EXCEEDED_MESSAGE, OPT_OUT_MESSAGE, MISSING_API_KEY_MESSAGE, INVALID_API_KEY, CLIENT_NOT_INITIALIZED;
+var init_messages = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/messages.js"() {
+    SUCCESS_MESSAGE = "Event tracked successfully";
+    UNEXPECTED_ERROR_MESSAGE = "Unexpected error occurred";
+    MAX_RETRIES_EXCEEDED_MESSAGE = "Event rejected due to exceeded retry count";
+    OPT_OUT_MESSAGE = "Event skipped due to optOut config";
+    MISSING_API_KEY_MESSAGE = "Event rejected due to missing API key";
+    INVALID_API_KEY = "Invalid API key";
+    CLIENT_NOT_INITIALIZED = "Client not initialized";
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/status.js
+var Status;
+var init_status = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/status.js"() {
+    (function(Status2) {
+      Status2["Unknown"] = "unknown";
+      Status2["Skipped"] = "skipped";
+      Status2["Success"] = "success";
+      Status2["RateLimit"] = "rate_limit";
+      Status2["PayloadTooLarge"] = "payload_too_large";
+      Status2["Invalid"] = "invalid";
+      Status2["Failed"] = "failed";
+      Status2["Timeout"] = "Timeout";
+      Status2["SystemError"] = "SystemError";
+    })(Status || (Status = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/result-builder.js
+var buildResult;
+var init_result_builder = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/result-builder.js"() {
+    init_status();
+    buildResult = function(event, code, message) {
+      if (code === void 0) {
+        code = 0;
+      }
+      if (message === void 0) {
+        message = Status.Unknown;
+      }
+      return { event, code, message };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/global-scope.js
+var getGlobalScope;
+var init_global_scope = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/global-scope.js"() {
+    getGlobalScope = function() {
+      var ampIntegrationContextName = "ampIntegrationContext";
+      if (typeof globalThis !== "undefined" && typeof globalThis[ampIntegrationContextName] !== "undefined") {
+        return globalThis[ampIntegrationContextName];
+      }
+      if (typeof globalThis !== "undefined") {
+        return globalThis;
+      }
+      if (typeof window !== "undefined") {
+        return window;
+      }
+      if (typeof self !== "undefined") {
+        return self;
+      }
+      if (typeof global !== "undefined") {
+        return global;
+      }
+      return void 0;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/uuid.js
+var legacyUUID, hex, UUID;
+var init_uuid = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/uuid.js"() {
+    init_tslib_es6();
+    init_global_scope();
+    legacyUUID = function(a) {
+      return a ? (
+        // a random number from 0 to 15
+        (a ^ // unless b is 8,
+        Math.random() * // in which case
+        16 >> // a random number from
+        a / 4).toString(16)
+      ) : (
+        // or otherwise a concatenated string:
+        (String(1e7) + // 10000000 +
+        String(-1e3) + // -1000 +
+        String(-4e3) + // -4000 +
+        String(-8e3) + // -80000000 +
+        String(-1e11)).replace(
+          // replacing
+          /[018]/g,
+          // zeroes, ones, and eights with
+          UUID
+        )
+      );
+    };
+    hex = __spreadArray([], __read(Array(256).keys()), false).map(function(index) {
+      return index.toString(16).padStart(2, "0");
+    });
+    UUID = function(a) {
+      var _a;
+      var globalScope = getGlobalScope();
+      if (!((_a = globalScope === null || globalScope === void 0 ? void 0 : globalScope.crypto) === null || _a === void 0 ? void 0 : _a.getRandomValues)) {
+        return legacyUUID(a);
+      }
+      var r = globalScope.crypto.getRandomValues(new Uint8Array(16));
+      r[6] = r[6] & 15 | 64;
+      r[8] = r[8] & 63 | 128;
+      return __spreadArray([], __read(r.entries()), false).map(function(_a2) {
+        var _b = __read(_a2, 2), index = _b[0], int = _b[1];
+        return [4, 6, 8, 10].includes(index) ? "-".concat(hex[int]) : hex[int];
+      }).join("");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/timeline.js
+var Timeline;
+var init_timeline = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/timeline.js"() {
+    init_tslib_es6();
+    init_result_builder();
+    init_uuid();
+    Timeline = /** @class */
+    (function() {
+      function Timeline2(client) {
+        this.client = client;
+        this.queue = [];
+        this.applying = false;
+        this.plugins = [];
+      }
+      Timeline2.prototype.register = function(plugin, config) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function() {
+          return __generator(this, function(_c) {
+            switch (_c.label) {
+              case 0:
+                if (this.plugins.some(function(existingPlugin) {
+                  return existingPlugin.name === plugin.name;
+                })) {
+                  this.loggerProvider.warn("Plugin with name ".concat(plugin.name, " already exists, skipping registration"));
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                if (plugin.name === void 0) {
+                  plugin.name = UUID();
+                  this.loggerProvider.warn("Plugin name is undefined. \n      Generating a random UUID for plugin name: ".concat(plugin.name, ". \n      Set a name for the plugin to prevent it from being added multiple times."));
+                }
+                plugin.type = (_a = plugin.type) !== null && _a !== void 0 ? _a : "enrichment";
+                return [4, (_b = plugin.setup) === null || _b === void 0 ? void 0 : _b.call(plugin, config, this.client)];
+              case 1:
+                _c.sent();
+                this.plugins.push(plugin);
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Timeline2.prototype.deregister = function(pluginName, config) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function() {
+          var index, plugin;
+          return __generator(this, function(_b) {
+            switch (_b.label) {
+              case 0:
+                index = this.plugins.findIndex(function(plugin2) {
+                  return plugin2.name === pluginName;
+                });
+                if (index === -1) {
+                  config.loggerProvider.warn("Plugin with name ".concat(pluginName, " does not exist, skipping deregistration"));
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                plugin = this.plugins[index];
+                this.plugins.splice(index, 1);
+                return [4, (_a = plugin.teardown) === null || _a === void 0 ? void 0 : _a.call(plugin)];
+              case 1:
+                _b.sent();
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Timeline2.prototype.reset = function(client) {
+        this.applying = false;
+        var plugins = this.plugins;
+        plugins.map(function(plugin) {
+          var _a;
+          return (_a = plugin.teardown) === null || _a === void 0 ? void 0 : _a.call(plugin);
+        });
+        this.plugins = [];
+        this.client = client;
+      };
+      Timeline2.prototype.push = function(event) {
+        var _this = this;
+        return new Promise(function(resolve) {
+          _this.queue.push([event, resolve]);
+          _this.scheduleApply(0);
+        });
+      };
+      Timeline2.prototype.scheduleApply = function(timeout) {
+        var _this = this;
+        if (this.applying)
+          return;
+        this.applying = true;
+        setTimeout(function() {
+          void _this.apply(_this.queue.shift()).then(function() {
+            _this.applying = false;
+            if (_this.queue.length > 0) {
+              _this.scheduleApply(0);
+            }
+          });
+        }, timeout);
+      };
+      Timeline2.prototype.apply = function(item) {
+        return __awaiter(this, void 0, void 0, function() {
+          var _a, event, _b, resolve, before, before_1, before_1_1, plugin, e, e_1_1, enrichment, enrichment_1, enrichment_1_1, plugin, e, e_2_1, destination, executeDestinations;
+          var e_1, _c, e_2, _d;
+          return __generator(this, function(_e) {
+            switch (_e.label) {
+              case 0:
+                if (!item) {
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                _a = __read(item, 1), event = _a[0];
+                _b = __read(item, 2), resolve = _b[1];
+                this.loggerProvider.log("Timeline.apply: Initial event", event);
+                before = this.plugins.filter(function(plugin2) {
+                  return plugin2.type === "before";
+                });
+                _e.label = 1;
+              case 1:
+                _e.trys.push([1, 6, 7, 8]);
+                before_1 = __values(before), before_1_1 = before_1.next();
+                _e.label = 2;
+              case 2:
+                if (!!before_1_1.done) return [3, 5];
+                plugin = before_1_1.value;
+                if (!plugin.execute) {
+                  return [3, 4];
+                }
+                return [4, plugin.execute(__assign({}, event))];
+              case 3:
+                e = _e.sent();
+                if (e === null) {
+                  this.loggerProvider.log("Timeline.apply: Event filtered out by before plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
+                  resolve({ event, code: 0, message: "" });
+                  return [
+                    2
+                    /*return*/
+                  ];
+                } else {
+                  event = e;
+                  this.loggerProvider.log("Timeline.apply: Event after before plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
+                }
+                _e.label = 4;
+              case 4:
+                before_1_1 = before_1.next();
+                return [3, 2];
+              case 5:
+                return [3, 8];
+              case 6:
+                e_1_1 = _e.sent();
+                e_1 = { error: e_1_1 };
+                return [3, 8];
+              case 7:
+                try {
+                  if (before_1_1 && !before_1_1.done && (_c = before_1.return)) _c.call(before_1);
+                } finally {
+                  if (e_1) throw e_1.error;
+                }
+                return [
+                  7
+                  /*endfinally*/
+                ];
+              case 8:
+                enrichment = this.plugins.filter(function(plugin2) {
+                  return plugin2.type === "enrichment" || plugin2.type === void 0;
+                });
+                _e.label = 9;
+              case 9:
+                _e.trys.push([9, 14, 15, 16]);
+                enrichment_1 = __values(enrichment), enrichment_1_1 = enrichment_1.next();
+                _e.label = 10;
+              case 10:
+                if (!!enrichment_1_1.done) return [3, 13];
+                plugin = enrichment_1_1.value;
+                if (!plugin.execute) {
+                  return [3, 12];
+                }
+                return [4, plugin.execute(__assign({}, event))];
+              case 11:
+                e = _e.sent();
+                if (e === null) {
+                  this.loggerProvider.log("Timeline.apply: Event filtered out by enrichment plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
+                  resolve({ event, code: 0, message: "" });
+                  return [
+                    2
+                    /*return*/
+                  ];
+                } else {
+                  event = e;
+                  this.loggerProvider.log("Timeline.apply: Event after enrichment plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
+                }
+                _e.label = 12;
+              case 12:
+                enrichment_1_1 = enrichment_1.next();
+                return [3, 10];
+              case 13:
+                return [3, 16];
+              case 14:
+                e_2_1 = _e.sent();
+                e_2 = { error: e_2_1 };
+                return [3, 16];
+              case 15:
+                try {
+                  if (enrichment_1_1 && !enrichment_1_1.done && (_d = enrichment_1.return)) _d.call(enrichment_1);
+                } finally {
+                  if (e_2) throw e_2.error;
+                }
+                return [
+                  7
+                  /*endfinally*/
+                ];
+              case 16:
+                destination = this.plugins.filter(function(plugin2) {
+                  return plugin2.type === "destination";
+                });
+                this.loggerProvider.log("Timeline.apply: Final event before destinations, event: ".concat(JSON.stringify(event)));
+                executeDestinations = destination.map(function(plugin2) {
+                  var eventClone = __assign({}, event);
+                  return plugin2.execute(eventClone).catch(function(e2) {
+                    return buildResult(eventClone, 0, String(e2));
+                  });
+                });
+                void Promise.all(executeDestinations).then(function(_a2) {
+                  var _b2 = __read(_a2, 1), result = _b2[0];
+                  var resolveResult = result || buildResult(event, 100, "Event not tracked, no destination plugins on the instance");
+                  resolve(resolveResult);
+                });
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Timeline2.prototype.flush = function() {
+        return __awaiter(this, void 0, void 0, function() {
+          var queue, destination, executeDestinations;
+          var _this = this;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                queue = this.queue;
+                this.queue = [];
+                return [4, Promise.all(queue.map(function(item) {
+                  return _this.apply(item);
+                }))];
+              case 1:
+                _a.sent();
+                destination = this.plugins.filter(function(plugin) {
+                  return plugin.type === "destination";
+                });
+                executeDestinations = destination.map(function(plugin) {
+                  return plugin.flush && plugin.flush();
+                });
+                return [4, Promise.all(executeDestinations)];
+              case 2:
+                _a.sent();
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Timeline2.prototype.onIdentityChanged = function(identity) {
+        this.plugins.forEach(function(plugin) {
+          var _a;
+          void ((_a = plugin.onIdentityChanged) === null || _a === void 0 ? void 0 : _a.call(plugin, identity));
+        });
+      };
+      Timeline2.prototype.onSessionIdChanged = function(sessionId) {
+        this.plugins.forEach(function(plugin) {
+          var _a;
+          void ((_a = plugin.onSessionIdChanged) === null || _a === void 0 ? void 0 : _a.call(plugin, sessionId));
+        });
+      };
+      Timeline2.prototype.onOptOutChanged = function(optOut) {
+        this.plugins.forEach(function(plugin) {
+          var _a;
+          void ((_a = plugin.onOptOutChanged) === null || _a === void 0 ? void 0 : _a.call(plugin, optOut));
+        });
+      };
+      Timeline2.prototype.onReset = function() {
+        this.plugins.forEach(function(plugin) {
+          var _a;
+          void ((_a = plugin.onReset) === null || _a === void 0 ? void 0 : _a.call(plugin));
+        });
+      };
+      return Timeline2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/event-builder.js
+var createTrackEvent, createIdentifyEvent, createGroupIdentifyEvent, createGroupEvent, createRevenueEvent;
+var init_event_builder = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/event-builder.js"() {
+    init_tslib_es6();
+    init_identify();
+    init_event();
+    createTrackEvent = function(eventInput, eventProperties, eventOptions) {
+      var baseEvent = typeof eventInput === "string" ? { event_type: eventInput } : eventInput;
+      return __assign(__assign(__assign({}, baseEvent), eventOptions), eventProperties && { event_properties: eventProperties });
+    };
+    createIdentifyEvent = function(identify2, eventOptions) {
+      var identifyEvent = __assign(__assign({}, eventOptions), { event_type: SpecialEventType.IDENTIFY, user_properties: identify2.getUserProperties() });
+      return identifyEvent;
+    };
+    createGroupIdentifyEvent = function(groupType, groupName, identify2, eventOptions) {
+      var _a;
+      var groupIdentify2 = __assign(__assign({}, eventOptions), { event_type: SpecialEventType.GROUP_IDENTIFY, group_properties: identify2.getUserProperties(), groups: (_a = {}, _a[groupType] = groupName, _a) });
+      return groupIdentify2;
+    };
+    createGroupEvent = function(groupType, groupName, eventOptions) {
+      var _a;
+      var identify2 = new Identify();
+      identify2.set(groupType, groupName);
+      var groupEvent = __assign(__assign({}, eventOptions), { event_type: SpecialEventType.IDENTIFY, user_properties: identify2.getUserProperties(), groups: (_a = {}, _a[groupType] = groupName, _a) });
+      return groupEvent;
+    };
+    createRevenueEvent = function(revenue2, eventOptions) {
+      return __assign(__assign({}, eventOptions), { event_type: SpecialEventType.REVENUE, event_properties: revenue2.getEventProperties() });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/return-wrapper.js
+var returnWrapper;
+var init_return_wrapper = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/return-wrapper.js"() {
+    returnWrapper = function(awaitable) {
+      return {
+        promise: awaitable || Promise.resolve()
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/core-client.js
+var AmplitudeCore;
+var init_core_client = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/core-client.js"() {
+    init_tslib_es6();
+    init_event();
+    init_identify();
+    init_messages();
+    init_timeline();
+    init_event_builder();
+    init_result_builder();
+    init_return_wrapper();
+    AmplitudeCore = /** @class */
+    (function() {
+      function AmplitudeCore2(name) {
+        if (name === void 0) {
+          name = "$default";
+        }
+        this.initializing = false;
+        this.isReady = false;
+        this.q = [];
+        this.dispatchQ = [];
+        this.logEvent = this.track.bind(this);
+        this.timeline = new Timeline(this);
+        this.name = name;
+      }
+      AmplitudeCore2.prototype._init = function(config) {
+        return __awaiter(this, void 0, void 0, function() {
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                this.config = config;
+                this.timeline.reset(this);
+                this.timeline.loggerProvider = this.config.loggerProvider;
+                return [4, this.runQueuedFunctions("q")];
+              case 1:
+                _a.sent();
+                this.isReady = true;
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      AmplitudeCore2.prototype.runQueuedFunctions = function(queueName) {
+        return __awaiter(this, void 0, void 0, function() {
+          var queuedFunctions, queuedFunctions_1, queuedFunctions_1_1, queuedFunction, val, e_1_1;
+          var e_1, _a;
+          return __generator(this, function(_b) {
+            switch (_b.label) {
+              case 0:
+                queuedFunctions = this[queueName];
+                this[queueName] = [];
+                _b.label = 1;
+              case 1:
+                _b.trys.push([1, 8, 9, 10]);
+                queuedFunctions_1 = __values(queuedFunctions), queuedFunctions_1_1 = queuedFunctions_1.next();
+                _b.label = 2;
+              case 2:
+                if (!!queuedFunctions_1_1.done) return [3, 7];
+                queuedFunction = queuedFunctions_1_1.value;
+                val = queuedFunction();
+                if (!(val && "promise" in val)) return [3, 4];
+                return [4, val.promise];
+              case 3:
+                _b.sent();
+                return [3, 6];
+              case 4:
+                return [4, val];
+              case 5:
+                _b.sent();
+                _b.label = 6;
+              case 6:
+                queuedFunctions_1_1 = queuedFunctions_1.next();
+                return [3, 2];
+              case 7:
+                return [3, 10];
+              case 8:
+                e_1_1 = _b.sent();
+                e_1 = { error: e_1_1 };
+                return [3, 10];
+              case 9:
+                try {
+                  if (queuedFunctions_1_1 && !queuedFunctions_1_1.done && (_a = queuedFunctions_1.return)) _a.call(queuedFunctions_1);
+                } finally {
+                  if (e_1) throw e_1.error;
+                }
+                return [
+                  7
+                  /*endfinally*/
+                ];
+              case 10:
+                if (!this[queueName].length) return [3, 12];
+                return [4, this.runQueuedFunctions(queueName)];
+              case 11:
+                _b.sent();
+                _b.label = 12;
+              case 12:
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      AmplitudeCore2.prototype.track = function(eventInput, eventProperties, eventOptions) {
+        var event = createTrackEvent(eventInput, eventProperties, eventOptions);
+        return returnWrapper(this.dispatch(event));
+      };
+      AmplitudeCore2.prototype.identify = function(identify2, eventOptions) {
+        var event = createIdentifyEvent(identify2, eventOptions);
+        return returnWrapper(this.dispatch(event));
+      };
+      AmplitudeCore2.prototype.groupIdentify = function(groupType, groupName, identify2, eventOptions) {
+        var event = createGroupIdentifyEvent(groupType, groupName, identify2, eventOptions);
+        return returnWrapper(this.dispatch(event));
+      };
+      AmplitudeCore2.prototype.setGroup = function(groupType, groupName, eventOptions) {
+        var event = createGroupEvent(groupType, groupName, eventOptions);
+        return returnWrapper(this.dispatch(event));
+      };
+      AmplitudeCore2.prototype.revenue = function(revenue2, eventOptions) {
+        var event = createRevenueEvent(revenue2, eventOptions);
+        return returnWrapper(this.dispatch(event));
+      };
+      AmplitudeCore2.prototype.add = function(plugin) {
+        if (!this.isReady) {
+          this.q.push(this._addPlugin.bind(this, plugin));
+          return returnWrapper();
+        }
+        return this._addPlugin(plugin);
+      };
+      AmplitudeCore2.prototype._addPlugin = function(plugin) {
+        return returnWrapper(this.timeline.register(plugin, this.config));
+      };
+      AmplitudeCore2.prototype.remove = function(pluginName) {
+        if (!this.isReady) {
+          this.q.push(this._removePlugin.bind(this, pluginName));
+          return returnWrapper();
+        }
+        return this._removePlugin(pluginName);
+      };
+      AmplitudeCore2.prototype._removePlugin = function(pluginName) {
+        return returnWrapper(this.timeline.deregister(pluginName, this.config));
+      };
+      AmplitudeCore2.prototype.dispatchWithCallback = function(event, callback) {
+        if (!this.isReady) {
+          return callback(buildResult(event, 0, CLIENT_NOT_INITIALIZED));
+        }
+        void this.process(event).then(callback);
+      };
+      AmplitudeCore2.prototype.dispatch = function(event) {
+        return __awaiter(this, void 0, void 0, function() {
+          var _this = this;
+          return __generator(this, function(_a) {
+            if (!this.isReady) {
+              return [2, new Promise(function(resolve) {
+                _this.dispatchQ.push(_this.dispatchWithCallback.bind(_this, event, resolve));
+              })];
+            }
+            return [2, this.process(event)];
+          });
+        });
+      };
+      AmplitudeCore2.prototype.getOperationAppliedUserProperties = function(userProperties) {
+        var updatedProperties = {};
+        if (userProperties === void 0) {
+          return updatedProperties;
+        }
+        var nonOpProperties = {};
+        Object.keys(userProperties).forEach(function(key) {
+          if (!Object.values(IdentifyOperation).includes(key)) {
+            nonOpProperties[key] = userProperties[key];
+          }
+        });
+        OrderedIdentifyOperations.forEach(function(operation) {
+          if (!Object.keys(userProperties).includes(operation))
+            return;
+          var opProperties = userProperties[operation];
+          switch (operation) {
+            case IdentifyOperation.CLEAR_ALL:
+              Object.keys(updatedProperties).forEach(function(prop) {
+                delete updatedProperties[prop];
+              });
+              break;
+            case IdentifyOperation.UNSET:
+              Object.keys(opProperties).forEach(function(prop) {
+                delete updatedProperties[prop];
+              });
+              break;
+            case IdentifyOperation.SET:
+              Object.assign(updatedProperties, opProperties);
+              break;
+          }
+        });
+        Object.assign(updatedProperties, nonOpProperties);
+        return updatedProperties;
+      };
+      AmplitudeCore2.prototype.process = function(event) {
+        return __awaiter(this, void 0, void 0, function() {
+          var userProperties, result, e_2, message, result;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                _a.trys.push([0, 2, , 3]);
+                if (this.config.optOut) {
+                  return [2, buildResult(event, 0, OPT_OUT_MESSAGE)];
+                }
+                if (event.event_type === SpecialEventType.IDENTIFY) {
+                  userProperties = this.getOperationAppliedUserProperties(event.user_properties);
+                  this.timeline.onIdentityChanged({ userProperties });
+                }
+                return [4, this.timeline.push(event)];
+              case 1:
+                result = _a.sent();
+                result.code === 200 ? this.config.loggerProvider.log(result.message) : result.code === 100 ? this.config.loggerProvider.warn(result.message) : this.config.loggerProvider.error(result.message);
+                return [2, result];
+              case 2:
+                e_2 = _a.sent();
+                message = String(e_2);
+                this.config.loggerProvider.error(message);
+                result = buildResult(event, 0, message);
+                return [2, result];
+              case 3:
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      AmplitudeCore2.prototype.setOptOut = function(optOut) {
+        if (!this.isReady) {
+          this.q.push(this._setOptOut.bind(this, Boolean(optOut)));
+          return;
+        }
+        this._setOptOut(optOut);
+      };
+      AmplitudeCore2.prototype._setOptOut = function(optOut) {
+        if (this.config.optOut !== optOut) {
+          this.timeline.onOptOutChanged(optOut);
+          this.config.optOut = Boolean(optOut);
+        }
+      };
+      AmplitudeCore2.prototype.flush = function() {
+        return returnWrapper(this.timeline.flush());
+      };
+      AmplitudeCore2.prototype.plugin = function(name) {
+        var plugin = this.timeline.plugins.find(function(plugin2) {
+          return plugin2.name === name;
+        });
+        if (plugin === void 0) {
+          this.config.loggerProvider.debug("Cannot find plugin with name ".concat(name));
+          return void 0;
+        }
+        return plugin;
+      };
+      AmplitudeCore2.prototype.plugins = function(pluginClass) {
+        return this.timeline.plugins.filter(function(plugin) {
+          return plugin instanceof pluginClass;
+        });
+      };
+      return AmplitudeCore2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/revenue.js
+var Revenue, RevenueProperty;
+var init_revenue = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/revenue.js"() {
+    init_tslib_es6();
+    init_valid_properties();
+    Revenue = /** @class */
+    (function() {
+      function Revenue2() {
+        this.productId = "";
+        this.quantity = 1;
+        this.price = 0;
+      }
+      Revenue2.prototype.setProductId = function(productId) {
+        this.productId = productId;
+        return this;
+      };
+      Revenue2.prototype.setQuantity = function(quantity) {
+        if (quantity > 0) {
+          this.quantity = quantity;
+        }
+        return this;
+      };
+      Revenue2.prototype.setPrice = function(price) {
+        this.price = price;
+        return this;
+      };
+      Revenue2.prototype.setRevenueType = function(revenueType) {
+        this.revenueType = revenueType;
+        return this;
+      };
+      Revenue2.prototype.setCurrency = function(currency) {
+        this.currency = currency;
+        return this;
+      };
+      Revenue2.prototype.setRevenue = function(revenue2) {
+        this.revenue = revenue2;
+        return this;
+      };
+      Revenue2.prototype.setReceipt = function(receipt) {
+        this.receipt = receipt;
+        return this;
+      };
+      Revenue2.prototype.setReceiptSig = function(receiptSig) {
+        this.receiptSig = receiptSig;
+        return this;
+      };
+      Revenue2.prototype.setEventProperties = function(properties) {
+        if (isValidObject(properties)) {
+          this.properties = properties;
+        }
+        return this;
+      };
+      Revenue2.prototype.getEventProperties = function() {
+        var eventProperties = this.properties ? __assign({}, this.properties) : {};
+        eventProperties[RevenueProperty.REVENUE_PRODUCT_ID] = this.productId;
+        eventProperties[RevenueProperty.REVENUE_QUANTITY] = this.quantity;
+        eventProperties[RevenueProperty.REVENUE_PRICE] = this.price;
+        eventProperties[RevenueProperty.REVENUE_TYPE] = this.revenueType;
+        eventProperties[RevenueProperty.REVENUE_CURRENCY] = this.currency;
+        eventProperties[RevenueProperty.REVENUE] = this.revenue;
+        eventProperties[RevenueProperty.RECEIPT] = this.receipt;
+        eventProperties[RevenueProperty.RECEIPT_SIG] = this.receiptSig;
+        return eventProperties;
+      };
+      return Revenue2;
+    })();
+    (function(RevenueProperty2) {
+      RevenueProperty2["REVENUE_PRODUCT_ID"] = "$productId";
+      RevenueProperty2["REVENUE_QUANTITY"] = "$quantity";
+      RevenueProperty2["REVENUE_PRICE"] = "$price";
+      RevenueProperty2["REVENUE_TYPE"] = "$revenueType";
+      RevenueProperty2["REVENUE_CURRENCY"] = "$currency";
+      RevenueProperty2["REVENUE"] = "$revenue";
+      RevenueProperty2["RECEIPT"] = "$receipt";
+      RevenueProperty2["RECEIPT_SIG"] = "$receiptSig";
+    })(RevenueProperty || (RevenueProperty = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/chunk.js
+var chunk;
+var init_chunk = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/chunk.js"() {
+    chunk = function(arr, size) {
+      var chunkSize = Math.max(size, 1);
+      return arr.reduce(function(chunks, element, index) {
+        var chunkIndex = Math.floor(index / chunkSize);
+        if (!chunks[chunkIndex]) {
+          chunks[chunkIndex] = [];
+        }
+        chunks[chunkIndex].push(element);
+        return chunks;
+      }, []);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/loglevel.js
+var LogLevel;
+var init_loglevel = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/loglevel.js"() {
+    (function(LogLevel2) {
+      LogLevel2[LogLevel2["None"] = 0] = "None";
+      LogLevel2[LogLevel2["Error"] = 1] = "Error";
+      LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+      LogLevel2[LogLevel2["Verbose"] = 3] = "Verbose";
+      LogLevel2[LogLevel2["Debug"] = 4] = "Debug";
+    })(LogLevel || (LogLevel = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/logger.js
+var PREFIX, Logger;
+var init_logger = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/logger.js"() {
+    init_loglevel();
+    PREFIX = "Amplitude Logger ";
+    Logger = /** @class */
+    (function() {
+      function Logger2() {
+        this.logLevel = LogLevel.None;
+      }
+      Logger2.prototype.disable = function() {
+        this.logLevel = LogLevel.None;
+      };
+      Logger2.prototype.enable = function(logLevel) {
+        if (logLevel === void 0) {
+          logLevel = LogLevel.Warn;
+        }
+        this.logLevel = logLevel;
+      };
+      Logger2.prototype.log = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (this.logLevel < LogLevel.Verbose) {
+          return;
+        }
+        console.log("".concat(PREFIX, "[Log]: ").concat(args.join(" ")));
+      };
+      Logger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (this.logLevel < LogLevel.Warn) {
+          return;
+        }
+        console.warn("".concat(PREFIX, "[Warn]: ").concat(args.join(" ")));
+      };
+      Logger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (this.logLevel < LogLevel.Error) {
+          return;
+        }
+        console.error("".concat(PREFIX, "[Error]: ").concat(args.join(" ")));
+      };
+      Logger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        if (this.logLevel < LogLevel.Debug) {
+          return;
+        }
+        console.log("".concat(PREFIX, "[Debug]: ").concat(args.join(" ")));
+      };
+      return Logger2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/config.js
+var getDefaultConfig, Config, getServerUrl, createServerConfig, RequestMetadata;
+var init_config = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/config.js"() {
+    init_constants();
+    init_logger();
+    init_loglevel();
+    getDefaultConfig = function() {
+      return {
+        flushMaxRetries: 12,
+        flushQueueSize: 200,
+        flushIntervalMillis: 1e4,
+        instanceName: DEFAULT_INSTANCE_NAME,
+        logLevel: LogLevel.Warn,
+        loggerProvider: new Logger(),
+        offline: false,
+        optOut: false,
+        serverUrl: AMPLITUDE_SERVER_URL,
+        serverZone: "US",
+        useBatch: false
+      };
+    };
+    Config = /** @class */
+    (function() {
+      function Config2(options) {
+        var _a, _b, _c, _d;
+        this._optOut = false;
+        var defaultConfig = getDefaultConfig();
+        this.apiKey = options.apiKey;
+        this.flushIntervalMillis = (_a = options.flushIntervalMillis) !== null && _a !== void 0 ? _a : defaultConfig.flushIntervalMillis;
+        this.flushMaxRetries = options.flushMaxRetries || defaultConfig.flushMaxRetries;
+        this.flushQueueSize = options.flushQueueSize || defaultConfig.flushQueueSize;
+        this.instanceName = options.instanceName || defaultConfig.instanceName;
+        this.loggerProvider = options.loggerProvider || defaultConfig.loggerProvider;
+        this.logLevel = (_b = options.logLevel) !== null && _b !== void 0 ? _b : defaultConfig.logLevel;
+        this.minIdLength = options.minIdLength;
+        this.plan = options.plan;
+        this.ingestionMetadata = options.ingestionMetadata;
+        this.offline = options.offline !== void 0 ? options.offline : defaultConfig.offline;
+        this.optOut = (_c = options.optOut) !== null && _c !== void 0 ? _c : defaultConfig.optOut;
+        this.serverUrl = options.serverUrl;
+        this.serverZone = options.serverZone || defaultConfig.serverZone;
+        this.storageProvider = options.storageProvider;
+        this.transportProvider = options.transportProvider;
+        this.useBatch = (_d = options.useBatch) !== null && _d !== void 0 ? _d : defaultConfig.useBatch;
+        this.loggerProvider.enable(this.logLevel);
+        var serverConfig = createServerConfig(options.serverUrl, options.serverZone, options.useBatch);
+        this.serverZone = serverConfig.serverZone;
+        this.serverUrl = serverConfig.serverUrl;
+      }
+      Object.defineProperty(Config2.prototype, "optOut", {
+        get: function() {
+          return this._optOut;
+        },
+        set: function(optOut) {
+          this._optOut = optOut;
+        },
+        enumerable: false,
+        configurable: true
+      });
+      return Config2;
+    })();
+    getServerUrl = function(serverZone, useBatch) {
+      if (serverZone === "EU") {
+        return useBatch ? EU_AMPLITUDE_BATCH_SERVER_URL : EU_AMPLITUDE_SERVER_URL;
+      }
+      return useBatch ? AMPLITUDE_BATCH_SERVER_URL : AMPLITUDE_SERVER_URL;
+    };
+    createServerConfig = function(serverUrl, serverZone, useBatch) {
+      if (serverUrl === void 0) {
+        serverUrl = "";
+      }
+      if (serverZone === void 0) {
+        serverZone = getDefaultConfig().serverZone;
+      }
+      if (useBatch === void 0) {
+        useBatch = getDefaultConfig().useBatch;
+      }
+      if (serverUrl) {
+        return { serverUrl, serverZone: void 0 };
+      }
+      var _serverZone = ["US", "EU"].includes(serverZone) ? serverZone : getDefaultConfig().serverZone;
+      return {
+        serverZone: _serverZone,
+        serverUrl: getServerUrl(_serverZone, useBatch)
+      };
+    };
+    RequestMetadata = /** @class */
+    (function() {
+      function RequestMetadata2() {
+        this.sdk = {
+          metrics: {
+            histogram: {}
+          }
+        };
+      }
+      RequestMetadata2.prototype.recordHistogram = function(key, value) {
+        this.sdk.metrics.histogram[key] = value;
+      };
+      return RequestMetadata2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/status-code.js
+function isSuccessStatusCode(code) {
+  return code >= 200 && code < 300;
+}
+var init_status_code = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/status-code.js"() {
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/debug.js
+var getStacktrace, getClientLogConfig, getValueByStringPath, getClientStates, debugWrapper;
+var init_debug = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/utils/debug.js"() {
+    init_tslib_es6();
+    init_loglevel();
+    getStacktrace = function(ignoreDepth) {
+      if (ignoreDepth === void 0) {
+        ignoreDepth = 0;
+      }
+      var trace = new Error().stack || "";
+      return trace.split("\n").slice(2 + ignoreDepth).map(function(text) {
+        return text.trim();
+      });
+    };
+    getClientLogConfig = function(client) {
+      return function() {
+        var _a = __assign({}, client.config), logger = _a.loggerProvider, logLevel = _a.logLevel;
+        return {
+          logger,
+          logLevel
+        };
+      };
+    };
+    getValueByStringPath = function(obj, path) {
+      var e_1, _a;
+      path = path.replace(/\[(\w+)\]/g, ".$1");
+      path = path.replace(/^\./, "");
+      try {
+        for (var _b = __values(path.split(".")), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var attr = _c.value;
+          if (attr in obj) {
+            obj = obj[attr];
+          } else {
+            return;
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      return obj;
+    };
+    getClientStates = function(client, paths) {
+      return function() {
+        var e_2, _a;
+        var res = {};
+        try {
+          for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+            var path = paths_1_1.value;
+            res[path] = getValueByStringPath(client, path);
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+        return res;
+      };
+    };
+    debugWrapper = function(fn, fnName, getLogConfig, getStates, fnContext) {
+      if (fnContext === void 0) {
+        fnContext = null;
+      }
+      return function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        var _a = getLogConfig(), logger = _a.logger, logLevel = _a.logLevel;
+        if (logLevel && logLevel < LogLevel.Debug || !logLevel || !logger) {
+          return fn.apply(fnContext, args);
+        }
+        var debugContext = {
+          type: "invoke public method",
+          name: fnName,
+          args,
+          stacktrace: getStacktrace(1),
+          time: {
+            start: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          states: {}
+        };
+        if (getStates && debugContext.states) {
+          debugContext.states.before = getStates();
+        }
+        var result = fn.apply(fnContext, args);
+        if (result && result.promise) {
+          result.promise.then(function() {
+            if (getStates && debugContext.states) {
+              debugContext.states.after = getStates();
+            }
+            if (debugContext.time) {
+              debugContext.time.end = (/* @__PURE__ */ new Date()).toISOString();
+            }
+            logger.debug(JSON.stringify(debugContext, null, 2));
+          });
+        } else {
+          if (getStates && debugContext.states) {
+            debugContext.states.after = getStates();
+          }
+          if (debugContext.time) {
+            debugContext.time.end = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          logger.debug(JSON.stringify(debugContext, null, 2));
+        }
+        return result;
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/plugins/destination.js
+function getErrorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function getResponseBodyString(res) {
+  var responseBodyString = "";
+  try {
+    if ("body" in res) {
+      responseBodyString = JSON.stringify(res.body, null, 2);
+    }
+  } catch (_a) {
+  }
+  return responseBodyString;
+}
+var Destination;
+var init_destination = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/plugins/destination.js"() {
+    init_tslib_es6();
+    init_status();
+    init_messages();
+    init_constants();
+    init_chunk();
+    init_result_builder();
+    init_config();
+    init_uuid();
+    init_status_code();
+    init_debug();
+    Destination = /** @class */
+    (function() {
+      function Destination2(context) {
+        this.name = "amplitude";
+        this.type = "destination";
+        this.retryTimeout = 1e3;
+        this.throttleTimeout = 3e4;
+        this.storageKey = "";
+        this.scheduleId = null;
+        this.scheduledTimeout = 0;
+        this.flushId = null;
+        this.queue = [];
+        this.diagnosticsClient = context === null || context === void 0 ? void 0 : context.diagnosticsClient;
+      }
+      Destination2.prototype.setup = function(config) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function() {
+          var unsent;
+          var _this = this;
+          return __generator(this, function(_b) {
+            switch (_b.label) {
+              case 0:
+                this.config = config;
+                this.storageKey = "".concat(STORAGE_PREFIX, "_").concat(this.config.apiKey.substring(0, 10));
+                return [4, (_a = this.config.storageProvider) === null || _a === void 0 ? void 0 : _a.get(this.storageKey)];
+              case 1:
+                unsent = _b.sent();
+                if (unsent && unsent.length > 0) {
+                  void Promise.all(unsent.map(function(event) {
+                    return _this.execute(event);
+                  })).catch();
+                }
+                return [2, Promise.resolve(void 0)];
+            }
+          });
+        });
+      };
+      Destination2.prototype.execute = function(event) {
+        var _this = this;
+        if (!event.insert_id) {
+          event.insert_id = UUID();
+        }
+        return new Promise(function(resolve) {
+          var context = {
+            event,
+            attempts: 0,
+            callback: function(result) {
+              return resolve(result);
+            },
+            timeout: 0
+          };
+          _this.queue.push(context);
+          _this.schedule(_this.config.flushIntervalMillis);
+          _this.saveEvents();
+        });
+      };
+      Destination2.prototype.removeEventsExceedFlushMaxRetries = function(list) {
+        var _this = this;
+        return list.filter(function(context) {
+          context.attempts += 1;
+          if (context.attempts < _this.config.flushMaxRetries) {
+            return true;
+          }
+          void _this.fulfillRequest([context], 500, MAX_RETRIES_EXCEEDED_MESSAGE);
+          return false;
+        });
+      };
+      Destination2.prototype.scheduleEvents = function(list) {
+        var _this = this;
+        list.forEach(function(context) {
+          _this.schedule(context.timeout === 0 ? _this.config.flushIntervalMillis : context.timeout);
+        });
+      };
+      Destination2.prototype.schedule = function(timeout) {
+        var _this = this;
+        if (this.config.offline) {
+          return;
+        }
+        if (this.scheduleId === null || this.scheduleId && timeout > this.scheduledTimeout) {
+          if (this.scheduleId) {
+            clearTimeout(this.scheduleId);
+          }
+          this.scheduledTimeout = timeout;
+          this.scheduleId = setTimeout(function() {
+            _this.queue = _this.queue.map(function(context) {
+              context.timeout = 0;
+              return context;
+            });
+            void _this.flush(true);
+          }, timeout);
+          return;
+        }
+      };
+      Destination2.prototype.resetSchedule = function() {
+        this.scheduleId = null;
+        this.scheduledTimeout = 0;
+      };
+      Destination2.prototype.flush = function(useRetry) {
+        if (useRetry === void 0) {
+          useRetry = false;
+        }
+        return __awaiter(this, void 0, void 0, function() {
+          var list, later, batches;
+          var _this = this;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                if (this.config.offline) {
+                  this.resetSchedule();
+                  this.config.loggerProvider.debug("Skipping flush while offline.");
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                if (this.flushId) {
+                  this.resetSchedule();
+                  this.config.loggerProvider.debug("Skipping flush because previous flush has not resolved.");
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                this.flushId = this.scheduleId;
+                this.resetSchedule();
+                list = [];
+                later = [];
+                this.queue.forEach(function(context) {
+                  return context.timeout === 0 ? list.push(context) : later.push(context);
+                });
+                batches = chunk(list, this.config.flushQueueSize);
+                return [4, batches.reduce(function(promise, batch) {
+                  return __awaiter(_this, void 0, void 0, function() {
+                    return __generator(this, function(_a2) {
+                      switch (_a2.label) {
+                        case 0:
+                          return [4, promise];
+                        case 1:
+                          _a2.sent();
+                          return [4, this.send(batch, useRetry)];
+                        case 2:
+                          return [2, _a2.sent()];
+                      }
+                    });
+                  });
+                }, Promise.resolve())];
+              case 1:
+                _a.sent();
+                this.flushId = null;
+                this.scheduleEvents(this.queue);
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Destination2.prototype.send = function(list, useRetry) {
+        var _a;
+        if (useRetry === void 0) {
+          useRetry = true;
+        }
+        return __awaiter(this, void 0, void 0, function() {
+          var payload, serverUrl, res, e_1, errorMessage;
+          return __generator(this, function(_b) {
+            switch (_b.label) {
+              case 0:
+                if (!this.config.apiKey) {
+                  return [2, this.fulfillRequest(list, 400, MISSING_API_KEY_MESSAGE)];
+                }
+                payload = {
+                  api_key: this.config.apiKey,
+                  events: list.map(function(context) {
+                    var _a2 = context.event; _a2.extra; var eventWithoutExtra = __rest(_a2, ["extra"]);
+                    return eventWithoutExtra;
+                  }),
+                  options: {
+                    min_id_length: this.config.minIdLength
+                  },
+                  client_upload_time: (/* @__PURE__ */ new Date()).toISOString(),
+                  request_metadata: this.config.requestMetadata
+                };
+                this.config.requestMetadata = new RequestMetadata();
+                _b.label = 1;
+              case 1:
+                _b.trys.push([1, 3, , 4]);
+                serverUrl = createServerConfig(this.config.serverUrl, this.config.serverZone, this.config.useBatch).serverUrl;
+                return [4, this.config.transportProvider.send(serverUrl, payload)];
+              case 2:
+                res = _b.sent();
+                if (res === null) {
+                  this.fulfillRequest(list, 0, UNEXPECTED_ERROR_MESSAGE);
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                if (!useRetry) {
+                  if ("body" in res) {
+                    this.fulfillRequest(list, res.statusCode, "".concat(res.status, ": ").concat(getResponseBodyString(res)));
+                  } else {
+                    this.fulfillRequest(list, res.statusCode, res.status);
+                  }
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                this.handleResponse(res, list);
+                return [3, 4];
+              case 3:
+                e_1 = _b.sent();
+                errorMessage = getErrorMessage(e_1);
+                this.config.loggerProvider.error(errorMessage);
+                (_a = this.diagnosticsClient) === null || _a === void 0 ? void 0 : _a.recordEvent("analytics.events.unsuccessful.from.catch.error", {
+                  events: list.map(function(context) {
+                    return context.event.event_type;
+                  }),
+                  message: errorMessage,
+                  stack_trace: getStacktrace()
+                });
+                this.handleResponse({ status: Status.Failed, statusCode: 0 }, list);
+                return [3, 4];
+              case 4:
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      Destination2.prototype.handleResponse = function(res, list) {
+        var _a;
+        if (!isSuccessStatusCode(res.statusCode)) {
+          (_a = this.diagnosticsClient) === null || _a === void 0 ? void 0 : _a.recordEvent("analytics.events.unsuccessful", {
+            events: list.map(function(context) {
+              return context.event.event_type;
+            }),
+            code: res.statusCode,
+            status: res.status,
+            body: getResponseBodyString(res),
+            stack_trace: getStacktrace()
+          });
+        }
+        var status = res.status;
+        switch (status) {
+          case Status.Success: {
+            this.handleSuccessResponse(res, list);
+            break;
+          }
+          case Status.Invalid: {
+            this.handleInvalidResponse(res, list);
+            break;
+          }
+          case Status.PayloadTooLarge: {
+            this.handlePayloadTooLargeResponse(res, list);
+            break;
+          }
+          case Status.RateLimit: {
+            this.handleRateLimitResponse(res, list);
+            break;
+          }
+          default: {
+            this.config.loggerProvider.warn(`{code: 0, error: "Status '`.concat(status, "' provided for ").concat(list.length, ' events"}'));
+            this.handleOtherResponse(list);
+            break;
+          }
+        }
+      };
+      Destination2.prototype.handleSuccessResponse = function(res, list) {
+        this.fulfillRequest(list, res.statusCode, SUCCESS_MESSAGE);
+      };
+      Destination2.prototype.handleInvalidResponse = function(res, list) {
+        var _this = this;
+        if (res.body.missingField || res.body.error.startsWith(INVALID_API_KEY)) {
+          this.fulfillRequest(list, res.statusCode, res.body.error);
+          return;
+        }
+        var dropIndex = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(Object.values(res.body.eventsWithInvalidFields)), false), __read(Object.values(res.body.eventsWithMissingFields)), false), __read(Object.values(res.body.eventsWithInvalidIdLengths)), false), __read(res.body.silencedEvents), false).flat();
+        var dropIndexSet = new Set(dropIndex);
+        var retry = list.filter(function(context, index) {
+          if (dropIndexSet.has(index)) {
+            _this.fulfillRequest([context], res.statusCode, res.body.error);
+            return;
+          }
+          return true;
+        });
+        if (retry.length > 0) {
+          this.config.loggerProvider.warn(getResponseBodyString(res));
+        }
+        var tryable = this.removeEventsExceedFlushMaxRetries(retry);
+        this.scheduleEvents(tryable);
+      };
+      Destination2.prototype.handlePayloadTooLargeResponse = function(res, list) {
+        if (list.length === 1) {
+          this.fulfillRequest(list, res.statusCode, res.body.error);
+          return;
+        }
+        this.config.loggerProvider.warn(getResponseBodyString(res));
+        this.config.flushQueueSize /= 2;
+        var tryable = this.removeEventsExceedFlushMaxRetries(list);
+        this.scheduleEvents(tryable);
+      };
+      Destination2.prototype.handleRateLimitResponse = function(res, list) {
+        var _this = this;
+        var dropUserIds = Object.keys(res.body.exceededDailyQuotaUsers);
+        var dropDeviceIds = Object.keys(res.body.exceededDailyQuotaDevices);
+        var throttledIndex = res.body.throttledEvents;
+        var dropUserIdsSet = new Set(dropUserIds);
+        var dropDeviceIdsSet = new Set(dropDeviceIds);
+        var throttledIndexSet = new Set(throttledIndex);
+        var retry = list.filter(function(context, index) {
+          if (context.event.user_id && dropUserIdsSet.has(context.event.user_id) || context.event.device_id && dropDeviceIdsSet.has(context.event.device_id)) {
+            _this.fulfillRequest([context], res.statusCode, res.body.error);
+            return;
+          }
+          if (throttledIndexSet.has(index)) {
+            context.timeout = _this.throttleTimeout;
+          }
+          return true;
+        });
+        if (retry.length > 0) {
+          this.config.loggerProvider.warn(getResponseBodyString(res));
+        }
+        var tryable = this.removeEventsExceedFlushMaxRetries(retry);
+        this.scheduleEvents(tryable);
+      };
+      Destination2.prototype.handleOtherResponse = function(list) {
+        var _this = this;
+        var later = list.map(function(context) {
+          context.timeout = context.attempts * _this.retryTimeout;
+          return context;
+        });
+        var tryable = this.removeEventsExceedFlushMaxRetries(later);
+        this.scheduleEvents(tryable);
+      };
+      Destination2.prototype.fulfillRequest = function(list, code, message) {
+        var _a, _b, _c;
+        if (!isSuccessStatusCode(code)) {
+          (_a = this.diagnosticsClient) === null || _a === void 0 ? void 0 : _a.increment("analytics.events.dropped", list.length);
+          (_b = this.diagnosticsClient) === null || _b === void 0 ? void 0 : _b.recordEvent("analytics.events.dropped", {
+            events: list.map(function(context) {
+              return context.event.event_type;
+            }),
+            code,
+            message,
+            stack_trace: getStacktrace()
+          });
+        } else {
+          (_c = this.diagnosticsClient) === null || _c === void 0 ? void 0 : _c.increment("analytics.events.sent", list.length);
+        }
+        this.removeEvents(list);
+        list.forEach(function(context) {
+          return context.callback(buildResult(context.event, code, message));
+        });
+      };
+      Destination2.prototype.saveEvents = function() {
+        if (!this.config.storageProvider) {
+          return;
+        }
+        var updatedEvents = this.queue.map(function(context) {
+          return context.event;
+        });
+        void this.config.storageProvider.set(this.storageKey, updatedEvents);
+      };
+      Destination2.prototype.removeEvents = function(eventsToRemove) {
+        this.queue = this.queue.filter(function(queuedContext) {
+          return !eventsToRemove.some(function(context) {
+            return context.event.insert_id === queuedContext.event.insert_id;
+          });
+        });
+        this.saveEvents();
+      };
+      return Destination2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/transports/base.js
+var BaseTransport;
+var init_base = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/transports/base.js"() {
+    init_status();
+    init_status_code();
+    BaseTransport = /** @class */
+    (function() {
+      function BaseTransport2() {
+      }
+      BaseTransport2.prototype.send = function(_serverUrl, _payload) {
+        return Promise.resolve(null);
+      };
+      BaseTransport2.prototype.buildResponse = function(responseJSON) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        if (typeof responseJSON !== "object") {
+          return null;
+        }
+        var statusCode = responseJSON.code || 0;
+        var status = this.buildStatus(statusCode);
+        switch (status) {
+          case Status.Success:
+            return {
+              status,
+              statusCode,
+              body: {
+                eventsIngested: (_a = responseJSON.events_ingested) !== null && _a !== void 0 ? _a : 0,
+                payloadSizeBytes: (_b = responseJSON.payload_size_bytes) !== null && _b !== void 0 ? _b : 0,
+                serverUploadTime: (_c = responseJSON.server_upload_time) !== null && _c !== void 0 ? _c : 0
+              }
+            };
+          case Status.Invalid:
+            return {
+              status,
+              statusCode,
+              body: {
+                error: (_d = responseJSON.error) !== null && _d !== void 0 ? _d : "",
+                missingField: (_e = responseJSON.missing_field) !== null && _e !== void 0 ? _e : "",
+                eventsWithInvalidFields: (_f = responseJSON.events_with_invalid_fields) !== null && _f !== void 0 ? _f : {},
+                eventsWithMissingFields: (_g = responseJSON.events_with_missing_fields) !== null && _g !== void 0 ? _g : {},
+                eventsWithInvalidIdLengths: (_h = responseJSON.events_with_invalid_id_lengths) !== null && _h !== void 0 ? _h : {},
+                epsThreshold: (_j = responseJSON.eps_threshold) !== null && _j !== void 0 ? _j : 0,
+                exceededDailyQuotaDevices: (_k = responseJSON.exceeded_daily_quota_devices) !== null && _k !== void 0 ? _k : {},
+                silencedDevices: (_l = responseJSON.silenced_devices) !== null && _l !== void 0 ? _l : [],
+                silencedEvents: (_m = responseJSON.silenced_events) !== null && _m !== void 0 ? _m : [],
+                throttledDevices: (_o = responseJSON.throttled_devices) !== null && _o !== void 0 ? _o : {},
+                throttledEvents: (_p = responseJSON.throttled_events) !== null && _p !== void 0 ? _p : []
+              }
+            };
+          case Status.PayloadTooLarge:
+            return {
+              status,
+              statusCode,
+              body: {
+                error: (_q = responseJSON.error) !== null && _q !== void 0 ? _q : ""
+              }
+            };
+          case Status.RateLimit:
+            return {
+              status,
+              statusCode,
+              body: {
+                error: (_r = responseJSON.error) !== null && _r !== void 0 ? _r : "",
+                epsThreshold: (_s = responseJSON.eps_threshold) !== null && _s !== void 0 ? _s : 0,
+                throttledDevices: (_t = responseJSON.throttled_devices) !== null && _t !== void 0 ? _t : {},
+                throttledUsers: (_u = responseJSON.throttled_users) !== null && _u !== void 0 ? _u : {},
+                exceededDailyQuotaDevices: (_v = responseJSON.exceeded_daily_quota_devices) !== null && _v !== void 0 ? _v : {},
+                exceededDailyQuotaUsers: (_w = responseJSON.exceeded_daily_quota_users) !== null && _w !== void 0 ? _w : {},
+                throttledEvents: (_x = responseJSON.throttled_events) !== null && _x !== void 0 ? _x : []
+              }
+            };
+          case Status.Timeout:
+          default:
+            return {
+              status,
+              statusCode
+            };
+        }
+      };
+      BaseTransport2.prototype.buildStatus = function(code) {
+        if (isSuccessStatusCode(code)) {
+          return Status.Success;
+        }
+        if (code === 429) {
+          return Status.RateLimit;
+        }
+        if (code === 413) {
+          return Status.PayloadTooLarge;
+        }
+        if (code === 408) {
+          return Status.Timeout;
+        }
+        if (code >= 400 && code < 500) {
+          return Status.Invalid;
+        }
+        if (code >= 500) {
+          return Status.Failed;
+        }
+        return Status.Unknown;
+      };
+      return BaseTransport2;
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/server-zone.js
+var ServerZone;
+var init_server_zone = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/server-zone.js"() {
+    (function(ServerZone2) {
+      ServerZone2["US"] = "US";
+      ServerZone2["EU"] = "EU";
+      ServerZone2["STAGING"] = "STAGING";
+    })(ServerZone || (ServerZone = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/offline.js
+var OfflineDisabled;
+var init_offline = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/types/offline.js"() {
+    OfflineDisabled = null;
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/index.js
+var init_esm = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-core@2.33.0/node_modules/@amplitude/analytics-core/lib/esm/index.js"() {
+    init_core_client();
+    init_identify();
+    init_revenue();
+    init_destination();
+    init_config();
+    init_return_wrapper();
+    init_debug();
+    init_uuid();
+    init_base();
+    init_loglevel();
+    init_event();
+    init_server_zone();
+    init_offline();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/version.js"() {
+    VERSION = "1.5.26";
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/plugins/context.js
+var Context;
+var init_context = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/plugins/context.js"() {
+    init_tslib_es6();
+    init_esm();
+    init_version();
+    Context = /** @class */
+    (function() {
+      function Context2() {
+        this.name = "context";
+        this.type = "before";
+        this.eventId = 0;
+        this.library = "amplitude-node-ts/".concat(VERSION);
+      }
+      Context2.prototype.setup = function(config) {
+        this.config = config;
+        return Promise.resolve(void 0);
+      };
+      Context2.prototype.execute = function(context) {
+        var _this = this;
+        return new Promise(function(resolve) {
+          var time = (/* @__PURE__ */ new Date()).getTime();
+          var contextEvent = __assign(__assign(__assign({ time, insert_id: UUID(), plan: _this.config.plan }, _this.config.ingestionMetadata && {
+            ingestion_metadata: {
+              source_name: _this.config.ingestionMetadata.sourceName,
+              source_version: _this.config.ingestionMetadata.sourceVersion
+            }
+          }), context), { event_id: _this.eventId++, library: _this.library });
+          return resolve(contextEvent);
+        });
+      };
+      return Context2;
+    })();
+  }
+});
+var Http;
+var init_http = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/transports/http.js"() {
+    init_tslib_es6();
+    init_esm();
+    Http = /** @class */
+    (function(_super) {
+      __extends(Http2, _super);
+      function Http2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      Http2.prototype.send = function(serverUrl, payload) {
+        var _this = this;
+        var protocol;
+        if (serverUrl.startsWith("http://")) {
+          protocol = http;
+        } else if (serverUrl.startsWith("https://")) {
+          protocol = https;
+        } else {
+          throw new Error("Invalid server url");
+        }
+        var url = new URL(serverUrl);
+        var requestPayload = JSON.stringify(payload);
+        var options = {
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(requestPayload)
+          },
+          hostname: url.hostname,
+          method: "POST",
+          path: url.pathname,
+          port: url.port,
+          protocol: url.protocol
+        };
+        return new Promise(function(resolve) {
+          var req = protocol.request(options, function(res) {
+            res.setEncoding("utf8");
+            var responsePayload = "";
+            res.on("data", function(chunk2) {
+              responsePayload += chunk2;
+            });
+            res.on("end", function() {
+              if (res.complete && responsePayload.length > 0) {
+                try {
+                  var parsedResponsePayload = JSON.parse(responsePayload);
+                  var result = _this.buildResponse(parsedResponsePayload);
+                  resolve(result);
+                } catch (_a) {
+                  resolve(_this.buildResponse({ code: res.statusCode }));
+                }
+              }
+            });
+          });
+          req.on("error", function() {
+            return resolve(null);
+          });
+          req.end(requestPayload);
+        });
+      };
+      return Http2;
+    })(BaseTransport);
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/config.js
+var NodeConfig, useNodeConfig;
+var init_config2 = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/config.js"() {
+    init_tslib_es6();
+    init_esm();
+    init_http();
+    NodeConfig = /** @class */
+    (function(_super) {
+      __extends(NodeConfig2, _super);
+      function NodeConfig2(apiKey, options) {
+        return _super.call(this, __assign(__assign({ transportProvider: new Http() }, options), { apiKey })) || this;
+      }
+      return NodeConfig2;
+    })(Config);
+    useNodeConfig = function(apiKey, overrides) {
+      return new NodeConfig(apiKey, overrides);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/node-client.js
+var AmplitudeNode, createInstance, node_client_default;
+var init_node_client = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/node-client.js"() {
+    init_tslib_es6();
+    init_esm();
+    init_context();
+    init_config2();
+    AmplitudeNode = /** @class */
+    (function(_super) {
+      __extends(AmplitudeNode2, _super);
+      function AmplitudeNode2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      AmplitudeNode2.prototype.init = function(apiKey, options) {
+        if (apiKey === void 0) {
+          apiKey = "";
+        }
+        return returnWrapper(this._init(__assign(__assign({}, options), { apiKey })));
+      };
+      AmplitudeNode2.prototype._init = function(options) {
+        return __awaiter(this, void 0, void 0, function() {
+          var nodeOptions;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                if (this.initializing) {
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                this.initializing = true;
+                nodeOptions = useNodeConfig(options.apiKey, __assign({}, options));
+                return [4, _super.prototype._init.call(this, nodeOptions)];
+              case 1:
+                _a.sent();
+                return [4, this.add(new Destination()).promise];
+              case 2:
+                _a.sent();
+                return [4, this.add(new Context()).promise];
+              case 3:
+                _a.sent();
+                this.initializing = false;
+                return [4, this.runQueuedFunctions("dispatchQ")];
+              case 4:
+                _a.sent();
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      };
+      return AmplitudeNode2;
+    })(AmplitudeCore);
+    createInstance = function() {
+      var client = new AmplitudeNode();
+      return {
+        init: debugWrapper(client.init.bind(client), "init", getClientLogConfig(client), getClientStates(client, ["config"])),
+        add: debugWrapper(client.add.bind(client), "add", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.plugins"])),
+        remove: debugWrapper(client.remove.bind(client), "remove", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.plugins"])),
+        track: debugWrapper(client.track.bind(client), "track", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        logEvent: debugWrapper(client.logEvent.bind(client), "logEvent", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        identify: debugWrapper(client.identify.bind(client), "identify", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        groupIdentify: debugWrapper(client.groupIdentify.bind(client), "groupIdentify", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        setGroup: debugWrapper(client.setGroup.bind(client), "setGroup", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        revenue: debugWrapper(client.revenue.bind(client), "revenue", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        flush: debugWrapper(client.flush.bind(client), "flush", getClientLogConfig(client), getClientStates(client, ["config.apiKey", "timeline.queue.length"])),
+        setOptOut: debugWrapper(client.setOptOut.bind(client), "setOptOut", getClientLogConfig(client), getClientStates(client, ["config"]))
+      };
+    };
+    node_client_default = createInstance();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/types.js
+var types_exports = {};
+__export(types_exports, {
+  IdentifyOperation: () => IdentifyOperation,
+  LogLevel: () => LogLevel,
+  OfflineDisabled: () => OfflineDisabled,
+  RevenueProperty: () => RevenueProperty,
+  ServerZone: () => ServerZone,
+  SpecialEventType: () => SpecialEventType
+});
+var init_types = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/types.js"() {
+    init_esm();
+  }
+});
+
+// ../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  Identify: () => Identify,
+  Revenue: () => Revenue,
+  Types: () => types_exports,
+  add: () => add,
+  createInstance: () => createInstance,
+  flush: () => flush,
+  groupIdentify: () => groupIdentify,
+  identify: () => identify,
+  init: () => init,
+  logEvent: () => logEvent,
+  remove: () => remove,
+  revenue: () => revenue,
+  setGroup: () => setGroup,
+  setOptOut: () => setOptOut,
+  track: () => track
+});
+var add, groupIdentify, identify, init, logEvent, remove, revenue, setGroup, setOptOut, track, flush;
+var init_esm2 = __esm({
+  "../../node_modules/.pnpm/@amplitude+analytics-node@1.5.26/node_modules/@amplitude/analytics-node/lib/esm/index.js"() {
+    init_node_client();
+    init_node_client();
+    init_esm();
+    init_types();
+    add = node_client_default.add;
+    groupIdentify = node_client_default.groupIdentify;
+    identify = node_client_default.identify;
+    init = node_client_default.init;
+    logEvent = node_client_default.logEvent;
+    remove = node_client_default.remove;
+    revenue = node_client_default.revenue;
+    setGroup = node_client_default.setGroup;
+    setOptOut = node_client_default.setOptOut;
+    track = node_client_default.track;
+    flush = node_client_default.flush;
+  }
+});
+
+// src/amplitude.ts
+var AmplitudeSubscriber = class {
+  name = "AmplitudeSubscriber";
+  version = "1.0.0";
+  amplitude;
+  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 { init: init2 } = await Promise.resolve().then(() => (init_esm2(), esm_exports));
+      this.amplitude = init2(this.config.apiKey);
+    } catch (error) {
+      console.error(
+        "Amplitude subscriber failed to initialize. Install @amplitude/events-node: pnpm add @amplitude/events-node",
+        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();
+    this.amplitude?.track({
+      event_type: name,
+      user_id: attributes?.userId || attributes?.user_id || "anonymous",
+      event_properties: attributes
+    });
+  }
+  async trackFunnelStep(funnelName, step, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    this.amplitude?.trackEvent({
+      event_type: `${funnelName}.${step}`,
+      user_id: attributes?.userId || attributes?.user_id || "anonymous",
+      event_properties: {
+        funnel: funnelName,
+        step,
+        ...attributes
+      }
+    });
+  }
+  async trackOutcome(operationName, outcome, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    this.amplitude?.trackEvent({
+      event_type: `${operationName}.${outcome}`,
+      user_id: attributes?.userId || attributes?.user_id || "anonymous",
+      event_properties: {
+        operation: operationName,
+        outcome,
+        ...attributes
+      }
+    });
+  }
+  async trackValue(name, value, attributes) {
+    if (!this.enabled) return;
+    await this.ensureInitialized();
+    this.amplitude?.trackEvent({
+      event_type: name,
+      user_id: attributes?.userId || attributes?.user_id || "anonymous",
+      event_properties: {
+        value,
+        ...attributes
+      }
+    });
+  }
+  /** Flush pending events before shutdown */
+  async shutdown() {
+    await this.ensureInitialized();
+    if (this.amplitude) {
+      await this.amplitude.flush();
+    }
+  }
+};
+
+export { AmplitudeSubscriber };
+//# sourceMappingURL=amplitude.js.map
+//# sourceMappingURL=amplitude.js.map