@trackstall/sdk 0.1.0

package/index.js

@@ -0,0 +1,2734 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../core/dist/schema.js
+var require_schema = __commonJS({
+  "../core/dist/schema.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../core/dist/productEvent.js
+var require_productEvent = __commonJS({
+  "../core/dist/productEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/max.js
+var max_default;
+var init_max = __esm({
+  "../../node_modules/uuid/dist/esm-browser/max.js"() {
+    max_default = "ffffffff-ffff-ffff-ffff-ffffffffffff";
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/nil.js
+var nil_default;
+var init_nil = __esm({
+  "../../node_modules/uuid/dist/esm-browser/nil.js"() {
+    nil_default = "00000000-0000-0000-0000-000000000000";
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/regex.js
+var regex_default;
+var init_regex = __esm({
+  "../../node_modules/uuid/dist/esm-browser/regex.js"() {
+    regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default;
+var init_validate = __esm({
+  "../../node_modules/uuid/dist/esm-browser/validate.js"() {
+    init_regex();
+    validate_default = validate;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+var parse_default;
+var init_parse = __esm({
+  "../../node_modules/uuid/dist/esm-browser/parse.js"() {
+    init_validate();
+    parse_default = parse;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+function stringify(arr, offset = 0) {
+  const uuid = unsafeStringify(arr, offset);
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var byteToHex, stringify_default;
+var init_stringify = __esm({
+  "../../node_modules/uuid/dist/esm-browser/stringify.js"() {
+    init_validate();
+    byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+    stringify_default = stringify;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/rng.js
+function rng() {
+  if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  }
+  return getRandomValues(rnds8);
+}
+var getRandomValues, rnds8;
+var init_rng = __esm({
+  "../../node_modules/uuid/dist/esm-browser/rng.js"() {
+    rnds8 = new Uint8Array(16);
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v1.js
+function v1(options, buf, offset) {
+  var _a, _b, _c, _d;
+  let bytes;
+  const isV6 = (_a = options == null ? void 0 : options._v6) != null ? _a : false;
+  if (options) {
+    const optionsKeys = Object.keys(options);
+    if (optionsKeys.length === 1 && optionsKeys[0] === "_v6") {
+      options = void 0;
+    }
+  }
+  if (options) {
+    bytes = v1Bytes((_d = (_c = options.random) != null ? _c : (_b = options.rng) == null ? void 0 : _b.call(options)) != null ? _d : rng(), options.msecs, options.nsecs, options.clockseq, options.node, buf, offset);
+  } else {
+    const now = Date.now();
+    const rnds = rng();
+    updateV1State(_state, now, rnds);
+    bytes = v1Bytes(rnds, _state.msecs, _state.nsecs, isV6 ? void 0 : _state.clockseq, isV6 ? void 0 : _state.node, buf, offset);
+  }
+  return buf != null ? buf : unsafeStringify(bytes);
+}
+function updateV1State(state, now, rnds) {
+  var _a, _b;
+  (_a = state.msecs) != null ? _a : state.msecs = -Infinity;
+  (_b = state.nsecs) != null ? _b : state.nsecs = 0;
+  if (now === state.msecs) {
+    state.nsecs++;
+    if (state.nsecs >= 1e4) {
+      state.node = void 0;
+      state.nsecs = 0;
+    }
+  } else if (now > state.msecs) {
+    state.nsecs = 0;
+  } else if (now < state.msecs) {
+    state.node = void 0;
+  }
+  if (!state.node) {
+    state.node = rnds.slice(10, 16);
+    state.node[0] |= 1;
+    state.clockseq = (rnds[8] << 8 | rnds[9]) & 16383;
+  }
+  state.msecs = now;
+  return state;
+}
+function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  if (!buf) {
+    buf = new Uint8Array(16);
+    offset = 0;
+  } else {
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+  }
+  msecs != null ? msecs : msecs = Date.now();
+  nsecs != null ? nsecs : nsecs = 0;
+  clockseq != null ? clockseq : clockseq = (rnds[8] << 8 | rnds[9]) & 16383;
+  node != null ? node : node = rnds.slice(10, 16);
+  msecs += 122192928e5;
+  const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
+  buf[offset++] = tl >>> 24 & 255;
+  buf[offset++] = tl >>> 16 & 255;
+  buf[offset++] = tl >>> 8 & 255;
+  buf[offset++] = tl & 255;
+  const tmh = msecs / 4294967296 * 1e4 & 268435455;
+  buf[offset++] = tmh >>> 8 & 255;
+  buf[offset++] = tmh & 255;
+  buf[offset++] = tmh >>> 24 & 15 | 16;
+  buf[offset++] = tmh >>> 16 & 255;
+  buf[offset++] = clockseq >>> 8 | 128;
+  buf[offset++] = clockseq & 255;
+  for (let n = 0; n < 6; ++n) {
+    buf[offset++] = node[n];
+  }
+  return buf;
+}
+var _state, v1_default;
+var init_v1 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v1.js"() {
+    init_rng();
+    init_stringify();
+    _state = {};
+    v1_default = v1;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v1ToV6.js
+function v1ToV6(uuid) {
+  const v1Bytes2 = typeof uuid === "string" ? parse_default(uuid) : uuid;
+  const v6Bytes = _v1ToV6(v1Bytes2);
+  return typeof uuid === "string" ? unsafeStringify(v6Bytes) : v6Bytes;
+}
+function _v1ToV6(v1Bytes2) {
+  return Uint8Array.of((v1Bytes2[6] & 15) << 4 | v1Bytes2[7] >> 4 & 15, (v1Bytes2[7] & 15) << 4 | (v1Bytes2[4] & 240) >> 4, (v1Bytes2[4] & 15) << 4 | (v1Bytes2[5] & 240) >> 4, (v1Bytes2[5] & 15) << 4 | (v1Bytes2[0] & 240) >> 4, (v1Bytes2[0] & 15) << 4 | (v1Bytes2[1] & 240) >> 4, (v1Bytes2[1] & 15) << 4 | (v1Bytes2[2] & 240) >> 4, 96 | v1Bytes2[2] & 15, v1Bytes2[3], v1Bytes2[8], v1Bytes2[9], v1Bytes2[10], v1Bytes2[11], v1Bytes2[12], v1Bytes2[13], v1Bytes2[14], v1Bytes2[15]);
+}
+var init_v1ToV6 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v1ToV6.js"() {
+    init_parse();
+    init_stringify();
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/md5.js
+function md5(bytes) {
+  const words = uint8ToUint32(bytes);
+  const md5Bytes = wordsToMd5(words, bytes.length * 8);
+  return uint32ToUint8(md5Bytes);
+}
+function uint32ToUint8(input) {
+  const bytes = new Uint8Array(input.length * 4);
+  for (let i = 0; i < input.length * 4; i++) {
+    bytes[i] = input[i >> 2] >>> i % 4 * 8 & 255;
+  }
+  return bytes;
+}
+function getOutputLength(inputLength8) {
+  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+}
+function wordsToMd5(x, len) {
+  const xpad = new Uint32Array(getOutputLength(len)).fill(0);
+  xpad.set(x);
+  xpad[len >> 5] |= 128 << len % 32;
+  xpad[xpad.length - 1] = len;
+  x = xpad;
+  let a = 1732584193;
+  let b = -271733879;
+  let c = -1732584194;
+  let d = 271733878;
+  for (let i = 0; i < x.length; i += 16) {
+    const olda = a;
+    const oldb = b;
+    const oldc = c;
+    const oldd = d;
+    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+    a = safeAdd(a, olda);
+    b = safeAdd(b, oldb);
+    c = safeAdd(c, oldc);
+    d = safeAdd(d, oldd);
+  }
+  return Uint32Array.of(a, b, c, d);
+}
+function uint8ToUint32(input) {
+  if (input.length === 0) {
+    return new Uint32Array();
+  }
+  const output = new Uint32Array(getOutputLength(input.length * 8)).fill(0);
+  for (let i = 0; i < input.length; i++) {
+    output[i >> 2] |= (input[i] & 255) << i % 4 * 8;
+  }
+  return output;
+}
+function safeAdd(x, y) {
+  const lsw = (x & 65535) + (y & 65535);
+  const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return msw << 16 | lsw & 65535;
+}
+function bitRotateLeft(num, cnt) {
+  return num << cnt | num >>> 32 - cnt;
+}
+function md5cmn(q, a, b, x, s, t) {
+  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+function md5ff(a, b, c, d, x, s, t) {
+  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+function md5gg(a, b, c, d, x, s, t) {
+  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+function md5hh(a, b, c, d, x, s, t) {
+  return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5ii(a, b, c, d, x, s, t) {
+  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+var md5_default;
+var init_md5 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/md5.js"() {
+    md5_default = md5;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; ++i) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+function v35(version2, hash, value, namespace, buf, offset) {
+  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
+  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
+  if (typeof namespace === "string") {
+    namespace = parse_default(namespace);
+  }
+  if ((namespace == null ? void 0 : namespace.length) !== 16) {
+    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+  }
+  let bytes = new Uint8Array(16 + valueBytes.length);
+  bytes.set(namespaceBytes);
+  bytes.set(valueBytes, namespaceBytes.length);
+  bytes = hash(bytes);
+  bytes[6] = bytes[6] & 15 | version2;
+  bytes[8] = bytes[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+var DNS, URL;
+var init_v35 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v35.js"() {
+    init_parse();
+    init_stringify();
+    DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v3.js
+function v3(value, namespace, buf, offset) {
+  return v35(48, md5_default, value, namespace, buf, offset);
+}
+var v3_default;
+var init_v3 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v3.js"() {
+    init_md5();
+    init_v35();
+    v3.DNS = DNS;
+    v3.URL = URL;
+    v3_default = v3;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/native.js
+var randomUUID, native_default;
+var init_native = __esm({
+  "../../node_modules/uuid/dist/esm-browser/native.js"() {
+    randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+    native_default = { randomUUID };
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v4.js
+function v4(options, buf, offset) {
+  var _a, _b, _c;
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default;
+var init_v4 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v4.js"() {
+    init_native();
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/sha1.js
+function f(s, x, y, z) {
+  switch (s) {
+    case 0:
+      return x & y ^ ~x & z;
+    case 1:
+      return x ^ y ^ z;
+    case 2:
+      return x & y ^ x & z ^ y & z;
+    case 3:
+      return x ^ y ^ z;
+  }
+}
+function ROTL(x, n) {
+  return x << n | x >>> 32 - n;
+}
+function sha1(bytes) {
+  const K = [1518500249, 1859775393, 2400959708, 3395469782];
+  const H = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+  const newBytes = new Uint8Array(bytes.length + 1);
+  newBytes.set(bytes);
+  newBytes[bytes.length] = 128;
+  bytes = newBytes;
+  const l = bytes.length / 4 + 2;
+  const N = Math.ceil(l / 16);
+  const M = new Array(N);
+  for (let i = 0; i < N; ++i) {
+    const arr = new Uint32Array(16);
+    for (let j = 0; j < 16; ++j) {
+      arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
+    }
+    M[i] = arr;
+  }
+  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+  M[N - 1][14] = Math.floor(M[N - 1][14]);
+  M[N - 1][15] = (bytes.length - 1) * 8 & 4294967295;
+  for (let i = 0; i < N; ++i) {
+    const W = new Uint32Array(80);
+    for (let t = 0; t < 16; ++t) {
+      W[t] = M[i][t];
+    }
+    for (let t = 16; t < 80; ++t) {
+      W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+    }
+    let a = H[0];
+    let b = H[1];
+    let c = H[2];
+    let d = H[3];
+    let e = H[4];
+    for (let t = 0; t < 80; ++t) {
+      const s = Math.floor(t / 20);
+      const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
+      e = d;
+      d = c;
+      c = ROTL(b, 30) >>> 0;
+      b = a;
+      a = T;
+    }
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+  }
+  return Uint8Array.of(H[0] >> 24, H[0] >> 16, H[0] >> 8, H[0], H[1] >> 24, H[1] >> 16, H[1] >> 8, H[1], H[2] >> 24, H[2] >> 16, H[2] >> 8, H[2], H[3] >> 24, H[3] >> 16, H[3] >> 8, H[3], H[4] >> 24, H[4] >> 16, H[4] >> 8, H[4]);
+}
+var sha1_default;
+var init_sha1 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/sha1.js"() {
+    sha1_default = sha1;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v5.js
+function v5(value, namespace, buf, offset) {
+  return v35(80, sha1_default, value, namespace, buf, offset);
+}
+var v5_default;
+var init_v5 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v5.js"() {
+    init_sha1();
+    init_v35();
+    v5.DNS = DNS;
+    v5.URL = URL;
+    v5_default = v5;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v6.js
+function v6(options, buf, offset) {
+  options != null ? options : options = {};
+  offset != null ? offset : offset = 0;
+  let bytes = v1_default({ ...options, _v6: true }, new Uint8Array(16));
+  bytes = v1ToV6(bytes);
+  if (buf) {
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; i++) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+var v6_default;
+var init_v6 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v6.js"() {
+    init_stringify();
+    init_v1();
+    init_v1ToV6();
+    v6_default = v6;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v6ToV1.js
+function v6ToV1(uuid) {
+  const v6Bytes = typeof uuid === "string" ? parse_default(uuid) : uuid;
+  const v1Bytes2 = _v6ToV1(v6Bytes);
+  return typeof uuid === "string" ? unsafeStringify(v1Bytes2) : v1Bytes2;
+}
+function _v6ToV1(v6Bytes) {
+  return Uint8Array.of((v6Bytes[3] & 15) << 4 | v6Bytes[4] >> 4 & 15, (v6Bytes[4] & 15) << 4 | (v6Bytes[5] & 240) >> 4, (v6Bytes[5] & 15) << 4 | v6Bytes[6] & 15, v6Bytes[7], (v6Bytes[1] & 15) << 4 | (v6Bytes[2] & 240) >> 4, (v6Bytes[2] & 15) << 4 | (v6Bytes[3] & 240) >> 4, 16 | (v6Bytes[0] & 240) >> 4, (v6Bytes[0] & 15) << 4 | (v6Bytes[1] & 240) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]);
+}
+var init_v6ToV1 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v6ToV1.js"() {
+    init_parse();
+    init_stringify();
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/v7.js
+function v7(options, buf, offset) {
+  var _a, _b, _c;
+  let bytes;
+  if (options) {
+    bytes = v7Bytes((_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng(), options.msecs, options.seq, buf, offset);
+  } else {
+    const now = Date.now();
+    const rnds = rng();
+    updateV7State(_state2, now, rnds);
+    bytes = v7Bytes(rnds, _state2.msecs, _state2.seq, buf, offset);
+  }
+  return buf != null ? buf : unsafeStringify(bytes);
+}
+function updateV7State(state, now, rnds) {
+  var _a, _b;
+  (_a = state.msecs) != null ? _a : state.msecs = -Infinity;
+  (_b = state.seq) != null ? _b : state.seq = 0;
+  if (now > state.msecs) {
+    state.seq = rnds[6] << 23 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+    state.msecs = now;
+  } else {
+    state.seq = state.seq + 1 | 0;
+    if (state.seq === 0) {
+      state.msecs++;
+    }
+  }
+  return state;
+}
+function v7Bytes(rnds, msecs, seq, buf, offset = 0) {
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  if (!buf) {
+    buf = new Uint8Array(16);
+    offset = 0;
+  } else {
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+  }
+  msecs != null ? msecs : msecs = Date.now();
+  seq != null ? seq : seq = rnds[6] * 127 << 24 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+  buf[offset++] = msecs / 1099511627776 & 255;
+  buf[offset++] = msecs / 4294967296 & 255;
+  buf[offset++] = msecs / 16777216 & 255;
+  buf[offset++] = msecs / 65536 & 255;
+  buf[offset++] = msecs / 256 & 255;
+  buf[offset++] = msecs & 255;
+  buf[offset++] = 112 | seq >>> 28 & 15;
+  buf[offset++] = seq >>> 20 & 255;
+  buf[offset++] = 128 | seq >>> 14 & 63;
+  buf[offset++] = seq >>> 6 & 255;
+  buf[offset++] = seq << 2 & 255 | rnds[10] & 3;
+  buf[offset++] = rnds[11];
+  buf[offset++] = rnds[12];
+  buf[offset++] = rnds[13];
+  buf[offset++] = rnds[14];
+  buf[offset++] = rnds[15];
+  return buf;
+}
+var _state2, v7_default;
+var init_v7 = __esm({
+  "../../node_modules/uuid/dist/esm-browser/v7.js"() {
+    init_rng();
+    init_stringify();
+    _state2 = {};
+    v7_default = v7;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/version.js
+function version(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  return parseInt(uuid.slice(14, 15), 16);
+}
+var version_default;
+var init_version = __esm({
+  "../../node_modules/uuid/dist/esm-browser/version.js"() {
+    init_validate();
+    version_default = version;
+  }
+});
+
+// ../../node_modules/uuid/dist/esm-browser/index.js
+var esm_browser_exports = {};
+__export(esm_browser_exports, {
+  MAX: () => max_default,
+  NIL: () => nil_default,
+  parse: () => parse_default,
+  stringify: () => stringify_default,
+  v1: () => v1_default,
+  v1ToV6: () => v1ToV6,
+  v3: () => v3_default,
+  v4: () => v4_default,
+  v5: () => v5_default,
+  v6: () => v6_default,
+  v6ToV1: () => v6ToV1,
+  v7: () => v7_default,
+  validate: () => validate_default,
+  version: () => version_default
+});
+var init_esm_browser = __esm({
+  "../../node_modules/uuid/dist/esm-browser/index.js"() {
+    init_max();
+    init_nil();
+    init_parse();
+    init_stringify();
+    init_v1();
+    init_v1ToV6();
+    init_v3();
+    init_v4();
+    init_v5();
+    init_v6();
+    init_v6ToV1();
+    init_v7();
+    init_validate();
+    init_version();
+  }
+});
+
+// ../core/dist/eventId.js
+var require_eventId = __commonJS({
+  "../core/dist/eventId.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TRACKSTALL_EVENT_NAMESPACE = void 0;
+    exports.deterministicEventId = deterministicEventId3;
+    exports.randomEventId = randomEventId3;
+    var uuid_1 = (init_esm_browser(), __toCommonJS(esm_browser_exports));
+    exports.TRACKSTALL_EVENT_NAMESPACE = "b7d2f0c4-1e8a-4c3b-9f6d-5a2e7c4b1d90";
+    function deterministicEventId3(input) {
+      var _a, _b;
+      if (!input.appId) {
+        throw new Error("deterministicEventId: appId is required");
+      }
+      if (!input.userId) {
+        throw new Error("deterministicEventId: userId is required");
+      }
+      if (!input.eventName) {
+        throw new Error("deterministicEventId: eventName is required");
+      }
+      const key = [
+        input.appId,
+        input.userId,
+        input.eventName,
+        (_a = input.transactionId) != null ? _a : "",
+        (_b = input.timestamp) != null ? _b : ""
+      ].join("|");
+      return (0, uuid_1.v5)(key, exports.TRACKSTALL_EVENT_NAMESPACE);
+    }
+    function randomEventId3() {
+      return (0, uuid_1.v4)();
+    }
+  }
+});
+
+// ../core/dist/revenueRules.js
+var require_revenueRules = __commonJS({
+  "../core/dist/revenueRules.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.STORE_FEE_DEFAULTS = void 0;
+    exports.buildRevenue = buildRevenue2;
+    exports.STORE_FEE_DEFAULTS = {
+      apple: 0.3,
+      google: 0.3,
+      stripe: 0.029,
+      web: 0.029,
+      unknown: 0
+    };
+    function buildRevenue2(input) {
+      if (!Number.isFinite(input.value)) {
+        throw new Error(`buildRevenue: value must be a finite number (got ${input.value})`);
+      }
+      if (input.value < 0) {
+        throw new Error(`buildRevenue: value must be non-negative (got ${input.value})`);
+      }
+      if (!input.currency || input.currency.length !== 3) {
+        throw new Error(`buildRevenue: currency must be a 3-letter ISO 4217 code (got ${JSON.stringify(input.currency)})`);
+      }
+      const rate = resolveFeeRate(input.store, input.feeRateOverride);
+      const isNetInput = input.netOfStoreFee === true;
+      const grossValue = isNetInput ? input.value / (1 - rate) : input.value;
+      const netValue = isNetInput ? input.value : input.value * (1 - rate);
+      return {
+        grossValue: round2(grossValue),
+        netValue: round2(netValue),
+        currency: input.currency.toUpperCase(),
+        store: input.store,
+        transactionId: input.transactionId
+      };
+    }
+    function resolveFeeRate(store, override) {
+      if (override !== void 0) {
+        if (!Number.isFinite(override) || override < 0 || override >= 1) {
+          throw new Error(`buildRevenue: feeRateOverride must be in [0, 1) (got ${override})`);
+        }
+        return override;
+      }
+      return exports.STORE_FEE_DEFAULTS[store];
+    }
+    function round2(value) {
+      return Math.round(value * 100) / 100;
+    }
+  }
+});
+
+// (disabled):crypto
+var require_crypto = __commonJS({
+  "(disabled):crypto"() {
+  }
+});
+
+// (disabled):buffer
+var require_buffer = __commonJS({
+  "(disabled):buffer"() {
+  }
+});
+
+// ../../node_modules/js-sha256/src/sha256.js
+var require_sha256 = __commonJS({
+  "../../node_modules/js-sha256/src/sha256.js"(exports, module2) {
+    (function() {
+      "use strict";
+      var ERROR = "input is invalid type";
+      var WINDOW = typeof window === "object";
+      var root = WINDOW ? window : {};
+      if (root.JS_SHA256_NO_WINDOW) {
+        WINDOW = false;
+      }
+      var WEB_WORKER = !WINDOW && typeof self === "object";
+      var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === "object" && process.versions && process.versions.node && process.type != "renderer";
+      if (NODE_JS) {
+        root = global;
+      } else if (WEB_WORKER) {
+        root = self;
+      }
+      var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module2 === "object" && module2.exports;
+      var AMD = typeof define === "function" && define.amd;
+      var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== "undefined";
+      var HEX_CHARS = "0123456789abcdef".split("");
+      var EXTRA = [-2147483648, 8388608, 32768, 128];
+      var SHIFT = [24, 16, 8, 0];
+      var K = [
+        1116352408,
+        1899447441,
+        3049323471,
+        3921009573,
+        961987163,
+        1508970993,
+        2453635748,
+        2870763221,
+        3624381080,
+        310598401,
+        607225278,
+        1426881987,
+        1925078388,
+        2162078206,
+        2614888103,
+        3248222580,
+        3835390401,
+        4022224774,
+        264347078,
+        604807628,
+        770255983,
+        1249150122,
+        1555081692,
+        1996064986,
+        2554220882,
+        2821834349,
+        2952996808,
+        3210313671,
+        3336571891,
+        3584528711,
+        113926993,
+        338241895,
+        666307205,
+        773529912,
+        1294757372,
+        1396182291,
+        1695183700,
+        1986661051,
+        2177026350,
+        2456956037,
+        2730485921,
+        2820302411,
+        3259730800,
+        3345764771,
+        3516065817,
+        3600352804,
+        4094571909,
+        275423344,
+        430227734,
+        506948616,
+        659060556,
+        883997877,
+        958139571,
+        1322822218,
+        1537002063,
+        1747873779,
+        1955562222,
+        2024104815,
+        2227730452,
+        2361852424,
+        2428436474,
+        2756734187,
+        3204031479,
+        3329325298
+      ];
+      var OUTPUT_TYPES = ["hex", "array", "digest", "arrayBuffer"];
+      var blocks = [];
+      if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {
+        Array.isArray = function(obj) {
+          return Object.prototype.toString.call(obj) === "[object Array]";
+        };
+      }
+      if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+        ArrayBuffer.isView = function(obj) {
+          return typeof obj === "object" && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+        };
+      }
+      var createOutputMethod = function(outputType, is224) {
+        return function(message) {
+          return new Sha256(is224, true).update(message)[outputType]();
+        };
+      };
+      var createMethod = function(is224) {
+        var method = createOutputMethod("hex", is224);
+        if (NODE_JS) {
+          method = nodeWrap(method, is224);
+        }
+        method.create = function() {
+          return new Sha256(is224);
+        };
+        method.update = function(message) {
+          return method.create().update(message);
+        };
+        for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+          var type = OUTPUT_TYPES[i];
+          method[type] = createOutputMethod(type, is224);
+        }
+        return method;
+      };
+      var nodeWrap = function(method, is224) {
+        var crypto2 = require_crypto();
+        var Buffer2 = require_buffer().Buffer;
+        var algorithm = is224 ? "sha224" : "sha256";
+        var bufferFrom;
+        if (Buffer2.from && !root.JS_SHA256_NO_BUFFER_FROM) {
+          bufferFrom = Buffer2.from;
+        } else {
+          bufferFrom = function(message) {
+            return new Buffer2(message);
+          };
+        }
+        var nodeMethod = function(message) {
+          if (typeof message === "string") {
+            return crypto2.createHash(algorithm).update(message, "utf8").digest("hex");
+          } else {
+            if (message === null || message === void 0) {
+              throw new Error(ERROR);
+            } else if (message.constructor === ArrayBuffer) {
+              message = new Uint8Array(message);
+            }
+          }
+          if (Array.isArray(message) || ArrayBuffer.isView(message) || message.constructor === Buffer2) {
+            return crypto2.createHash(algorithm).update(bufferFrom(message)).digest("hex");
+          } else {
+            return method(message);
+          }
+        };
+        return nodeMethod;
+      };
+      var createHmacOutputMethod = function(outputType, is224) {
+        return function(key, message) {
+          return new HmacSha256(key, is224, true).update(message)[outputType]();
+        };
+      };
+      var createHmacMethod = function(is224) {
+        var method = createHmacOutputMethod("hex", is224);
+        method.create = function(key) {
+          return new HmacSha256(key, is224);
+        };
+        method.update = function(key, message) {
+          return method.create(key).update(message);
+        };
+        for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+          var type = OUTPUT_TYPES[i];
+          method[type] = createHmacOutputMethod(type, is224);
+        }
+        return method;
+      };
+      function Sha256(is224, sharedMemory) {
+        if (sharedMemory) {
+          blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+          this.blocks = blocks;
+        } else {
+          this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        }
+        if (is224) {
+          this.h0 = 3238371032;
+          this.h1 = 914150663;
+          this.h2 = 812702999;
+          this.h3 = 4144912697;
+          this.h4 = 4290775857;
+          this.h5 = 1750603025;
+          this.h6 = 1694076839;
+          this.h7 = 3204075428;
+        } else {
+          this.h0 = 1779033703;
+          this.h1 = 3144134277;
+          this.h2 = 1013904242;
+          this.h3 = 2773480762;
+          this.h4 = 1359893119;
+          this.h5 = 2600822924;
+          this.h6 = 528734635;
+          this.h7 = 1541459225;
+        }
+        this.block = this.start = this.bytes = this.hBytes = 0;
+        this.finalized = this.hashed = false;
+        this.first = true;
+        this.is224 = is224;
+      }
+      Sha256.prototype.update = function(message) {
+        if (this.finalized) {
+          return;
+        }
+        var notString, type = typeof message;
+        if (type !== "string") {
+          if (type === "object") {
+            if (message === null) {
+              throw new Error(ERROR);
+            } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+              message = new Uint8Array(message);
+            } else if (!Array.isArray(message)) {
+              if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+                throw new Error(ERROR);
+              }
+            }
+          } else {
+            throw new Error(ERROR);
+          }
+          notString = true;
+        }
+        var code, index = 0, i, length = message.length, blocks2 = this.blocks;
+        while (index < length) {
+          if (this.hashed) {
+            this.hashed = false;
+            blocks2[0] = this.block;
+            this.block = blocks2[16] = blocks2[1] = blocks2[2] = blocks2[3] = blocks2[4] = blocks2[5] = blocks2[6] = blocks2[7] = blocks2[8] = blocks2[9] = blocks2[10] = blocks2[11] = blocks2[12] = blocks2[13] = blocks2[14] = blocks2[15] = 0;
+          }
+          if (notString) {
+            for (i = this.start; index < length && i < 64; ++index) {
+              blocks2[i >>> 2] |= message[index] << SHIFT[i++ & 3];
+            }
+          } else {
+            for (i = this.start; index < length && i < 64; ++index) {
+              code = message.charCodeAt(index);
+              if (code < 128) {
+                blocks2[i >>> 2] |= code << SHIFT[i++ & 3];
+              } else if (code < 2048) {
+                blocks2[i >>> 2] |= (192 | code >>> 6) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
+              } else if (code < 55296 || code >= 57344) {
+                blocks2[i >>> 2] |= (224 | code >>> 12) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code >>> 6 & 63) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
+              } else {
+                code = 65536 + ((code & 1023) << 10 | message.charCodeAt(++index) & 1023);
+                blocks2[i >>> 2] |= (240 | code >>> 18) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code >>> 12 & 63) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code >>> 6 & 63) << SHIFT[i++ & 3];
+                blocks2[i >>> 2] |= (128 | code & 63) << SHIFT[i++ & 3];
+              }
+            }
+          }
+          this.lastByteIndex = i;
+          this.bytes += i - this.start;
+          if (i >= 64) {
+            this.block = blocks2[16];
+            this.start = i - 64;
+            this.hash();
+            this.hashed = true;
+          } else {
+            this.start = i;
+          }
+        }
+        if (this.bytes > 4294967295) {
+          this.hBytes += this.bytes / 4294967296 << 0;
+          this.bytes = this.bytes % 4294967296;
+        }
+        return this;
+      };
+      Sha256.prototype.finalize = function() {
+        if (this.finalized) {
+          return;
+        }
+        this.finalized = true;
+        var blocks2 = this.blocks, i = this.lastByteIndex;
+        blocks2[16] = this.block;
+        blocks2[i >>> 2] |= EXTRA[i & 3];
+        this.block = blocks2[16];
+        if (i >= 56) {
+          if (!this.hashed) {
+            this.hash();
+          }
+          blocks2[0] = this.block;
+          blocks2[16] = blocks2[1] = blocks2[2] = blocks2[3] = blocks2[4] = blocks2[5] = blocks2[6] = blocks2[7] = blocks2[8] = blocks2[9] = blocks2[10] = blocks2[11] = blocks2[12] = blocks2[13] = blocks2[14] = blocks2[15] = 0;
+        }
+        blocks2[14] = this.hBytes << 3 | this.bytes >>> 29;
+        blocks2[15] = this.bytes << 3;
+        this.hash();
+      };
+      Sha256.prototype.hash = function() {
+        var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f2 = this.h5, g = this.h6, h = this.h7, blocks2 = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
+        for (j = 16; j < 64; ++j) {
+          t1 = blocks2[j - 15];
+          s0 = (t1 >>> 7 | t1 << 25) ^ (t1 >>> 18 | t1 << 14) ^ t1 >>> 3;
+          t1 = blocks2[j - 2];
+          s1 = (t1 >>> 17 | t1 << 15) ^ (t1 >>> 19 | t1 << 13) ^ t1 >>> 10;
+          blocks2[j] = blocks2[j - 16] + s0 + blocks2[j - 7] + s1 << 0;
+        }
+        bc = b & c;
+        for (j = 0; j < 64; j += 4) {
+          if (this.first) {
+            if (this.is224) {
+              ab = 300032;
+              t1 = blocks2[0] - 1413257819;
+              h = t1 - 150054599 << 0;
+              d = t1 + 24177077 << 0;
+            } else {
+              ab = 704751109;
+              t1 = blocks2[0] - 210244248;
+              h = t1 - 1521486534 << 0;
+              d = t1 + 143694565 << 0;
+            }
+            this.first = false;
+          } else {
+            s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+            s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+            ab = a & b;
+            maj = ab ^ a & c ^ bc;
+            ch = e & f2 ^ ~e & g;
+            t1 = h + s1 + ch + K[j] + blocks2[j];
+            t2 = s0 + maj;
+            h = d + t1 << 0;
+            d = t1 + t2 << 0;
+          }
+          s0 = (d >>> 2 | d << 30) ^ (d >>> 13 | d << 19) ^ (d >>> 22 | d << 10);
+          s1 = (h >>> 6 | h << 26) ^ (h >>> 11 | h << 21) ^ (h >>> 25 | h << 7);
+          da = d & a;
+          maj = da ^ d & b ^ ab;
+          ch = h & e ^ ~h & f2;
+          t1 = g + s1 + ch + K[j + 1] + blocks2[j + 1];
+          t2 = s0 + maj;
+          g = c + t1 << 0;
+          c = t1 + t2 << 0;
+          s0 = (c >>> 2 | c << 30) ^ (c >>> 13 | c << 19) ^ (c >>> 22 | c << 10);
+          s1 = (g >>> 6 | g << 26) ^ (g >>> 11 | g << 21) ^ (g >>> 25 | g << 7);
+          cd = c & d;
+          maj = cd ^ c & a ^ da;
+          ch = g & h ^ ~g & e;
+          t1 = f2 + s1 + ch + K[j + 2] + blocks2[j + 2];
+          t2 = s0 + maj;
+          f2 = b + t1 << 0;
+          b = t1 + t2 << 0;
+          s0 = (b >>> 2 | b << 30) ^ (b >>> 13 | b << 19) ^ (b >>> 22 | b << 10);
+          s1 = (f2 >>> 6 | f2 << 26) ^ (f2 >>> 11 | f2 << 21) ^ (f2 >>> 25 | f2 << 7);
+          bc = b & c;
+          maj = bc ^ b & d ^ cd;
+          ch = f2 & g ^ ~f2 & h;
+          t1 = e + s1 + ch + K[j + 3] + blocks2[j + 3];
+          t2 = s0 + maj;
+          e = a + t1 << 0;
+          a = t1 + t2 << 0;
+          this.chromeBugWorkAround = true;
+        }
+        this.h0 = this.h0 + a << 0;
+        this.h1 = this.h1 + b << 0;
+        this.h2 = this.h2 + c << 0;
+        this.h3 = this.h3 + d << 0;
+        this.h4 = this.h4 + e << 0;
+        this.h5 = this.h5 + f2 << 0;
+        this.h6 = this.h6 + g << 0;
+        this.h7 = this.h7 + h << 0;
+      };
+      Sha256.prototype.hex = function() {
+        this.finalize();
+        var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7;
+        var hex = HEX_CHARS[h0 >>> 28 & 15] + HEX_CHARS[h0 >>> 24 & 15] + HEX_CHARS[h0 >>> 20 & 15] + HEX_CHARS[h0 >>> 16 & 15] + HEX_CHARS[h0 >>> 12 & 15] + HEX_CHARS[h0 >>> 8 & 15] + HEX_CHARS[h0 >>> 4 & 15] + HEX_CHARS[h0 & 15] + HEX_CHARS[h1 >>> 28 & 15] + HEX_CHARS[h1 >>> 24 & 15] + HEX_CHARS[h1 >>> 20 & 15] + HEX_CHARS[h1 >>> 16 & 15] + HEX_CHARS[h1 >>> 12 & 15] + HEX_CHARS[h1 >>> 8 & 15] + HEX_CHARS[h1 >>> 4 & 15] + HEX_CHARS[h1 & 15] + HEX_CHARS[h2 >>> 28 & 15] + HEX_CHARS[h2 >>> 24 & 15] + HEX_CHARS[h2 >>> 20 & 15] + HEX_CHARS[h2 >>> 16 & 15] + HEX_CHARS[h2 >>> 12 & 15] + HEX_CHARS[h2 >>> 8 & 15] + HEX_CHARS[h2 >>> 4 & 15] + HEX_CHARS[h2 & 15] + HEX_CHARS[h3 >>> 28 & 15] + HEX_CHARS[h3 >>> 24 & 15] + HEX_CHARS[h3 >>> 20 & 15] + HEX_CHARS[h3 >>> 16 & 15] + HEX_CHARS[h3 >>> 12 & 15] + HEX_CHARS[h3 >>> 8 & 15] + HEX_CHARS[h3 >>> 4 & 15] + HEX_CHARS[h3 & 15] + HEX_CHARS[h4 >>> 28 & 15] + HEX_CHARS[h4 >>> 24 & 15] + HEX_CHARS[h4 >>> 20 & 15] + HEX_CHARS[h4 >>> 16 & 15] + HEX_CHARS[h4 >>> 12 & 15] + HEX_CHARS[h4 >>> 8 & 15] + HEX_CHARS[h4 >>> 4 & 15] + HEX_CHARS[h4 & 15] + HEX_CHARS[h5 >>> 28 & 15] + HEX_CHARS[h5 >>> 24 & 15] + HEX_CHARS[h5 >>> 20 & 15] + HEX_CHARS[h5 >>> 16 & 15] + HEX_CHARS[h5 >>> 12 & 15] + HEX_CHARS[h5 >>> 8 & 15] + HEX_CHARS[h5 >>> 4 & 15] + HEX_CHARS[h5 & 15] + HEX_CHARS[h6 >>> 28 & 15] + HEX_CHARS[h6 >>> 24 & 15] + HEX_CHARS[h6 >>> 20 & 15] + HEX_CHARS[h6 >>> 16 & 15] + HEX_CHARS[h6 >>> 12 & 15] + HEX_CHARS[h6 >>> 8 & 15] + HEX_CHARS[h6 >>> 4 & 15] + HEX_CHARS[h6 & 15];
+        if (!this.is224) {
+          hex += HEX_CHARS[h7 >>> 28 & 15] + HEX_CHARS[h7 >>> 24 & 15] + HEX_CHARS[h7 >>> 20 & 15] + HEX_CHARS[h7 >>> 16 & 15] + HEX_CHARS[h7 >>> 12 & 15] + HEX_CHARS[h7 >>> 8 & 15] + HEX_CHARS[h7 >>> 4 & 15] + HEX_CHARS[h7 & 15];
+        }
+        return hex;
+      };
+      Sha256.prototype.toString = Sha256.prototype.hex;
+      Sha256.prototype.digest = function() {
+        this.finalize();
+        var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7;
+        var arr = [
+          h0 >>> 24 & 255,
+          h0 >>> 16 & 255,
+          h0 >>> 8 & 255,
+          h0 & 255,
+          h1 >>> 24 & 255,
+          h1 >>> 16 & 255,
+          h1 >>> 8 & 255,
+          h1 & 255,
+          h2 >>> 24 & 255,
+          h2 >>> 16 & 255,
+          h2 >>> 8 & 255,
+          h2 & 255,
+          h3 >>> 24 & 255,
+          h3 >>> 16 & 255,
+          h3 >>> 8 & 255,
+          h3 & 255,
+          h4 >>> 24 & 255,
+          h4 >>> 16 & 255,
+          h4 >>> 8 & 255,
+          h4 & 255,
+          h5 >>> 24 & 255,
+          h5 >>> 16 & 255,
+          h5 >>> 8 & 255,
+          h5 & 255,
+          h6 >>> 24 & 255,
+          h6 >>> 16 & 255,
+          h6 >>> 8 & 255,
+          h6 & 255
+        ];
+        if (!this.is224) {
+          arr.push(h7 >>> 24 & 255, h7 >>> 16 & 255, h7 >>> 8 & 255, h7 & 255);
+        }
+        return arr;
+      };
+      Sha256.prototype.array = Sha256.prototype.digest;
+      Sha256.prototype.arrayBuffer = function() {
+        this.finalize();
+        var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
+        var dataView = new DataView(buffer);
+        dataView.setUint32(0, this.h0);
+        dataView.setUint32(4, this.h1);
+        dataView.setUint32(8, this.h2);
+        dataView.setUint32(12, this.h3);
+        dataView.setUint32(16, this.h4);
+        dataView.setUint32(20, this.h5);
+        dataView.setUint32(24, this.h6);
+        if (!this.is224) {
+          dataView.setUint32(28, this.h7);
+        }
+        return buffer;
+      };
+      function HmacSha256(key, is224, sharedMemory) {
+        var i, type = typeof key;
+        if (type === "string") {
+          var bytes = [], length = key.length, index = 0, code;
+          for (i = 0; i < length; ++i) {
+            code = key.charCodeAt(i);
+            if (code < 128) {
+              bytes[index++] = code;
+            } else if (code < 2048) {
+              bytes[index++] = 192 | code >>> 6;
+              bytes[index++] = 128 | code & 63;
+            } else if (code < 55296 || code >= 57344) {
+              bytes[index++] = 224 | code >>> 12;
+              bytes[index++] = 128 | code >>> 6 & 63;
+              bytes[index++] = 128 | code & 63;
+            } else {
+              code = 65536 + ((code & 1023) << 10 | key.charCodeAt(++i) & 1023);
+              bytes[index++] = 240 | code >>> 18;
+              bytes[index++] = 128 | code >>> 12 & 63;
+              bytes[index++] = 128 | code >>> 6 & 63;
+              bytes[index++] = 128 | code & 63;
+            }
+          }
+          key = bytes;
+        } else {
+          if (type === "object") {
+            if (key === null) {
+              throw new Error(ERROR);
+            } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+              key = new Uint8Array(key);
+            } else if (!Array.isArray(key)) {
+              if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+                throw new Error(ERROR);
+              }
+            }
+          } else {
+            throw new Error(ERROR);
+          }
+        }
+        if (key.length > 64) {
+          key = new Sha256(is224, true).update(key).array();
+        }
+        var oKeyPad = [], iKeyPad = [];
+        for (i = 0; i < 64; ++i) {
+          var b = key[i] || 0;
+          oKeyPad[i] = 92 ^ b;
+          iKeyPad[i] = 54 ^ b;
+        }
+        Sha256.call(this, is224, sharedMemory);
+        this.update(iKeyPad);
+        this.oKeyPad = oKeyPad;
+        this.inner = true;
+        this.sharedMemory = sharedMemory;
+      }
+      HmacSha256.prototype = new Sha256();
+      HmacSha256.prototype.finalize = function() {
+        Sha256.prototype.finalize.call(this);
+        if (this.inner) {
+          this.inner = false;
+          var innerHash = this.array();
+          Sha256.call(this, this.is224, this.sharedMemory);
+          this.update(this.oKeyPad);
+          this.update(innerHash);
+          Sha256.prototype.finalize.call(this);
+        }
+      };
+      var exports2 = createMethod();
+      exports2.sha256 = exports2;
+      exports2.sha224 = createMethod(true);
+      exports2.sha256.hmac = createHmacMethod();
+      exports2.sha224.hmac = createHmacMethod(true);
+      if (COMMON_JS) {
+        module2.exports = exports2;
+      } else {
+        root.sha256 = exports2.sha256;
+        root.sha224 = exports2.sha224;
+        if (AMD) {
+          define(function() {
+            return exports2;
+          });
+        }
+      }
+    })();
+  }
+});
+
+// ../core/dist/hash.js
+var require_hash = __commonJS({
+  "../core/dist/hash.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hashEmail = hashEmail2;
+    exports.hashPhone = hashPhone2;
+    exports.hashPii = hashPii;
+    exports.sha256Hex = sha256Hex;
+    var js_sha256_1 = require_sha256();
+    function hashEmail2(email) {
+      if (!email)
+        return void 0;
+      const normalized = email.trim().toLowerCase();
+      if (normalized.length === 0)
+        return void 0;
+      return (0, js_sha256_1.sha256)(normalized);
+    }
+    function hashPhone2(phone) {
+      if (!phone)
+        return void 0;
+      const digits = phone.replace(/\D/g, "");
+      if (digits.length === 0)
+        return void 0;
+      return (0, js_sha256_1.sha256)(digits);
+    }
+    function hashPii(value) {
+      if (!value)
+        return void 0;
+      const normalized = value.trim().toLowerCase();
+      if (normalized.length === 0)
+        return void 0;
+      return (0, js_sha256_1.sha256)(normalized);
+    }
+    function sha256Hex(value) {
+      return (0, js_sha256_1.sha256)(value);
+    }
+  }
+});
+
+// ../core/dist/index.js
+var require_dist = __commonJS({
+  "../core/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_schema(), exports);
+    __exportStar(require_productEvent(), exports);
+    __exportStar(require_eventId(), exports);
+    __exportStar(require_revenueRules(), exports);
+    __exportStar(require_hash(), exports);
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_RETRY: () => DEFAULT_RETRY,
+  EventQueue: () => EventQueue,
+  MemoryStorage: () => MemoryStorage,
+  MetaAdapter: () => MetaAdapter,
+  TikTokAdapter: () => TikTokAdapter,
+  Transport: () => Transport,
+  buildRevenue: () => import_core3.buildRevenue,
+  collectDeviceContext: () => collectDeviceContext,
+  computeRetryDelayMs: () => computeRetryDelayMs,
+  createTrackStallClient: () => createTrackStallClient,
+  defaultStorage: () => defaultStorage,
+  deterministicEventId: () => import_core3.deterministicEventId,
+  getAttStatus: () => getAttStatus,
+  isRetriableStatus: () => isRetriableStatus,
+  loadAttModule: () => loadAttModule,
+  mapToMetaEvent: () => mapToMetaEvent,
+  mapToTikTokEvent: () => mapToTikTokEvent,
+  normalizeAttStatus: () => normalizeAttStatus,
+  randomEventId: () => import_core3.randomEventId,
+  readAdvertisingId: () => readAdvertisingId,
+  requestAttStatus: () => requestAttStatus,
+  resolveRetryConfig: () => resolveRetryConfig,
+  shouldRetry: () => shouldRetry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_core2 = __toESM(require_dist());
+
+// src/att.ts
+function loadAttModule(injected) {
+  if (injected) return injected;
+  try {
+    return require("expo-tracking-transparency");
+  } catch {
+  }
+  try {
+    return require("react-native-tracking-transparency");
+  } catch {
+  }
+  return null;
+}
+async function requestAttStatus(mod) {
+  if (mod.requestTrackingPermissionsAsync) {
+    const res = await mod.requestTrackingPermissionsAsync();
+    return normalizeAttStatus(res == null ? void 0 : res.status);
+  }
+  if (mod.requestTrackingPermission) {
+    return normalizeAttStatus(await mod.requestTrackingPermission());
+  }
+  return "unavailable";
+}
+function readAdvertisingId(mod) {
+  if (!mod.getAdvertisingId) return void 0;
+  try {
+    const id = mod.getAdvertisingId();
+    if (!id || id === "00000000-0000-0000-0000-000000000000") return void 0;
+    return id;
+  } catch {
+    return void 0;
+  }
+}
+async function getAttStatus(mod) {
+  if (mod.getTrackingPermissionsAsync) {
+    const res = await mod.getTrackingPermissionsAsync();
+    return normalizeAttStatus(res == null ? void 0 : res.status);
+  }
+  if (mod.getTrackingStatus) {
+    return normalizeAttStatus(await mod.getTrackingStatus());
+  }
+  return "unavailable";
+}
+function normalizeAttStatus(raw) {
+  switch (raw) {
+    case "authorized":
+    case "granted":
+      return "authorized";
+    case "denied":
+      return "denied";
+    case "restricted":
+      return "restricted";
+    case "not-determined":
+    case "undetermined":
+      return "undetermined";
+    default:
+      return "unavailable";
+  }
+}
+
+// src/deviceContext.ts
+var ZERO_UUID = "00000000-0000-0000-0000-000000000000";
+function collectDeviceContext() {
+  var _a, _b;
+  const out = {};
+  const rn = loadReactNative();
+  if (rn == null ? void 0 : rn.Dimensions) {
+    try {
+      const screen = (_a = rn.Dimensions.get("screen")) != null ? _a : rn.Dimensions.get("window");
+      if (screen) {
+        if (Number.isFinite(screen.width)) out.screenW = Math.round(screen.width);
+        if (Number.isFinite(screen.height)) out.screenH = Math.round(screen.height);
+        if (typeof screen.scale === "number" && Number.isFinite(screen.scale)) out.pixelRatio = screen.scale;
+      }
+    } catch {
+    }
+  }
+  if (out.pixelRatio === void 0 && (rn == null ? void 0 : rn.PixelRatio)) {
+    try {
+      const ratio = rn.PixelRatio.get();
+      if (typeof ratio === "number" && Number.isFinite(ratio)) out.pixelRatio = ratio;
+    } catch {
+    }
+  }
+  const expoDevice = loadExpoDevice();
+  if (expoDevice == null ? void 0 : expoDevice.modelName) out.deviceModel = expoDevice.modelName;
+  if (expoDevice == null ? void 0 : expoDevice.osVersion) out.osVersion = expoDevice.osVersion;
+  if (out.osVersion === void 0 && ((_b = rn == null ? void 0 : rn.Platform) == null ? void 0 : _b.Version) !== void 0) {
+    out.osVersion = String(rn.Platform.Version);
+  }
+  const locale = detectLocale();
+  if (locale) out.locale = locale;
+  const timezone = detectTimezone();
+  if (timezone) out.timezone = timezone;
+  return pruneUndefined(out);
+}
+function loadReactNative() {
+  try {
+    return require("react-native");
+  } catch {
+    return null;
+  }
+}
+function loadExpoDevice() {
+  try {
+    return require("expo-device");
+  } catch {
+    return null;
+  }
+}
+function loadExpoApplication() {
+  try {
+    return require("expo-application");
+  } catch {
+    return null;
+  }
+}
+async function collectIosIdForVendor() {
+  const app = loadExpoApplication();
+  if (!(app == null ? void 0 : app.getIosIdForVendorAsync)) return void 0;
+  try {
+    const idfv = await app.getIosIdForVendorAsync();
+    if (!idfv || idfv === ZERO_UUID) return void 0;
+    return idfv;
+  } catch {
+    return void 0;
+  }
+}
+function detectLocale() {
+  try {
+    const resolved = Intl.DateTimeFormat().resolvedOptions().locale;
+    return resolved || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectTimezone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return tz || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function pruneUndefined(obj) {
+  for (const k of Object.keys(obj)) {
+    if (obj[k] === void 0) delete obj[k];
+  }
+  return obj;
+}
+
+// src/adapters/metaAdapter.ts
+var import_core = __toESM(require_dist());
+var MetaAdapter = class {
+  constructor(options) {
+    this.options = options;
+    this.sdk = null;
+    var _a;
+    this.name = (_a = options.name) != null ? _a : "meta";
+    this.honorAtt = options.honorAtt !== false;
+  }
+  async initialize() {
+    var _a, _b, _c, _d, _e, _f;
+    const sdk = this.loadSdk();
+    sdk.Settings.setAppID(this.options.appId);
+    sdk.Settings.setClientToken(this.options.clientToken);
+    if (this.honorAtt) {
+      await Promise.resolve((_b = (_a = sdk.Settings).setAdvertiserTrackingEnabled) == null ? void 0 : _b.call(_a, true));
+      await Promise.resolve((_d = (_c = sdk.Settings).setAdvertiserIDCollectionEnabled) == null ? void 0 : _d.call(_c, true));
+    }
+    await Promise.resolve((_f = (_e = sdk.Settings).setAutoLogAppEventsEnabled) == null ? void 0 : _f.call(_e, false));
+    sdk.Settings.initializeSDK();
+    this.sdk = sdk;
+  }
+  setUser(identity) {
+    var _a, _b, _c, _d, _e;
+    if (!this.sdk) return;
+    if (!identity) {
+      this.sdk.AppEventsLogger.clearUserID();
+      (_b = (_a = this.sdk.AppEventsLogger).clearUserData) == null ? void 0 : _b.call(_a);
+      return;
+    }
+    this.sdk.AppEventsLogger.setUserID(identity.userId);
+    this.sdk.AppEventsLogger.setUserData({
+      em: (_c = (0, import_core.hashEmail)(identity.email)) != null ? _c : null,
+      ph: (_d = (0, import_core.hashPhone)(identity.phone)) != null ? _d : null,
+      country: (_e = identity.country) != null ? _e : null
+    });
+  }
+  async deliver(event) {
+    if (!this.sdk) {
+      return { ok: false, code: "sdk_not_initialized", retriable: true };
+    }
+    try {
+      const mapped = mapToMetaEvent(event);
+      if (!mapped) return { ok: true, code: "unmapped" };
+      const params = withEventId(mapped.parameters, event.eventId);
+      if (mapped.kind === "purchase" && mapped.amount !== void 0 && mapped.currency) {
+        this.sdk.AppEventsLogger.logPurchase(mapped.amount, mapped.currency, params);
+      } else if (mapped.valueToSum !== void 0) {
+        this.sdk.AppEventsLogger.logEvent(mapped.name, mapped.valueToSum, params);
+      } else {
+        this.sdk.AppEventsLogger.logEvent(mapped.name, params);
+      }
+      return { ok: true };
+    } catch (err) {
+      return {
+        ok: false,
+        code: "sdk_threw",
+        message: err instanceof Error ? err.message : String(err),
+        retriable: true
+      };
+    }
+  }
+  async flush() {
+    var _a;
+    (_a = this.sdk) == null ? void 0 : _a.AppEventsLogger.flush();
+  }
+  async setAdvertiserTracking(enabled) {
+    var _a, _b, _c, _d;
+    if (!this.sdk || !this.honorAtt) return;
+    await Promise.resolve((_b = (_a = this.sdk.Settings).setAdvertiserTrackingEnabled) == null ? void 0 : _b.call(_a, enabled));
+    await Promise.resolve((_d = (_c = this.sdk.Settings).setAdvertiserIDCollectionEnabled) == null ? void 0 : _d.call(_c, enabled));
+  }
+  loadSdk() {
+    if (this.options.sdkLoader) return this.options.sdkLoader();
+    try {
+      return require("react-native-fbsdk-next");
+    } catch (err) {
+      throw new Error(
+        `@trackstall/sdk: failed to load \`react-native-fbsdk-next\`. Install it in the host app and run \`pod install\`. Underlying error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+function mapToMetaEvent(event) {
+  var _a, _b, _c, _d, _e, _f;
+  const baseParams = { fb_event_source: "trackstall" };
+  if (event.productId) baseParams["fb_content_id"] = event.productId;
+  if (event.properties) {
+    for (const [k, v] of Object.entries(event.properties)) {
+      if (v === null) continue;
+      baseParams[k] = v;
+    }
+  }
+  switch (event.name) {
+    case "purchase":
+      if (!event.revenue) return null;
+      return {
+        name: "fb_mobile_purchase",
+        kind: "purchase",
+        amount: event.revenue.netValue,
+        currency: event.revenue.currency,
+        parameters: { ...baseParams, fb_content_type: "product", fb_currency: event.revenue.currency }
+      };
+    case "subscribe":
+      if (!event.revenue) return null;
+      return {
+        name: "Subscribe",
+        kind: "standard",
+        valueToSum: event.revenue.netValue,
+        parameters: { ...baseParams, fb_content_type: "product", fb_currency: event.revenue.currency }
+      };
+    case "renewal":
+      if (!event.revenue) return null;
+      return {
+        name: "Renewal",
+        kind: "custom",
+        valueToSum: event.revenue.netValue,
+        parameters: { ...baseParams, fb_content_type: "product", fb_currency: event.revenue.currency }
+      };
+    case "refund":
+      if (!event.revenue) return null;
+      return {
+        name: "fb_mobile_purchase",
+        kind: "purchase",
+        amount: -Math.abs(event.revenue.netValue),
+        currency: event.revenue.currency,
+        parameters: { ...baseParams, fb_content_type: "product", is_refund: true }
+      };
+    case "trial_started":
+      return {
+        name: "StartTrial",
+        kind: "standard",
+        valueToSum: (_a = event.revenue) == null ? void 0 : _a.netValue,
+        parameters: { ...baseParams, fb_currency: (_b = event.revenue) == null ? void 0 : _b.currency, fb_content_type: "product" }
+      };
+    case "start_checkout":
+      return {
+        name: "fb_mobile_initiated_checkout",
+        kind: "standard",
+        valueToSum: (_c = event.revenue) == null ? void 0 : _c.netValue,
+        parameters: { ...baseParams, fb_currency: (_d = event.revenue) == null ? void 0 : _d.currency, fb_num_items: 1 }
+      };
+    case "add_to_cart":
+      return {
+        name: "fb_mobile_add_to_cart",
+        kind: "standard",
+        valueToSum: (_e = event.revenue) == null ? void 0 : _e.netValue,
+        parameters: { ...baseParams, fb_currency: (_f = event.revenue) == null ? void 0 : _f.currency }
+      };
+    case "paywall_shown":
+    case "content_view":
+      return { name: "fb_mobile_content_view", kind: "standard", parameters: baseParams };
+    case "install":
+      return { name: "fb_mobile_activate_app", kind: "standard", parameters: baseParams };
+    case "onboarding_completed":
+      return { name: "fb_mobile_complete_registration", kind: "standard", parameters: baseParams };
+    case "app_open":
+      return null;
+    case "cancellation":
+    case "expiration":
+      return null;
+    case "onboarding_started":
+    case "onboarding_step":
+    case "paywall_dismissed":
+    case "level_complete":
+    case "tutorial_complete":
+      return { name: event.name, kind: "custom", parameters: baseParams };
+    default:
+      return { name: event.name, kind: "custom", parameters: baseParams };
+  }
+}
+function withEventId(parameters, eventId) {
+  return { ...parameters, _eventID: eventId };
+}
+
+// src/adapters/tiktokAdapter.ts
+var TikTokAdapter = class {
+  constructor(options) {
+    this.options = options;
+    this.sdk = null;
+    this.currentUserId = null;
+    var _a;
+    this.name = (_a = options.name) != null ? _a : "tiktok";
+  }
+  async initialize() {
+    var _a;
+    const sdk = this.loadSdk();
+    await sdk.default.initialize(this.options.appId, this.options.tiktokAppId, {
+      accessToken: this.options.accessToken,
+      debugMode: (_a = this.options.debugMode) != null ? _a : false,
+      autoTrackAppLifecycle: false,
+      autoTrackRouteChanges: false
+    });
+    this.sdk = sdk.default;
+  }
+  setUser(identity) {
+    var _a;
+    this.currentUserId = (_a = identity == null ? void 0 : identity.userId) != null ? _a : null;
+  }
+  async deliver(event) {
+    var _a;
+    if (!this.sdk) {
+      return { ok: false, code: "sdk_not_initialized", retriable: true };
+    }
+    const mapped = mapToTikTokEvent(event, this.currentUserId);
+    if (!mapped) return { ok: true, code: "unmapped" };
+    try {
+      let ok;
+      if (mapped.kind === "purchase" && mapped.value !== void 0 && mapped.currency) {
+        ok = await this.sdk.trackCompletePurchase(
+          mapped.value,
+          mapped.currency,
+          (_a = mapped.contents) != null ? _a : [],
+          mapped.params
+        );
+      } else {
+        ok = await this.sdk.trackEvent(mapped.name, mapped.params);
+      }
+      if (ok) return { ok: true };
+      return { ok: false, code: "sdk_returned_false", retriable: true };
+    } catch (err) {
+      return {
+        ok: false,
+        code: "sdk_threw",
+        message: err instanceof Error ? err.message : String(err),
+        retriable: true
+      };
+    }
+  }
+  loadSdk() {
+    if (this.options.sdkLoader) return this.options.sdkLoader();
+    try {
+      return require("@layers/expo-tiktok-business");
+    } catch (err) {
+      throw new Error(
+        `@trackstall/sdk: failed to load \`@layers/expo-tiktok-business\`. Install it in the host app and run \`pod install\`. Underlying error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+function mapToTikTokEvent(event, userId) {
+  var _a, _b, _c, _d, _e, _f;
+  const baseParams = { event_id: event.eventId };
+  if (userId) baseParams["external_id"] = userId;
+  if (event.productId) baseParams["content_id"] = event.productId;
+  if (event.properties) {
+    for (const [k, v] of Object.entries(event.properties)) {
+      if (v === null) continue;
+      baseParams[k] = v;
+    }
+  }
+  switch (event.name) {
+    case "subscribe":
+      if (!event.revenue) return null;
+      return {
+        name: "Subscribe",
+        kind: "purchase",
+        value: event.revenue.netValue,
+        currency: event.revenue.currency,
+        contents: contentsFromEvent(event),
+        params: { ...baseParams, currency: event.revenue.currency, value: event.revenue.netValue, content_type: "product" }
+      };
+    case "purchase":
+    case "renewal":
+      if (!event.revenue) return null;
+      return {
+        name: "CompletePayment",
+        kind: "purchase",
+        value: event.revenue.netValue,
+        currency: event.revenue.currency,
+        contents: contentsFromEvent(event),
+        params: { ...baseParams, currency: event.revenue.currency, value: event.revenue.netValue, content_type: "product" }
+      };
+    case "refund":
+      if (!event.revenue) return null;
+      return {
+        name: "RefundOrder",
+        kind: "custom",
+        params: { ...baseParams, currency: event.revenue.currency, value: -Math.abs(event.revenue.netValue), content_type: "product" }
+      };
+    case "start_checkout":
+      return {
+        name: "InitiateCheckout",
+        kind: "standard",
+        params: { ...baseParams, currency: (_a = event.revenue) == null ? void 0 : _a.currency, value: (_b = event.revenue) == null ? void 0 : _b.netValue }
+      };
+    case "add_to_cart":
+      return {
+        name: "AddToCart",
+        kind: "standard",
+        params: { ...baseParams, currency: (_c = event.revenue) == null ? void 0 : _c.currency, value: (_d = event.revenue) == null ? void 0 : _d.netValue }
+      };
+    case "trial_started":
+      return {
+        name: "StartTrial",
+        kind: "custom",
+        params: { ...baseParams, currency: (_e = event.revenue) == null ? void 0 : _e.currency, value: (_f = event.revenue) == null ? void 0 : _f.netValue }
+      };
+    case "paywall_shown":
+    case "content_view":
+      return { name: "ViewContent", kind: "standard", params: { ...baseParams, content_type: "paywall" } };
+    case "install":
+      return { name: "AppInstall", kind: "standard", params: baseParams };
+    case "app_open":
+      return { name: "Launch", kind: "standard", params: baseParams };
+    case "onboarding_completed":
+      return { name: "CompleteRegistration", kind: "standard", params: baseParams };
+    case "cancellation":
+    case "expiration":
+      return null;
+    case "onboarding_started":
+    case "onboarding_step":
+    case "paywall_dismissed":
+    case "level_complete":
+    case "tutorial_complete":
+      return { name: event.name, kind: "custom", params: baseParams };
+    default:
+      return { name: event.name, kind: "custom", params: baseParams };
+  }
+}
+function contentsFromEvent(event) {
+  var _a, _b;
+  if (!event.revenue) return [];
+  return [
+    {
+      content_id: (_b = (_a = event.productId) != null ? _a : event.revenue.transactionId) != null ? _b : "unknown",
+      content_type: "product",
+      quantity: 1,
+      price: event.revenue.netValue
+    }
+  ];
+}
+
+// src/eventQueue.ts
+var DEFAULT_CAPACITY = 500;
+var DEFAULT_STORAGE_KEY = "trackstall.queue.v1";
+var EventQueue = class {
+  constructor(options) {
+    this.entries = [];
+    this.hydrated = false;
+    this.counter = 0;
+    this.chain = Promise.resolve();
+    var _a, _b, _c;
+    this.storage = options.storage;
+    this.logger = options.logger;
+    this.capacity = (_a = options.capacity) != null ? _a : DEFAULT_CAPACITY;
+    this.storageKey = (_b = options.storageKey) != null ? _b : DEFAULT_STORAGE_KEY;
+    this.now = (_c = options.now) != null ? _c : Date.now;
+  }
+  async hydrate() {
+    if (this.hydrated) return;
+    try {
+      const raw = await this.storage.getItem(this.storageKey);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) this.entries = parsed;
+      }
+    } catch (err) {
+      this.logger.warn("trackstall: failed to hydrate queue \u2014 starting empty", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      this.entries = [];
+    }
+    this.hydrated = true;
+  }
+  size() {
+    return this.entries.length;
+  }
+  async enqueue(eventId, body) {
+    return this.serialize(async () => {
+      this.counter += 1;
+      const entry = {
+        id: `q-${this.now()}-${this.counter}`,
+        eventId,
+        body,
+        attempts: 0,
+        nextRetryAt: 0,
+        createdAt: this.now()
+      };
+      this.entries.push(entry);
+      if (this.entries.length > this.capacity) {
+        const dropped = this.entries.length - this.capacity;
+        this.entries.splice(0, dropped);
+        this.logger.warn("trackstall: queue at capacity \u2014 dropped oldest", { dropped });
+      }
+      await this.persist();
+    });
+  }
+  /** Snapshot of entries eligible to send now (does not mutate). */
+  pullReady(limit) {
+    const nowMs = this.now();
+    return this.entries.filter((e) => e.nextRetryAt <= nowMs).slice(0, limit);
+  }
+  async markDelivered(ids) {
+    if (ids.length === 0) return;
+    return this.serialize(async () => {
+      const set = new Set(ids);
+      this.entries = this.entries.filter((e) => !set.has(e.id));
+      await this.persist();
+    });
+  }
+  async markFailed(ids, nextRetryAt) {
+    if (ids.length === 0) return;
+    return this.serialize(async () => {
+      const set = new Set(ids);
+      for (const e of this.entries) {
+        if (set.has(e.id)) {
+          e.attempts += 1;
+          e.nextRetryAt = nextRetryAt;
+        }
+      }
+      await this.persist();
+    });
+  }
+  async clear() {
+    return this.serialize(async () => {
+      this.entries = [];
+      await this.persist();
+    });
+  }
+  async persist() {
+    try {
+      await this.storage.setItem(this.storageKey, JSON.stringify(this.entries));
+    } catch (err) {
+      this.logger.warn("trackstall: failed to persist queue", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  serialize(fn) {
+    const next = this.chain.then(fn, fn);
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+};
+
+// src/retryPolicy.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 6,
+  initialDelayMs: 1e3,
+  maxDelayMs: 5 * 60 * 1e3,
+  jitter: 0.2
+};
+function resolveRetryConfig(input) {
+  var _a, _b, _c, _d;
+  return {
+    maxAttempts: (_a = input == null ? void 0 : input.maxAttempts) != null ? _a : DEFAULT_RETRY.maxAttempts,
+    initialDelayMs: (_b = input == null ? void 0 : input.initialDelayMs) != null ? _b : DEFAULT_RETRY.initialDelayMs,
+    maxDelayMs: (_c = input == null ? void 0 : input.maxDelayMs) != null ? _c : DEFAULT_RETRY.maxDelayMs,
+    jitter: (_d = input == null ? void 0 : input.jitter) != null ? _d : DEFAULT_RETRY.jitter
+  };
+}
+function computeRetryDelayMs(attempt, config, random = Math.random) {
+  if (attempt <= 0) return 0;
+  const safeAttempt = Math.min(attempt, 30);
+  const base = config.initialDelayMs * Math.pow(2, safeAttempt - 1);
+  const capped = Math.min(base, config.maxDelayMs);
+  const jitterFactor = 1 + (random() * 2 - 1) * config.jitter;
+  return Math.max(0, Math.round(capped * jitterFactor));
+}
+function shouldRetry(attemptsSoFar, retriable, config) {
+  if (retriable === false) return false;
+  return attemptsSoFar < config.maxAttempts;
+}
+
+// src/storage/memoryStorage.ts
+var MemoryStorage = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  async getItem(key) {
+    return this.map.has(key) ? this.map.get(key) : null;
+  }
+  async setItem(key, value) {
+    this.map.set(key, value);
+  }
+  async removeItem(key) {
+    this.map.delete(key);
+  }
+};
+function defaultStorage() {
+  const ls = globalThis.localStorage;
+  if (!ls) return new MemoryStorage();
+  return {
+    async getItem(key) {
+      return ls.getItem(key);
+    },
+    async setItem(key, value) {
+      ls.setItem(key, value);
+    },
+    async removeItem(key) {
+      ls.removeItem(key);
+    }
+  };
+}
+
+// src/transport.ts
+var Transport = class {
+  constructor(options) {
+    var _a, _b;
+    this.endpoint = options.endpoint.replace(/\/+$/, "");
+    this.publicKey = options.publicKey;
+    const f2 = (_a = options.fetchImpl) != null ? _a : globalThis.fetch;
+    if (typeof f2 !== "function") {
+      throw new Error("TrackStall: global fetch unavailable \u2014 pass `fetchImpl` in the config.");
+    }
+    this.fetchImpl = f2;
+    this.timeoutMs = (_b = options.timeoutMs) != null ? _b : 8e3;
+  }
+  async get(path) {
+    return this.send("GET", path, void 0);
+  }
+  async post(path, body) {
+    return this.send("POST", path, body);
+  }
+  async send(httpMethod, path, body) {
+    var _a;
+    const url = `${this.endpoint}${path.startsWith("/") ? path : `/${path}`}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: httpMethod,
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.publicKey}`
+        },
+        body: httpMethod === "GET" ? void 0 : JSON.stringify(body != null ? body : {}),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      const isAbort = (err == null ? void 0 : err.name) === "AbortError";
+      return {
+        ok: false,
+        status: 0,
+        body: null,
+        retriable: true,
+        errorMessage: isAbort ? `request timed out after ${this.timeoutMs}ms` : `network error: ${(_a = err == null ? void 0 : err.message) != null ? _a : String(err)}`
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+    const parsed = await safeJson(res);
+    if (res.ok) return { ok: true, status: res.status, body: parsed, retriable: false };
+    return {
+      ok: false,
+      status: res.status,
+      body: parsed,
+      retriable: isRetriableStatus(res.status),
+      errorMessage: `HTTP ${res.status}`
+    };
+  }
+};
+function isRetriableStatus(status) {
+  if (status >= 500) return true;
+  if (status === 408 || status === 429) return true;
+  return false;
+}
+async function safeJson(res) {
+  try {
+    const text = await res.text();
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+function createTrackStallClient(config) {
+  return new TrackStallClientImpl(config);
+}
+var EMPTY_FLUSH = { attempted: 0, delivered: 0, retryScheduled: 0, dropped: 0 };
+var ANONYMOUS_ID_STORAGE_KEY = "trackstall.anonymousId.v1";
+var ATT_REPORTED_STORAGE_KEY = "trackstall.att.reported.v1";
+var TrackStallClientImpl = class {
+  constructor(config) {
+    this.config = config;
+    this.anonymousId = null;
+    /** Latest ATT status seen at runtime — overrides `device.attStatus`. */
+    this.attStatus = null;
+    this.user = null;
+    this.initialized = false;
+    this.initializePromise = null;
+    this.flushChain = Promise.resolve();
+    /** In-app ad SDKs (Meta/TikTok) wired from remote config; dual-send lane. */
+    this.nativeAdapters = [];
+    var _a, _b, _c, _d, _e;
+    if (!config.appId) throw new Error("TrackStall: `appId` is required");
+    if (!config.publicKey) throw new Error("TrackStall: `publicKey` is required");
+    if (!config.endpoint) throw new Error("TrackStall: `endpoint` is required");
+    this.logger = (_a = config.logger) != null ? _a : defaultLogger;
+    this.enabled = config.enabled !== false;
+    this.platform = (_b = config.platform) != null ? _b : "ios";
+    this.batchSize = Math.max(1, (_c = config.batchSize) != null ? _c : 20);
+    this.now = (_d = config.now) != null ? _d : Date.now;
+    this.retry = resolveRetryConfig(config.retry);
+    this.device = { ...config.device };
+    this.transport = new Transport({
+      endpoint: config.endpoint,
+      publicKey: config.publicKey,
+      fetchImpl: config.fetchImpl,
+      timeoutMs: config.requestTimeoutMs
+    });
+    this.storage = (_e = config.storage) != null ? _e : defaultStorage();
+    this.queue = new EventQueue({
+      storage: this.storage,
+      logger: this.logger,
+      capacity: config.bufferCapacity,
+      now: this.now
+    });
+    this.analyticsQueue = new EventQueue({
+      storage: this.storage,
+      logger: this.logger,
+      capacity: config.bufferCapacity,
+      storageKey: "trackstall.analytics.queue.v1",
+      now: this.now
+    });
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initializePromise) return this.initializePromise;
+    this.initializePromise = (async () => {
+      await Promise.all([this.queue.hydrate(), this.analyticsQueue.hydrate()]);
+      this.resolveDeviceContext();
+      await this.resolveIosIdfv();
+      await this.loadAnonymousId();
+      await this.wireNativeAdapters();
+      this.initialized = true;
+      this.logger.info("trackstall: initialized", {
+        appId: this.config.appId,
+        queueSize: this.queue.size(),
+        nativeAdapters: this.nativeAdapters.map((a) => a.name)
+      });
+      void this.flushSafe();
+    })();
+    return this.initializePromise;
+  }
+  setUser(identity) {
+    this.user = identity;
+    for (const adapter of this.nativeAdapters) {
+      try {
+        adapter.setUser(identity);
+      } catch (err) {
+        this.logger.warn("trackstall: native setUser failed", { adapter: adapter.name });
+        void err;
+      }
+    }
+  }
+  async recordClick(input) {
+    var _a;
+    const res = await this.transport.post("/v1/click", { ...this.deviceClickFields(), ...input });
+    if (!res.ok) {
+      throw new Error(`trackstall: recordClick failed (${res.status}) ${(_a = res.errorMessage) != null ? _a : ""}`.trim());
+    }
+    return res.body;
+  }
+  async matchInstall(input = {}) {
+    var _a, _b, _c;
+    const userId = (_b = input.userId) != null ? _b : (_a = this.user) == null ? void 0 : _a.userId;
+    if (!userId) throw new Error("trackstall: matchInstall requires a userId (set a user first)");
+    const res = await this.transport.post("/v1/match", {
+      ...this.deviceClickFields(),
+      ...input,
+      userId
+    });
+    if (!res.ok) {
+      throw new Error(`trackstall: matchInstall failed (${res.status}) ${(_c = res.errorMessage) != null ? _c : ""}`.trim());
+    }
+    return res.body;
+  }
+  async reportInstallReferrer(input) {
+    var _a, _b, _c;
+    if (!this.initialized) await this.initialize();
+    const userId = (_b = input.userId) != null ? _b : (_a = this.user) == null ? void 0 : _a.userId;
+    if (!userId) {
+      throw new Error("trackstall: reportInstallReferrer requires a userId (set a user first)");
+    }
+    const res = await this.transport.post("/v1/referrer", {
+      ...this.deviceClickFields(),
+      ...input,
+      userId
+    });
+    if (!res.ok) {
+      throw new Error(
+        `trackstall: reportInstallReferrer failed (${res.status}) ${(_c = res.errorMessage) != null ? _c : ""}`.trim()
+      );
+    }
+    return res.body;
+  }
+  async track(input) {
+    var _a, _b, _c, _d;
+    const identity = (_a = input.user) != null ? _a : this.user;
+    const timestampMs = (_b = input.timestampMs) != null ? _b : this.now();
+    const timestamp = Math.floor(timestampMs / 1e3);
+    const eventId = (_d = input.eventId) != null ? _d : (identity == null ? void 0 : identity.userId) ? (0, import_core2.deterministicEventId)({
+      appId: this.config.appId,
+      userId: identity.userId,
+      eventName: input.name,
+      transactionId: (_c = input.revenue) == null ? void 0 : _c.transactionId,
+      timestamp
+    }) : (0, import_core2.randomEventId)();
+    if (!this.enabled) return eventId;
+    if (!this.initialized) await this.initialize();
+    const canonical = this.buildCanonicalEvent(input, identity, eventId, timestamp);
+    if (this.nativeAdapters.length > 0) void this.deliverNative(canonical);
+    await this.queue.enqueue(eventId, canonical);
+    void this.flushSafe();
+    return eventId;
+  }
+  async logEvent(name, properties, options = {}) {
+    var _a, _b, _c, _d;
+    const eventId = (_a = options.eventId) != null ? _a : (0, import_core2.randomEventId)();
+    if (!this.enabled) return eventId;
+    if (!this.initialized) await this.initialize();
+    const timestampMs = (_b = options.timestampMs) != null ? _b : this.now();
+    const device = this.device;
+    const body = pruneUndefined2({
+      eventId,
+      name,
+      timestamp: Math.floor(timestampMs / 1e3),
+      platform: this.platform,
+      userId: (_c = this.user) == null ? void 0 : _c.userId,
+      anonymousId: (_d = this.anonymousId) != null ? _d : void 0,
+      sessionId: options.sessionId,
+      properties: properties && Object.keys(properties).length > 0 ? properties : void 0,
+      context: pruneUndefined2({
+        appVersion: device.appVersion,
+        locale: device.locale,
+        country: device.country,
+        sdk: "trackstall-sdk"
+      })
+    });
+    await this.analyticsQueue.enqueue(eventId, body);
+    void this.flushSafe();
+    return eventId;
+  }
+  async requestAttPermission() {
+    var _a, _b, _c;
+    if (this.platform !== "ios") return "unavailable";
+    if (!this.enabled) return (_b = (_a = this.attStatus) != null ? _a : this.device.attStatus) != null ? _b : "unavailable";
+    if (!this.initialized) await this.initialize();
+    const mod = loadAttModule((_c = this.config.native) == null ? void 0 : _c.att);
+    if (!mod) {
+      this.logger.warn(
+        "trackstall: no tracking-transparency module found \u2014 install `expo-tracking-transparency` or `react-native-tracking-transparency`, or inject `native.att`"
+      );
+      return "unavailable";
+    }
+    let status;
+    try {
+      const current = await getAttStatus(mod);
+      status = current === "undetermined" ? await requestAttStatus(mod) : current;
+    } catch (err) {
+      this.logger.error("trackstall: ATT request failed", err);
+      return "unavailable";
+    }
+    await this.applyAttStatus(status);
+    return status;
+  }
+  async setAttStatus(status) {
+    if (!this.enabled) return;
+    if (!this.initialized) await this.initialize();
+    await this.applyAttStatus(status);
+  }
+  async flush() {
+    var _a;
+    if (!this.enabled) return { ...EMPTY_FLUSH };
+    for (const adapter of this.nativeAdapters) {
+      try {
+        await ((_a = adapter.flush) == null ? void 0 : _a.call(adapter));
+      } catch (err) {
+        this.logger.warn("trackstall: native flush failed", { adapter: adapter.name });
+        void err;
+      }
+    }
+    return this.scheduleFlush();
+  }
+  getDiagnostics() {
+    var _a, _b;
+    return {
+      initialized: this.initialized,
+      enabled: this.enabled,
+      appId: this.config.appId,
+      userId: (_b = (_a = this.user) == null ? void 0 : _a.userId) != null ? _b : null,
+      anonymousId: this.anonymousId,
+      queueSize: this.queue.size(),
+      analyticsQueueSize: this.analyticsQueue.size()
+    };
+  }
+  // ── Internals ──────────────────────────────────────────────────────────────
+  buildCanonicalEvent(input, identity, eventId, timestamp) {
+    var _a, _b, _c, _d;
+    const device = this.device;
+    const user = pruneUndefined2({
+      userId: identity == null ? void 0 : identity.userId,
+      email: identity == null ? void 0 : identity.email,
+      phone: identity == null ? void 0 : identity.phone,
+      country: (_a = identity == null ? void 0 : identity.country) != null ? _a : device.country,
+      locale: (_b = identity == null ? void 0 : identity.locale) != null ? _b : device.locale,
+      idfa: device.idfa,
+      idfv: device.idfv,
+      gaid: device.gaid,
+      attStatus: (_c = this.attStatus) != null ? _c : device.attStatus
+    });
+    const properties = { ...(_d = input.properties) != null ? _d : {} };
+    if (input.sandbox) properties.environment = "sandbox";
+    return {
+      appId: this.config.appId,
+      eventId,
+      name: input.name,
+      platform: this.platform,
+      timestamp,
+      user,
+      revenue: input.revenue,
+      productId: input.productId,
+      properties: Object.keys(properties).length > 0 ? properties : void 0
+    };
+  }
+  /**
+   * Resolve client-safe config (from `/v1/config` or the injected override) and
+   * boot the matching native adapters. Every step is best-effort: a missing
+   * config, a failed fetch, or a native SDK that won't initialize just disables
+   * the native lane — the backend lane (CAPI/EAPI) keeps working.
+   */
+  async wireNativeAdapters() {
+    var _a, _b;
+    if (this.config.disableNativeDualSend) return;
+    let cfg = this.config.remoteConfig;
+    if (!cfg) {
+      const res = await this.transport.get("/v1/config");
+      if (!res.ok) {
+        this.logger.warn("trackstall: /v1/config fetch failed \u2014 native dual-send disabled", {
+          status: res.status
+        });
+        return;
+      }
+      cfg = res.body;
+    }
+    const pending = [];
+    if (cfg.meta) {
+      const injected = (_a = this.config.native) == null ? void 0 : _a.meta;
+      pending.push(
+        new MetaAdapter({
+          appId: cfg.meta.appId,
+          clientToken: cfg.meta.clientToken,
+          sdkLoader: injected ? () => injected : void 0
+        })
+      );
+    }
+    if (cfg.tiktok) {
+      const injected = (_b = this.config.native) == null ? void 0 : _b.tiktok;
+      pending.push(
+        new TikTokAdapter({
+          appId: cfg.tiktok.appId,
+          tiktokAppId: cfg.tiktok.ttAppId,
+          accessToken: cfg.tiktok.accessToken,
+          debugMode: cfg.sandbox,
+          sdkLoader: injected ? () => injected : void 0
+        })
+      );
+    }
+    for (const adapter of pending) {
+      try {
+        await adapter.initialize();
+        if (this.user) adapter.setUser(this.user);
+        this.nativeAdapters.push(adapter);
+        this.logger.info("trackstall: native adapter ready", { adapter: adapter.name });
+      } catch (err) {
+        this.logger.error("trackstall: native adapter init failed \u2014 skipping", err, {
+          adapter: adapter.name
+        });
+      }
+    }
+  }
+  async deliverNative(event) {
+    const results = await Promise.allSettled(
+      this.nativeAdapters.map((adapter) => adapter.deliver(event))
+    );
+    results.forEach((r, i) => {
+      const adapter = this.nativeAdapters[i];
+      if (r.status === "rejected") {
+        this.logger.warn("trackstall: native deliver threw", { adapter: adapter == null ? void 0 : adapter.name });
+      } else if (!r.value.ok) {
+        this.logger.debug("trackstall: native deliver failed", {
+          adapter: adapter == null ? void 0 : adapter.name,
+          code: r.value.code
+        });
+      }
+    });
+  }
+  /**
+   * Device signals shared by `recordClick` / `matchInstall`. Beyond
+   * locale/timezone/country, this carries the screen+OS fingerprint that the
+   * server uses to build `deviceFp` — without it probabilistic matching falls
+   * back to the weak IP-only tier and most installs go unattributed.
+   */
+  /**
+   * Merge best-effort auto-collected device signals into the resolved device
+   * context WITHOUT overriding anything the host already supplied. Runs once on
+   * `initialize()`. Disable with `config.disableAutoDeviceContext`.
+   */
+  resolveDeviceContext() {
+    var _a, _b;
+    if (this.config.disableAutoDeviceContext) return;
+    let collected;
+    try {
+      collected = collectDeviceContext();
+    } catch (err) {
+      this.logger.warn("trackstall: device auto-collection failed", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    for (const [key, value] of Object.entries(collected)) {
+      if (value === void 0) continue;
+      if (this.device[key] === void 0) {
+        this.device[key] = value;
+      }
+    }
+    this.logger.debug("trackstall: device context resolved", {
+      screen: this.device.screenW && this.device.screenH ? `${this.device.screenW}x${this.device.screenH}` : null,
+      osVersion: (_a = this.device.osVersion) != null ? _a : null,
+      deviceModel: (_b = this.device.deviceModel) != null ? _b : null
+    });
+  }
+  /**
+   * iOS IDFV — no ATT consent required, so it's auto-collected for every iOS
+   * install (host-supplied `config.device.idfv` always wins). Async because
+   * `expo-application` only exposes the promise API.
+   */
+  async resolveIosIdfv() {
+    if (this.platform !== "ios") return;
+    if (this.config.disableAutoDeviceContext) return;
+    if (this.device.idfv) return;
+    try {
+      const idfv = await collectIosIdForVendor();
+      if (idfv) this.device.idfv = idfv;
+    } catch (err) {
+      this.logger.warn("trackstall: idfv collection failed", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  deviceClickFields() {
+    const d = this.device;
+    return pruneUndefined2({
+      locale: d.locale,
+      timezone: d.timezone,
+      country: d.country,
+      screenW: d.screenW,
+      screenH: d.screenH,
+      pixelRatio: d.pixelRatio,
+      osVersion: d.osVersion,
+      deviceModel: d.deviceModel
+    });
+  }
+  flushSafe() {
+    return this.scheduleFlush().then(() => void 0).catch((err) => {
+      this.logger.error("trackstall: flush failed (recoverable)", err);
+    });
+  }
+  scheduleFlush() {
+    const next = this.flushChain.then(
+      () => this.flushOnce(),
+      () => this.flushOnce()
+    );
+    this.flushChain = next.catch(() => void 0);
+    return next;
+  }
+  /**
+   * Remember the status locally (stamps future attribution events) and report
+   * it to `POST /v1/att` — once per `(identity, status)` so retries/app opens
+   * don't spam the backend.
+   */
+  async applyAttStatus(status) {
+    var _a, _b, _c, _d, _e;
+    this.attStatus = status;
+    if (status === "authorized" && !this.device.idfa) {
+      const mod = loadAttModule((_a = this.config.native) == null ? void 0 : _a.att);
+      const idfa = mod ? readAdvertisingId(mod) : void 0;
+      if (idfa) this.device.idfa = idfa;
+    }
+    const distinctId = (_c = (_b = this.user) == null ? void 0 : _b.userId) != null ? _c : this.anonymousId;
+    if (!distinctId) return;
+    const fingerprint = `${distinctId}:${status}`;
+    try {
+      if (await this.storage.getItem(ATT_REPORTED_STORAGE_KEY) === fingerprint) return;
+    } catch {
+    }
+    const res = await this.transport.post("/v1/att", {
+      status,
+      userId: (_d = this.user) == null ? void 0 : _d.userId,
+      anonymousId: (_e = this.anonymousId) != null ? _e : void 0,
+      platform: this.platform
+    });
+    if (!res.ok) {
+      this.logger.warn("trackstall: ATT report failed \u2014 will retry on next change", {
+        status: res.status
+      });
+      return;
+    }
+    try {
+      await this.storage.setItem(ATT_REPORTED_STORAGE_KEY, fingerprint);
+    } catch {
+    }
+  }
+  /** Load (or mint + persist) the device-scoped anonymous id. */
+  async loadAnonymousId() {
+    try {
+      const existing = await this.storage.getItem(ANONYMOUS_ID_STORAGE_KEY);
+      if (existing) {
+        this.anonymousId = existing;
+        return;
+      }
+    } catch (err) {
+      this.logger.warn("trackstall: failed to read anonymousId \u2014 minting a fresh one", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    this.anonymousId = `anon-${(0, import_core2.randomEventId)()}`;
+    try {
+      await this.storage.setItem(ANONYMOUS_ID_STORAGE_KEY, this.anonymousId);
+    } catch {
+    }
+  }
+  async flushOnce() {
+    const result = { ...EMPTY_FLUSH };
+    for (let guard = 0; guard < 50; guard++) {
+      const ready = this.queue.pullReady(this.batchSize);
+      if (ready.length === 0) break;
+      result.attempted += ready.length;
+      await this.deliverBatch(this.queue, "/v1/events", ready, result);
+    }
+    for (let guard = 0; guard < 50; guard++) {
+      const ready = this.analyticsQueue.pullReady(this.batchSize);
+      if (ready.length === 0) break;
+      result.attempted += ready.length;
+      await this.deliverBatch(this.analyticsQueue, "/v1/track", ready, result);
+    }
+    return result;
+  }
+  async deliverBatch(queue, path, batch, result) {
+    const ids = batch.map((e) => e.id);
+    const res = await this.transport.post(path, { events: batch.map((e) => e.body) });
+    if (res.ok) {
+      const rejected = extractRejectedEventIds(res.body);
+      const terminalIds = batch.map((e) => e.id);
+      await queue.markDelivered(terminalIds);
+      result.delivered += batch.length - rejected.size;
+      result.dropped += countRejected(batch, rejected);
+      return;
+    }
+    if (!res.retriable) {
+      this.logger.error("trackstall: batch rejected (non-retriable) \u2014 dropping", void 0, {
+        status: res.status,
+        path,
+        count: batch.length
+      });
+      await queue.markDelivered(ids);
+      result.dropped += batch.length;
+      return;
+    }
+    const maxAttempts = Math.max(...batch.map((e) => e.attempts)) + 1;
+    if (!shouldRetry(maxAttempts, true, this.retry)) {
+      this.logger.error("trackstall: batch exhausted retries \u2014 dropping", void 0, {
+        status: res.status,
+        path,
+        count: batch.length
+      });
+      await queue.markDelivered(ids);
+      result.dropped += batch.length;
+      return;
+    }
+    const delay = computeRetryDelayMs(maxAttempts, this.retry);
+    await queue.markFailed(ids, this.now() + delay);
+    result.retryScheduled += batch.length;
+    this.logger.warn("trackstall: batch delivery failed \u2014 scheduled retry", {
+      status: res.status,
+      path,
+      count: batch.length,
+      delayMs: delay
+    });
+  }
+};
+function extractRejectedEventIds(body) {
+  const out = /* @__PURE__ */ new Set();
+  const results = body == null ? void 0 : body.results;
+  if (Array.isArray(results)) {
+    for (const r of results) {
+      if (r.status === "rejected" && r.eventId) out.add(r.eventId);
+    }
+  }
+  return out;
+}
+function countRejected(batch, rejectedEventIds) {
+  let n = 0;
+  for (const e of batch) if (rejectedEventIds.has(e.eventId)) n += 1;
+  return n;
+}
+function pruneUndefined2(obj) {
+  for (const k of Object.keys(obj)) {
+    if (obj[k] === void 0) delete obj[k];
+  }
+  return obj;
+}
+var defaultLogger = {
+  debug: (m, c) => console.debug(`[trackstall] ${m}`, c != null ? c : ""),
+  info: (m, c) => console.log(`[trackstall] ${m}`, c != null ? c : ""),
+  warn: (m, c) => console.warn(`[trackstall] ${m}`, c != null ? c : ""),
+  error: (m, e, c) => console.error(`[trackstall] ${m}`, e != null ? e : "", c != null ? c : "")
+};
+
+// src/index.ts
+var import_core3 = __toESM(require_dist());