@snowplow/react-native-tracker 2.1.2 → 4.0.2-dev.0

package/dist/index.cjs.js

@@ -0,0 +1,2656 @@
+/*!
+ * React Native tracker for Snowplow v4.0.2-dev.0 (https://docs.snowplow.io/docs/collecting-data/collecting-from-own-applications/javascript-trackers/)
+ * Copyright 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+ * Licensed under BSD-3-Clause
+ */
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.snowplowBrowserTracking = {}));
+})(this, (function (exports) { 'use strict';
+
+  /******************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+
+  var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+  };
+
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+
+  function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+  }
+
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  }
+
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+
+  /**
+   * Convert array of 16 byte values to UUID string format of the form:
+   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+   */
+  var byteToHex = [];
+  for (var i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+  }
+  function unsafeStringify(arr, offset = 0) {
+    // Note: Be careful editing this code!  It's been tuned for performance
+    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+    //
+    // Note to future-self: No, you can't remove the `toLowerCase()` call.
+    // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351
+    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();
+  }
+
+  // Unique ID creation requires a high quality random # generator. In the browser we therefore
+  // require the crypto API and do not support built-in fallback to lower quality random number
+  // generators (like Math.random()).
+
+  var getRandomValues;
+  var rnds8 = new Uint8Array(16);
+  function rng() {
+    // lazy load so that environments that need to polyfill have a chance to do so
+    if (!getRandomValues) {
+      // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+      getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+      if (!getRandomValues) {
+        throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+      }
+    }
+    return getRandomValues(rnds8);
+  }
+
+  var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+  var native = {
+    randomUUID
+  };
+
+  function v4(options, buf, offset) {
+    if (native.randomUUID && !buf && !options) {
+      return native.randomUUID();
+    }
+    options = options || {};
+    var rnds = options.random || (options.rng || rng)();
+
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = rnds[6] & 0x0f | 0x40;
+    rnds[8] = rnds[8] & 0x3f | 0x80;
+
+    // Copy bytes to buffer, if provided
+    if (buf) {
+      offset = offset || 0;
+      for (var i = 0; i < 16; ++i) {
+        buf[offset + i] = rnds[i];
+      }
+      return buf;
+    }
+    return unsafeStringify(rnds);
+  }
+
+  /*!
+   * Core functionality for Snowplow JavaScript trackers v4.0.2-dev.0 (http://bit.ly/sp-js)
+   * Copyright 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * Licensed under BSD-3-Clause
+   */
+
+  var version$1 = "4.0.2-dev.0";
+
+  /*
+   * Copyright (c) 2013 Kevin van Zonneveld (http://kvz.io)
+   * and Contributors (http://phpjs.org/authors)
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy of
+   * this software and associated documentation files (the "Software"), to deal in
+   * the Software without restriction, including without limitation the rights to
+   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+   * of the Software, and to permit persons to whom the Software is furnished to do
+   * so, subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   * SOFTWARE.
+   */
+  /**
+   * Decodes a url safe Base 64 encoded string
+   * @remarks See: {@link http://tools.ietf.org/html/rfc4648#page-7}
+   * @param data - String to decode
+   * @returns The decoded string
+   */
+  function base64urldecode(data) {
+      if (!data) {
+          return data;
+      }
+      var padding = 4 - (data.length % 4);
+      switch (padding) {
+          case 2:
+              data += '==';
+              break;
+          case 3:
+              data += '=';
+              break;
+      }
+      var b64Data = data.replace(/-/g, '+').replace(/_/g, '/');
+      return base64decode(b64Data);
+  }
+  /**
+   * Encodes a string into a url safe Base 64 encoded string
+   * @remarks See: {@link http://tools.ietf.org/html/rfc4648#page-7}
+   * @param data - String to encode
+   * @returns The url safe Base 64 string
+   */
+  function base64urlencode(data) {
+      if (!data) {
+          return data;
+      }
+      var enc = base64encode(data);
+      return enc.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+  }
+  var b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  /**
+   * Encode string as base64.
+   * Any type can be passed, but will be stringified
+   *
+   * @param data - string to encode
+   * @returns base64-encoded string
+   */
+  function base64encode(data) {
+      // discuss at: http://phpjs.org/functions/base64_encode/
+      // original by: Tyler Akins (http://rumkin.com)
+      // improved by: Bayron Guevara
+      // improved by: Thunder.m
+      // improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+      // improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+      // improved by: Rafał Kukawski (http://kukawski.pl)
+      // bugfixed by: Pellentesque Malesuada
+      // example 1: base64_encode('Kevin van Zonneveld');
+      // returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
+      // example 2: base64_encode('a');
+      // returns 2: 'YQ=='
+      // example 3: base64_encode('✓ à la mode');
+      // returns 3: '4pyTIMOgIGxhIG1vZGU='
+      var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0;
+      var tmp_arr = [];
+      if (!data) {
+          return data;
+      }
+      data = unescape(encodeURIComponent(data));
+      do {
+          // pack three octets into four hexets
+          o1 = data.charCodeAt(i++);
+          o2 = data.charCodeAt(i++);
+          o3 = data.charCodeAt(i++);
+          bits = (o1 << 16) | (o2 << 8) | o3;
+          h1 = (bits >> 18) & 0x3f;
+          h2 = (bits >> 12) & 0x3f;
+          h3 = (bits >> 6) & 0x3f;
+          h4 = bits & 0x3f;
+          // use hexets to index into b64, and append result to encoded string
+          tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
+      } while (i < data.length);
+      var enc = tmp_arr.join('');
+      var r = data.length % 3;
+      return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3);
+  }
+  /**
+   * Decode base64 to string
+   *
+   * @param data - base64 to string
+   * @returns decoded string
+   */
+  function base64decode(encodedData) {
+      //  discuss at: http://locutus.io/php/base64_decode/
+      // original by: Tyler Akins (http://rumkin.com)
+      // improved by: Thunder.m
+      // improved by: Kevin van Zonneveld (http://kvz.io)
+      // improved by: Kevin van Zonneveld (http://kvz.io)
+      //    input by: Aman Gupta
+      //    input by: Brett Zamir (http://brett-zamir.me)
+      // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
+      // bugfixed by: Pellentesque Malesuada
+      // bugfixed by: Kevin van Zonneveld (http://kvz.io)
+      // improved by: Indigo744
+      //   example 1: base64_decode('S2V2aW4gdmFuIFpvbm5ldmVsZA==')
+      //   returns 1: 'Kevin van Zonneveld'
+      //   example 2: base64_decode('YQ==')
+      //   returns 2: 'a'
+      //   example 3: base64_decode('4pyTIMOgIGxhIG1vZGU=')
+      //   returns 3: '✓ à la mode'
+      // decodeUTF8string()
+      // Internal function to decode properly UTF8 string
+      // Adapted from Solution #1 at https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
+      var decodeUTF8string = function (str) {
+          // Going backwards: from bytestream, to percent-encoding, to original string.
+          return decodeURIComponent(str
+              .split('')
+              .map(function (c) {
+              return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+          })
+              .join(''));
+      };
+      var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, dec = '';
+      var tmpArr = [];
+      if (!encodedData) {
+          return encodedData;
+      }
+      encodedData += '';
+      do {
+          // unpack four hexets into three octets using index points in b64
+          h1 = b64.indexOf(encodedData.charAt(i++));
+          h2 = b64.indexOf(encodedData.charAt(i++));
+          h3 = b64.indexOf(encodedData.charAt(i++));
+          h4 = b64.indexOf(encodedData.charAt(i++));
+          bits = (h1 << 18) | (h2 << 12) | (h3 << 6) | h4;
+          o1 = (bits >> 16) & 0xff;
+          o2 = (bits >> 8) & 0xff;
+          o3 = bits & 0xff;
+          if (h3 === 64) {
+              tmpArr[ac++] = String.fromCharCode(o1);
+          }
+          else if (h4 === 64) {
+              tmpArr[ac++] = String.fromCharCode(o1, o2);
+          }
+          else {
+              tmpArr[ac++] = String.fromCharCode(o1, o2, o3);
+          }
+      } while (i < encodedData.length);
+      dec = tmpArr.join('');
+      return decodeUTF8string(dec.replace(/\0+$/, ''));
+  }
+
+  /*
+   * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the documentation
+   *    and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of the copyright holder nor the names of its
+   *    contributors may be used to endorse or promote products derived from
+   *    this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  function payloadBuilder() {
+      var dict = {}, allJson = [], jsonForProcessing = [], contextEntitiesForProcessing = [];
+      var processor;
+      var add = function (key, value) {
+          if (value != null && value !== '') {
+              // null also checks undefined
+              dict[key] = value;
+          }
+      };
+      var addDict = function (dict) {
+          for (var key in dict) {
+              if (Object.prototype.hasOwnProperty.call(dict, key)) {
+                  add(key, dict[key]);
+              }
+          }
+      };
+      var addJson = function (keyIfEncoded, keyIfNotEncoded, json) {
+          if (json && isNonEmptyJson(json)) {
+              var jsonWithKeys = { keyIfEncoded: keyIfEncoded, keyIfNotEncoded: keyIfNotEncoded, json: json };
+              jsonForProcessing.push(jsonWithKeys);
+              allJson.push(jsonWithKeys);
+          }
+      };
+      var addContextEntity = function (entity) {
+          contextEntitiesForProcessing.push(entity);
+      };
+      return {
+          add: add,
+          addDict: addDict,
+          addJson: addJson,
+          addContextEntity: addContextEntity,
+          getPayload: function () { return dict; },
+          getJson: function () { return allJson; },
+          withJsonProcessor: function (jsonProcessor) {
+              processor = jsonProcessor;
+          },
+          build: function () {
+              processor === null || processor === void 0 ? void 0 : processor(this, jsonForProcessing, contextEntitiesForProcessing);
+              return dict;
+          },
+      };
+  }
+  /**
+   * A helper to build a Snowplow request from a set of name-value pairs, provided using the add methods.
+   * Will base64 encode JSON, if desired, on build
+   *
+   * @returns The request builder, with add and build methods
+   */
+  function payloadJsonProcessor(encodeBase64) {
+      return function (payloadBuilder, jsonForProcessing, contextEntitiesForProcessing) {
+          var add = function (json, keyIfEncoded, keyIfNotEncoded) {
+              var str = JSON.stringify(json);
+              if (encodeBase64) {
+                  payloadBuilder.add(keyIfEncoded, base64urlencode(str));
+              }
+              else {
+                  payloadBuilder.add(keyIfNotEncoded, str);
+              }
+          };
+          var getContextFromPayload = function () {
+              var payload = payloadBuilder.getPayload();
+              if (encodeBase64 ? payload.cx : payload.co) {
+                  return JSON.parse(encodeBase64 ? base64urldecode(payload.cx) : payload.co);
+              }
+              return undefined;
+          };
+          var combineContexts = function (originalContext, newContext) {
+              var context = originalContext || getContextFromPayload();
+              if (context) {
+                  context.data = context.data.concat(newContext.data);
+              }
+              else {
+                  context = newContext;
+              }
+              return context;
+          };
+          var context = undefined;
+          for (var _i = 0, jsonForProcessing_1 = jsonForProcessing; _i < jsonForProcessing_1.length; _i++) {
+              var json = jsonForProcessing_1[_i];
+              if (json.keyIfEncoded === 'cx') {
+                  context = combineContexts(context, json.json);
+              }
+              else {
+                  add(json.json, json.keyIfEncoded, json.keyIfNotEncoded);
+              }
+          }
+          jsonForProcessing.length = 0;
+          if (contextEntitiesForProcessing.length) {
+              var newContext = {
+                  schema: 'iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-0',
+                  data: __spreadArray([], contextEntitiesForProcessing, true),
+              };
+              context = combineContexts(context, newContext);
+              contextEntitiesForProcessing.length = 0;
+          }
+          if (context) {
+              add(context, 'cx', 'co');
+          }
+      };
+  }
+  /**
+   * Is property a non-empty JSON?
+   * @param property - Checks if object is non-empty json
+   */
+  function isNonEmptyJson(property) {
+      if (!isJson(property)) {
+          return false;
+      }
+      for (var key in property) {
+          if (Object.prototype.hasOwnProperty.call(property, key)) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /**
+   * Is property a JSON?
+   * @param property - Checks if object is json
+   */
+  function isJson(property) {
+      return (typeof property !== 'undefined' &&
+          property !== null &&
+          (property.constructor === {}.constructor || property.constructor === [].constructor));
+  }
+
+  /*
+   * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the documentation
+   *    and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of the copyright holder nor the names of its
+   *    contributors may be used to endorse or promote products derived from
+   *    this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  var label = 'Snowplow: ';
+  exports.LOG_LEVEL = void 0;
+  (function (LOG_LEVEL) {
+      LOG_LEVEL[LOG_LEVEL["none"] = 0] = "none";
+      LOG_LEVEL[LOG_LEVEL["error"] = 1] = "error";
+      LOG_LEVEL[LOG_LEVEL["warn"] = 2] = "warn";
+      LOG_LEVEL[LOG_LEVEL["debug"] = 3] = "debug";
+      LOG_LEVEL[LOG_LEVEL["info"] = 4] = "info";
+  })(exports.LOG_LEVEL || (exports.LOG_LEVEL = {}));
+  var LOG = logger();
+  function logger(logLevel) {
+      if (logLevel === void 0) { logLevel = exports.LOG_LEVEL.warn; }
+      function setLogLevel(level) {
+          if (exports.LOG_LEVEL[level]) {
+              logLevel = level;
+          }
+          else {
+              logLevel = exports.LOG_LEVEL.warn;
+          }
+      }
+      /**
+       * Log errors, with or without error object
+       */
+      function error(message, error) {
+          var extraParams = [];
+          for (var _i = 2; _i < arguments.length; _i++) {
+              extraParams[_i - 2] = arguments[_i];
+          }
+          if (logLevel >= exports.LOG_LEVEL.error && typeof console !== 'undefined') {
+              var logMsg = label + message + '\n';
+              if (error) {
+                  console.error.apply(console, __spreadArray([logMsg + '\n', error], extraParams, false));
+              }
+              else {
+                  console.error.apply(console, __spreadArray([logMsg], extraParams, false));
+              }
+          }
+      }
+      /**
+       * Log warnings, with or without error object
+       */
+      function warn(message, error) {
+          var extraParams = [];
+          for (var _i = 2; _i < arguments.length; _i++) {
+              extraParams[_i - 2] = arguments[_i];
+          }
+          if (logLevel >= exports.LOG_LEVEL.warn && typeof console !== 'undefined') {
+              var logMsg = label + message;
+              if (error) {
+                  console.warn.apply(console, __spreadArray([logMsg + '\n', error], extraParams, false));
+              }
+              else {
+                  console.warn.apply(console, __spreadArray([logMsg], extraParams, false));
+              }
+          }
+      }
+      /**
+       * Log debug messages
+       */
+      function debug(message) {
+          var extraParams = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+              extraParams[_i - 1] = arguments[_i];
+          }
+          if (logLevel >= exports.LOG_LEVEL.debug && typeof console !== 'undefined') {
+              console.debug.apply(console, __spreadArray([label + message], extraParams, false));
+          }
+      }
+      /**
+       * Log info messages
+       */
+      function info(message) {
+          var extraParams = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+              extraParams[_i - 1] = arguments[_i];
+          }
+          if (logLevel >= exports.LOG_LEVEL.info && typeof console !== 'undefined') {
+              console.info.apply(console, __spreadArray([label + message], extraParams, false));
+          }
+      }
+      return { setLogLevel: setLogLevel, warn: warn, error: error, debug: debug, info: info };
+  }
+
+  /*
+   * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the documentation
+   *    and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of the copyright holder nor the names of its
+   *    contributors may be used to endorse or promote products derived from
+   *    this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  /**
+   * Contains helper functions to aid in the addition and removal of Global Contexts
+   */
+  function globalContexts() {
+      var globalPrimitives = [];
+      var conditionalProviders = [];
+      var namedPrimitives = {};
+      var namedConditionalProviders = {};
+      /**
+       * Returns all applicable global contexts for a specified event
+       * @param event - The event to check for applicable global contexts for
+       * @returns An array of contexts
+       */
+      var assembleAllContexts = function (event) {
+          var eventSchema = getUsefulSchema(event);
+          var eventType = getEventType(event);
+          var contexts = [];
+          var generatedPrimitives = generatePrimitives(globalPrimitives.concat(Object.values(namedPrimitives)), event, eventType, eventSchema);
+          contexts.push.apply(contexts, generatedPrimitives);
+          var generatedConditionals = generateConditionals(conditionalProviders.concat(Object.values(namedConditionalProviders)), event, eventType, eventSchema);
+          contexts.push.apply(contexts, generatedConditionals);
+          return contexts;
+      };
+      return {
+          getGlobalPrimitives: function () {
+              return globalPrimitives.concat(Object.values(namedPrimitives));
+          },
+          getConditionalProviders: function () {
+              return conditionalProviders.concat(Object.values(namedConditionalProviders));
+          },
+          addGlobalContexts: function (contexts) {
+              if (Array.isArray(contexts)) {
+                  var acceptedConditionalContexts = [];
+                  var acceptedContextPrimitives = [];
+                  for (var _i = 0, contexts_1 = contexts; _i < contexts_1.length; _i++) {
+                      var context = contexts_1[_i];
+                      if (isConditionalContextProvider(context)) {
+                          acceptedConditionalContexts.push(context);
+                      }
+                      else if (isContextPrimitive(context)) {
+                          acceptedContextPrimitives.push(context);
+                      }
+                  }
+                  globalPrimitives = globalPrimitives.concat(acceptedContextPrimitives);
+                  conditionalProviders = conditionalProviders.concat(acceptedConditionalContexts);
+              }
+              else {
+                  for (var _a = 0, _b = Object.entries(contexts); _a < _b.length; _a++) {
+                      var _c = _b[_a], name_1 = _c[0], context = _c[1];
+                      if (isConditionalContextProvider(context)) {
+                          namedConditionalProviders[name_1] = context;
+                      }
+                      else if (isContextPrimitive(context)) {
+                          namedPrimitives[name_1] = context;
+                      }
+                  }
+              }
+          },
+          clearGlobalContexts: function () {
+              conditionalProviders = [];
+              globalPrimitives = [];
+              namedConditionalProviders = {};
+              namedPrimitives = {};
+          },
+          removeGlobalContexts: function (contexts) {
+              var _loop_1 = function (context) {
+                  if (typeof context === 'string') {
+                      delete namedConditionalProviders[context];
+                      delete namedPrimitives[context];
+                  }
+                  else if (isConditionalContextProvider(context)) {
+                      conditionalProviders = conditionalProviders.filter(function (item) { return !compareProvider(context, item); });
+                  }
+                  else if (isContextPrimitive(context)) {
+                      globalPrimitives = globalPrimitives.filter(function (item) { return !compareProvider(context, item); });
+                  }
+              };
+              for (var _i = 0, contexts_2 = contexts; _i < contexts_2.length; _i++) {
+                  var context = contexts_2[_i];
+                  _loop_1(context);
+              }
+          },
+          getApplicableContexts: function (event) {
+              return assembleAllContexts(event);
+          },
+      };
+  }
+  function pluginContexts(plugins) {
+      /**
+       * Add common contexts to every event
+       *
+       * @param array - additionalContexts List of user-defined contexts
+       * @returns userContexts combined with commonContexts
+       */
+      return {
+          addPluginContexts: function (additionalContexts) {
+              var combinedContexts = additionalContexts
+                  ? __spreadArray([], additionalContexts, true) : [];
+              plugins.forEach(function (plugin) {
+                  try {
+                      if (plugin.contexts) {
+                          combinedContexts.push.apply(combinedContexts, plugin.contexts());
+                      }
+                  }
+                  catch (ex) {
+                      LOG.error('Error adding plugin contexts', ex);
+                  }
+              });
+              return combinedContexts;
+          },
+      };
+  }
+  /**
+   * Slices a schema into its composite parts. Useful for ruleset filtering.
+   * @param input - A schema string
+   * @returns The vendor, schema name, major, minor and patch information of a schema string
+   */
+  function getSchemaParts(input) {
+      var re = new RegExp('^iglu:([a-zA-Z0-9-_.]+)/([a-zA-Z0-9-_]+)/jsonschema/([1-9][0-9]*)-(0|[1-9][0-9]*)-(0|[1-9][0-9]*)$');
+      var matches = re.exec(input);
+      if (matches !== null)
+          return matches.slice(1, 6);
+      return undefined;
+  }
+  /**
+   * Validates the vendor section of a schema string contains allowed wildcard values
+   * @param parts - Array of parts from a schema string
+   * @returns Whether the vendor validation parts are a valid combination
+   */
+  function validateVendorParts(parts) {
+      if (parts[0] === '*' || parts[1] === '*') {
+          return false; // no wildcard in first or second part
+      }
+      if (parts.slice(2).length > 0) {
+          var asterisk = false;
+          for (var _i = 0, _a = parts.slice(2); _i < _a.length; _i++) {
+              var part = _a[_i];
+              if (part === '*')
+                  // mark when we've found a wildcard
+                  asterisk = true;
+              else if (asterisk)
+                  // invalid if alpha parts come after wildcard
+                  return false;
+          }
+          return true;
+      }
+      else if (parts.length == 2)
+          return true;
+      return false;
+  }
+  /**
+   * Validates the vendor part of a schema string is valid for a rule set
+   * @param input - Vendor part of a schema string
+   * @returns Whether the vendor validation string is valid
+   */
+  function validateVendor(input) {
+      var parts = input.split('.');
+      if (parts && parts.length > 1)
+          return validateVendorParts(parts);
+      return false;
+  }
+  /**
+   * Checks for validity of input and returns all the sections of a schema string that are used to match rules in a ruleset
+   * @param input - A Schema string
+   * @returns The sections of a schema string that are used to match rules in a ruleset
+   */
+  function getRuleParts(input) {
+      var re = new RegExp('^iglu:((?:(?:[a-zA-Z0-9-_]+|\\*).)+(?:[a-zA-Z0-9-_]+|\\*))/([a-zA-Z0-9-_.]+|\\*)/jsonschema/([1-9][0-9]*|\\*)-(0|[1-9][0-9]*|\\*)-(0|[1-9][0-9]*|\\*)$');
+      var matches = re.exec(input);
+      if (matches !== null && validateVendor(matches[1]))
+          return matches.slice(1, 6);
+      return undefined;
+  }
+  /**
+   * Ensures the rules specified in a schema string of a ruleset are valid
+   * @param input - A Schema string
+   * @returns if there rule is valid
+   */
+  function isValidRule(input) {
+      var ruleParts = getRuleParts(input);
+      if (ruleParts) {
+          var vendor = ruleParts[0];
+          return ruleParts.length === 5 && validateVendor(vendor);
+      }
+      return false;
+  }
+  /**
+   * Check if a variable is an Array containing only strings
+   * @param input - The variable to validate
+   * @returns True if the input is an array containing only strings
+   */
+  function isStringArray(input) {
+      return (Array.isArray(input) &&
+          input.every(function (x) {
+              return typeof x === 'string';
+          }));
+  }
+  /**
+   * Validates whether a rule set is an array of valid ruleset strings
+   * @param input - The Array of rule set arguments
+   * @returns True is the input is an array of valid rules
+   */
+  function isValidRuleSetArg(input) {
+      if (isStringArray(input))
+          return input.every(function (x) {
+              return isValidRule(x);
+          });
+      else if (typeof input === 'string')
+          return isValidRule(input);
+      return false;
+  }
+  /**
+   * Check if a variable is a valid, non-empty Self Describing JSON
+   * @param input - The variable to validate
+   * @returns True if a valid Self Describing JSON
+   */
+  function isSelfDescribingJson(input) {
+      var sdj = input;
+      if (isNonEmptyJson(sdj))
+          if ('schema' in sdj && 'data' in sdj)
+              return typeof sdj.schema === 'string' && typeof sdj.data === 'object';
+      return false;
+  }
+  /**
+   * Validates if the input object contains the expected properties of a ruleset
+   * @param input - The object containing a rule set
+   * @returns True if a valid rule set
+   */
+  function isRuleSet(input) {
+      var ruleSet = input;
+      var ruleCount = 0;
+      if (input != null && typeof input === 'object' && !Array.isArray(input)) {
+          if (Object.prototype.hasOwnProperty.call(ruleSet, 'accept')) {
+              if (isValidRuleSetArg(ruleSet['accept'])) {
+                  ruleCount += 1;
+              }
+              else {
+                  return false;
+              }
+          }
+          if (Object.prototype.hasOwnProperty.call(ruleSet, 'reject')) {
+              if (isValidRuleSetArg(ruleSet['reject'])) {
+                  ruleCount += 1;
+              }
+              else {
+                  return false;
+              }
+          }
+          // if either 'reject' or 'accept' or both exists,
+          // we have a valid ruleset
+          return ruleCount > 0 && ruleCount <= 2;
+      }
+      return false;
+  }
+  /**
+   * Validates if the function can be a valid context generator function
+   * @param input - The function to be validated
+   */
+  function isContextCallbackFunction(input) {
+      return typeof input === 'function' && input.length <= 1;
+  }
+  /**
+   * Validates if the function can be a valid context primitive function or self describing json
+   * @param input - The function or orbject to be validated
+   * @returns True if either a Context Generator or Self Describing JSON
+   */
+  function isContextPrimitive(input) {
+      return isContextCallbackFunction(input) || isSelfDescribingJson(input);
+  }
+  /**
+   * Validates if an array is a valid shape to be a Filter Provider
+   * @param input - The Array of Context filter callbacks
+   */
+  function isFilterProvider(input) {
+      if (Array.isArray(input)) {
+          if (input.length === 2) {
+              if (Array.isArray(input[1])) {
+                  return isContextCallbackFunction(input[0]) && input[1].every(isContextPrimitive);
+              }
+              return isContextCallbackFunction(input[0]) && isContextPrimitive(input[1]);
+          }
+      }
+      return false;
+  }
+  /**
+   * Validates if an array is a valid shape to be an array of rule sets
+   * @param input - The Array of Rule Sets
+   */
+  function isRuleSetProvider(input) {
+      if (Array.isArray(input) && input.length === 2) {
+          if (!isRuleSet(input[0]))
+              return false;
+          if (Array.isArray(input[1]))
+              return input[1].every(isContextPrimitive);
+          return isContextPrimitive(input[1]);
+      }
+      return false;
+  }
+  /**
+   * Checks if an input array is either a filter provider or a rule set provider
+   * @param input - An array of filter providers or rule set providers
+   * @returns Whether the array is a valid {@link ConditionalContextProvider}
+   */
+  function isConditionalContextProvider(input) {
+      return isFilterProvider(input) || isRuleSetProvider(input);
+  }
+  /**
+   * Checks if a given schema matches any rules within the provided rule set
+   * @param ruleSet - The rule set containing rules to match schema against
+   * @param schema - The schema to be matched against the rule set
+   */
+  function matchSchemaAgainstRuleSet(ruleSet, schema) {
+      var rejectCount = 0;
+      var acceptCount = 0;
+      var acceptRules = ruleSet['accept'];
+      if (Array.isArray(acceptRules)) {
+          if (ruleSet.accept.some(function (rule) { return matchSchemaAgainstRule(rule, schema); })) {
+              acceptCount++;
+          }
+      }
+      else if (typeof acceptRules === 'string') {
+          if (matchSchemaAgainstRule(acceptRules, schema)) {
+              acceptCount++;
+          }
+      }
+      var rejectRules = ruleSet['reject'];
+      if (Array.isArray(rejectRules)) {
+          if (ruleSet.reject.some(function (rule) { return matchSchemaAgainstRule(rule, schema); })) {
+              rejectCount++;
+          }
+      }
+      else if (typeof rejectRules === 'string') {
+          if (matchSchemaAgainstRule(rejectRules, schema)) {
+              rejectCount++;
+          }
+      }
+      if (acceptCount > 0 && rejectCount === 0) {
+          return true;
+      }
+      else if (acceptCount === 0 && rejectCount > 0) {
+          return false;
+      }
+      return false;
+  }
+  /**
+   * Checks if a given schema matches a specific rule from a rule set
+   * @param rule - The rule to match schema against
+   * @param schema - The schema to be matched against the rule
+   */
+  function matchSchemaAgainstRule(rule, schema) {
+      if (!isValidRule(rule))
+          return false;
+      var ruleParts = getRuleParts(rule);
+      var schemaParts = getSchemaParts(schema);
+      if (ruleParts && schemaParts) {
+          if (!matchVendor(ruleParts[0], schemaParts[0]))
+              return false;
+          for (var i = 1; i < 5; i++) {
+              if (!matchPart(ruleParts[i], schemaParts[i]))
+                  return false;
+          }
+          return true; // if it hasn't failed, it passes
+      }
+      return false;
+  }
+  function matchVendor(rule, vendor) {
+      // rule and vendor must have same number of elements
+      var vendorParts = vendor.split('.');
+      var ruleParts = rule.split('.');
+      if (vendorParts && ruleParts) {
+          if (vendorParts.length !== ruleParts.length)
+              return false;
+          for (var i = 0; i < ruleParts.length; i++) {
+              if (!matchPart(vendorParts[i], ruleParts[i]))
+                  return false;
+          }
+          return true;
+      }
+      return false;
+  }
+  function matchPart(rule, schema) {
+      // parts should be the string nested between slashes in the URI: /example/
+      return (rule && schema && rule === '*') || rule === schema;
+  }
+  // Returns the "useful" schema, i.e. what would someone want to use to identify events.
+  // For some events this is the 'e' property but for unstructured events, this is the
+  // 'schema' from the 'ue_px' field.
+  function getUsefulSchema(sb) {
+      var eventJson = sb.getJson();
+      for (var _i = 0, eventJson_1 = eventJson; _i < eventJson_1.length; _i++) {
+          var json = eventJson_1[_i];
+          if (json.keyIfEncoded === 'ue_px' && typeof json.json['data'] === 'object') {
+              var schema = json.json['data']['schema'];
+              if (typeof schema == 'string') {
+                  return schema;
+              }
+          }
+      }
+      return '';
+  }
+  function getEventType(payloadBuilder) {
+      var eventType = payloadBuilder.getPayload()['e'];
+      return typeof eventType === 'string' ? eventType : '';
+  }
+  function buildGenerator(generator, event, eventType, eventSchema) {
+      var contextGeneratorResult = undefined;
+      try {
+          // try to evaluate context generator
+          var args = {
+              event: event.getPayload(),
+              eventType: eventType,
+              eventSchema: eventSchema,
+          };
+          contextGeneratorResult = generator(args);
+          // determine if the produced result is a valid SDJ
+          if (Array.isArray(contextGeneratorResult) && contextGeneratorResult.every(isSelfDescribingJson)) {
+              return contextGeneratorResult;
+          }
+          else if (isSelfDescribingJson(contextGeneratorResult)) {
+              return contextGeneratorResult;
+          }
+          else {
+              return undefined;
+          }
+      }
+      catch (error) {
+          contextGeneratorResult = undefined;
+      }
+      return contextGeneratorResult;
+  }
+  function normalizeToArray(input) {
+      if (Array.isArray(input)) {
+          return input;
+      }
+      return Array.of(input);
+  }
+  function generatePrimitives(contextPrimitives, event, eventType, eventSchema) {
+      var _a;
+      var normalizedInputs = normalizeToArray(contextPrimitives);
+      var partialEvaluate = function (primitive) {
+          var result = evaluatePrimitive(primitive, event, eventType, eventSchema);
+          if (result && result.length !== 0) {
+              return result;
+          }
+          return undefined;
+      };
+      var generatedContexts = normalizedInputs.map(partialEvaluate);
+      return (_a = []).concat.apply(_a, generatedContexts.filter(function (c) { return c != null && c.filter(Boolean); }));
+  }
+  function evaluatePrimitive(contextPrimitive, event, eventType, eventSchema) {
+      if (isSelfDescribingJson(contextPrimitive)) {
+          return [contextPrimitive];
+      }
+      else if (isContextCallbackFunction(contextPrimitive)) {
+          var generatorOutput = buildGenerator(contextPrimitive, event, eventType, eventSchema);
+          if (isSelfDescribingJson(generatorOutput)) {
+              return [generatorOutput];
+          }
+          else if (Array.isArray(generatorOutput)) {
+              return generatorOutput;
+          }
+      }
+      return undefined;
+  }
+  function evaluateProvider(provider, event, eventType, eventSchema) {
+      if (isFilterProvider(provider)) {
+          var filter = provider[0];
+          var filterResult = false;
+          try {
+              var args = {
+                  event: event.getPayload(),
+                  eventType: eventType,
+                  eventSchema: eventSchema,
+              };
+              filterResult = filter(args);
+          }
+          catch (error) {
+              filterResult = false;
+          }
+          if (filterResult === true) {
+              return generatePrimitives(provider[1], event, eventType, eventSchema);
+          }
+      }
+      else if (isRuleSetProvider(provider)) {
+          if (matchSchemaAgainstRuleSet(provider[0], eventSchema)) {
+              return generatePrimitives(provider[1], event, eventType, eventSchema);
+          }
+      }
+      return [];
+  }
+  function compareProviderPart(a, b) {
+      if (typeof a === 'function')
+          return a === b;
+      return JSON.stringify(a) === JSON.stringify(b);
+  }
+  function compareProvider(a, b) {
+      if (isConditionalContextProvider(a)) {
+          if (!isConditionalContextProvider(b))
+              return false;
+          var ruleA = a[0], primitivesA = a[1];
+          var ruleB = b[0], primitivesB_1 = b[1];
+          if (!compareProviderPart(ruleA, ruleB))
+              return false;
+          if (Array.isArray(primitivesA)) {
+              if (!Array.isArray(primitivesB_1))
+                  return false;
+              if (primitivesA.length !== primitivesB_1.length)
+                  return false;
+              return primitivesA.reduce(function (matches, a, i) { return matches && compareProviderPart(a, primitivesB_1[i]); }, true);
+          }
+          else {
+              if (Array.isArray(primitivesB_1))
+                  return false;
+              return compareProviderPart(primitivesA, primitivesB_1);
+          }
+      }
+      else if (isContextPrimitive(a)) {
+          if (!isContextPrimitive(b))
+              return false;
+          return compareProviderPart(a, b);
+      }
+      return false;
+  }
+  function generateConditionals(providers, event, eventType, eventSchema) {
+      var _a;
+      var normalizedInput = normalizeToArray(providers);
+      var partialEvaluate = function (provider) {
+          var result = evaluateProvider(provider, event, eventType, eventSchema);
+          if (result && result.length !== 0) {
+              return result;
+          }
+          return undefined;
+      };
+      var generatedContexts = normalizedInput.map(partialEvaluate);
+      return (_a = []).concat.apply(_a, generatedContexts.filter(function (c) { return c != null && c.filter(Boolean); }));
+  }
+
+  /**
+   * Create a new EventStorePayload
+   */
+  function newEventStorePayload(_a) {
+      var payload = _a.payload, _b = _a.svrAnon, svrAnon = _b === void 0 ? false : _b;
+      return {
+          payload: payload,
+          svrAnon: svrAnon,
+      };
+  }
+
+  /*
+   * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the documentation
+   *    and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of the copyright holder nor the names of its
+   *    contributors may be used to endorse or promote products derived from
+   *    this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  /**
+   * Transform optional/old-behavior number timestamp into`Timestamp` ADT
+   *
+   * @param timestamp - optional number or timestamp object
+   * @returns correct timestamp object
+   */
+  function getTimestamp(timestamp) {
+      if (timestamp == null) {
+          return { type: 'dtm', value: new Date().getTime() };
+      }
+      else if (typeof timestamp === 'number') {
+          return { type: 'dtm', value: timestamp };
+      }
+      else if (timestamp.type === 'ttm') {
+          // We can return timestamp here, but this is safer fallback
+          return { type: 'ttm', value: timestamp.value };
+      }
+      else {
+          return { type: 'dtm', value: timestamp.value || new Date().getTime() };
+      }
+  }
+  /**
+   * Create a tracker core object
+   *
+   * @param base64 - Whether to base 64 encode contexts and self describing event JSONs
+   * @param corePlugins - The core plugins to be processed with each event
+   * @param callback - Function applied to every payload dictionary object
+   * @returns Tracker core
+   */
+  function trackerCore(configuration) {
+      if (configuration === void 0) { configuration = {}; }
+      function newCore(base64, corePlugins, callback) {
+          var pluginContextsHelper = pluginContexts(corePlugins), globalContextsHelper = globalContexts();
+          var encodeBase64 = base64, payloadPairs = {}; // Dictionary of key-value pairs which get added to every payload, e.g. tracker version
+          /**
+           * Wraps an array of custom contexts in a self-describing JSON
+           *
+           * @param contexts - Array of custom context self-describing JSONs
+           * @returns Outer JSON
+           */
+          function completeContexts(contexts) {
+              if (contexts && contexts.length) {
+                  return {
+                      schema: 'iglu:com.snowplowanalytics.snowplow/contexts/jsonschema/1-0-0',
+                      data: contexts,
+                  };
+              }
+              return undefined;
+          }
+          /**
+           * Adds all global contexts to a contexts array
+           *
+           * @param pb - PayloadData
+           * @param contexts - Custom contexts relating to the event
+           */
+          function attachGlobalContexts(pb, contexts) {
+              var applicableContexts = globalContextsHelper.getApplicableContexts(pb);
+              var returnedContexts = [];
+              if (contexts && contexts.length) {
+                  returnedContexts.push.apply(returnedContexts, contexts);
+              }
+              if (applicableContexts && applicableContexts.length) {
+                  returnedContexts.push.apply(returnedContexts, applicableContexts);
+              }
+              return returnedContexts;
+          }
+          /**
+           * Gets called by every trackXXX method
+           * Adds context and payloadPairs name-value pairs to the payload
+           * Applies the callback to the built payload
+           *
+           * @param pb - Payload
+           * @param context - Custom contexts relating to the event
+           * @param timestamp - Timestamp of the event
+           * @returns Payload after the callback is applied or undefined if the event is skipped
+           */
+          function track(pb, context, timestamp) {
+              pb.withJsonProcessor(payloadJsonProcessor(encodeBase64));
+              pb.add('eid', v4());
+              pb.addDict(payloadPairs);
+              var tstamp = getTimestamp(timestamp);
+              pb.add(tstamp.type, tstamp.value.toString());
+              var allContexts = attachGlobalContexts(pb, pluginContextsHelper.addPluginContexts(context));
+              var wrappedContexts = completeContexts(allContexts);
+              if (wrappedContexts !== undefined) {
+                  pb.addJson('cx', 'co', wrappedContexts);
+              }
+              corePlugins.forEach(function (plugin) {
+                  try {
+                      if (plugin.beforeTrack) {
+                          plugin.beforeTrack(pb);
+                      }
+                  }
+                  catch (ex) {
+                      LOG.error('Plugin beforeTrack', ex);
+                  }
+              });
+              // Call the filter on plugins to determine if the event should be tracked
+              var skip = corePlugins.find(function (plugin) {
+                  try {
+                      return plugin.filter && plugin.filter(pb.build()) === false;
+                  }
+                  catch (ex) {
+                      LOG.error('Plugin filter', ex);
+                      return false;
+                  }
+              });
+              if (skip) {
+                  return undefined;
+              }
+              if (typeof callback === 'function') {
+                  callback(pb);
+              }
+              var finalPayload = pb.build();
+              corePlugins.forEach(function (plugin) {
+                  try {
+                      if (plugin.afterTrack) {
+                          plugin.afterTrack(finalPayload);
+                      }
+                  }
+                  catch (ex) {
+                      LOG.error('Plugin afterTrack', ex);
+                  }
+              });
+              return finalPayload;
+          }
+          /**
+           * Set a persistent key-value pair to be added to every payload
+           *
+           * @param key - Field name
+           * @param value - Field value
+           */
+          function addPayloadPair(key, value) {
+              payloadPairs[key] = value;
+          }
+          var core = {
+              track: track,
+              addPayloadPair: addPayloadPair,
+              getBase64Encoding: function () {
+                  return encodeBase64;
+              },
+              setBase64Encoding: function (encode) {
+                  encodeBase64 = encode;
+              },
+              addPayloadDict: function (dict) {
+                  for (var key in dict) {
+                      if (Object.prototype.hasOwnProperty.call(dict, key)) {
+                          payloadPairs[key] = dict[key];
+                      }
+                  }
+              },
+              resetPayloadPairs: function (dict) {
+                  payloadPairs = isJson(dict) ? dict : {};
+              },
+              setTrackerVersion: function (version) {
+                  addPayloadPair('tv', version);
+              },
+              setTrackerNamespace: function (name) {
+                  addPayloadPair('tna', name);
+              },
+              setAppId: function (appId) {
+                  addPayloadPair('aid', appId);
+              },
+              setPlatform: function (value) {
+                  addPayloadPair('p', value);
+              },
+              setUserId: function (userId) {
+                  addPayloadPair('uid', userId);
+              },
+              setScreenResolution: function (width, height) {
+                  addPayloadPair('res', width + 'x' + height);
+              },
+              setViewport: function (width, height) {
+                  addPayloadPair('vp', width + 'x' + height);
+              },
+              setColorDepth: function (depth) {
+                  addPayloadPair('cd', depth);
+              },
+              setTimezone: function (timezone) {
+                  addPayloadPair('tz', timezone);
+              },
+              setLang: function (lang) {
+                  addPayloadPair('lang', lang);
+              },
+              setIpAddress: function (ip) {
+                  addPayloadPair('ip', ip);
+              },
+              setUseragent: function (useragent) {
+                  addPayloadPair('ua', useragent);
+              },
+              addGlobalContexts: function (contexts) {
+                  globalContextsHelper.addGlobalContexts(contexts);
+              },
+              clearGlobalContexts: function () {
+                  globalContextsHelper.clearGlobalContexts();
+              },
+              removeGlobalContexts: function (contexts) {
+                  globalContextsHelper.removeGlobalContexts(contexts);
+              },
+          };
+          return core;
+      }
+      var base64 = configuration.base64, corePlugins = configuration.corePlugins, callback = configuration.callback, plugins = corePlugins !== null && corePlugins !== void 0 ? corePlugins : [], partialCore = newCore(base64 !== null && base64 !== void 0 ? base64 : true, plugins, callback), core = __assign(__assign({}, partialCore), { addPlugin: function (configuration) {
+              var _a, _b;
+              var plugin = configuration.plugin;
+              plugins.push(plugin);
+              (_a = plugin.logger) === null || _a === void 0 ? void 0 : _a.call(plugin, LOG);
+              (_b = plugin.activateCorePlugin) === null || _b === void 0 ? void 0 : _b.call(plugin, core);
+          } });
+      plugins === null || plugins === void 0 ? void 0 : plugins.forEach(function (plugin) {
+          var _a, _b;
+          (_a = plugin.logger) === null || _a === void 0 ? void 0 : _a.call(plugin, LOG);
+          (_b = plugin.activateCorePlugin) === null || _b === void 0 ? void 0 : _b.call(plugin, core);
+      });
+      return core;
+  }
+  /**
+   * Build a self-describing event
+   * A custom event type, allowing for an event to be tracked using your own custom schema
+   * and a data object which conforms to the supplied schema
+   *
+   * @param event - Contains the properties and schema location for the event
+   * @returns PayloadBuilder to be sent to {@link @snowplow/tracker-core#TrackerCore.track}
+   */
+  function buildSelfDescribingEvent(event) {
+      var _a = event.event, schema = _a.schema, data = _a.data, pb = payloadBuilder();
+      var ueJson = {
+          schema: 'iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0',
+          data: { schema: schema, data: data },
+      };
+      pb.add('e', 'ue');
+      pb.addJson('ue_px', 'ue_pr', ueJson);
+      return pb;
+  }
+  /**
+   * Build a Page View Event
+   * Represents a Page View, which is typically fired as soon as possible when a web page
+   * is loaded within the users browser. Often also fired on "virtual page views" within
+   * Single Page Applications (SPA).
+   *
+   * @param event - Contains the properties for the Page View event
+   * @returns PayloadBuilder to be sent to {@link @snowplow/tracker-core#TrackerCore.track}
+   */
+  function buildPageView(event) {
+      var pageUrl = event.pageUrl, pageTitle = event.pageTitle, referrer = event.referrer, pb = payloadBuilder();
+      pb.add('e', 'pv'); // 'pv' for Page View
+      pb.add('url', pageUrl);
+      pb.add('page', pageTitle);
+      pb.add('refr', referrer);
+      return pb;
+  }
+  /**
+   * Build a Structured Event
+   * A classic style of event tracking, allows for easier movement between analytics
+   * systems. A loosely typed event, creating a Self Describing event is preferred, but
+   * useful for interoperability.
+   *
+   * @param event - Contains the properties for the Structured event
+   * @returns PayloadBuilder to be sent to {@link @snowplow/tracker-core#TrackerCore.track}
+   */
+  function buildStructEvent(event) {
+      var category = event.category, action = event.action, label = event.label, property = event.property, value = event.value, pb = payloadBuilder();
+      pb.add('e', 'se'); // 'se' for Structured Event
+      pb.add('se_ca', category);
+      pb.add('se_ac', action);
+      pb.add('se_la', label);
+      pb.add('se_pr', property);
+      pb.add('se_va', value == null ? undefined : value.toString());
+      return pb;
+  }
+
+  function newInMemoryEventStore(_a) {
+      var _b = _a.maxSize, maxSize = _b === void 0 ? 1000 : _b, _c = _a.events, events = _c === void 0 ? [] : _c;
+      var store = __spreadArray([], events, true);
+      var count = function () { return Promise.resolve(store.length); };
+      return {
+          count: count,
+          add: function (payload) {
+              store.push(payload);
+              while (store.length > maxSize) {
+                  store.shift();
+              }
+              return count();
+          },
+          removeHead: function (count) {
+              for (var i = 0; i < count; i++) {
+                  store.shift();
+              }
+              return Promise.resolve();
+          },
+          iterator: function () {
+              var index = 0;
+              // copy the store to prevent mutation
+              var events = __spreadArray([], store, true);
+              return {
+                  next: function () {
+                      if (index < events.length) {
+                          return Promise.resolve({ value: events[index++], done: false });
+                      }
+                      return Promise.resolve({ value: undefined, done: true });
+                  },
+              };
+          },
+          getAll: function () { return Promise.resolve(__spreadArray([], store, true)); },
+          getAllPayloads: function () { return Promise.resolve(store.map(function (e) { return e.payload; })); },
+      };
+  }
+
+  var PAYLOAD_DATA_SCHEMA = 'iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4';
+
+  /**
+   * Enclose an array of events in a self-describing payload_data JSON string
+   *
+   * @param array - events Batch of events
+   * @returns string payload_data self-describing JSON
+   */
+  function encloseInPayloadDataEnvelope(events) {
+      return JSON.stringify({
+          schema: PAYLOAD_DATA_SCHEMA,
+          data: events,
+      });
+  }
+  /**
+   * Attaches the STM field to outbound POST events.
+   *
+   * @param events - the events to attach the STM to
+   */
+  function attachStmToEvent(events) {
+      var stm = new Date().getTime().toString();
+      for (var i = 0; i < events.length; i++) {
+          events[i]['stm'] = stm;
+      }
+      return events;
+  }
+  function newEmitterRequest(_a) {
+      var endpoint = _a.endpoint, _b = _a.protocol, protocol = _b === void 0 ? 'https' : _b, port = _a.port, _c = _a.eventMethod, eventMethod = _c === void 0 ? 'post' : _c, customHeaders = _a.customHeaders, connectionTimeout = _a.connectionTimeout, _d = _a.keepalive, keepalive = _d === void 0 ? false : _d, _e = _a.postPath, postPath = _e === void 0 ? '/com.snowplowanalytics.snowplow/tp2' : _e, _f = _a.useStm, useStm = _f === void 0 ? true : _f, _g = _a.maxPostBytes, maxPostBytes = _g === void 0 ? 40000 : _g, _h = _a.credentials, credentials = _h === void 0 ? 'include' : _h;
+      var events = [];
+      var usePost = eventMethod.toLowerCase() === 'post';
+      var timer;
+      var abortController;
+      function countBytes() {
+          var count = events.reduce(function (acc, event) { return acc + (usePost ? event.getPOSTRequestBytesCount() : event.getGETRequestBytesCount()); }, 0);
+          if (usePost) {
+              count += 88; // 88 bytes for the payload_data envelope
+          }
+          return count;
+      }
+      function countEvents() {
+          return events.length;
+      }
+      function getServerAnonymizationOfExistingEvents() {
+          return events.length > 0 ? events[0].getServerAnonymization() : undefined;
+      }
+      function addEvent(event) {
+          if (events.length > 0 && getServerAnonymizationOfExistingEvents() !== event.getServerAnonymization()) {
+              return false;
+          }
+          else {
+              events.push(event);
+              return true;
+          }
+      }
+      function getEvents() {
+          return events;
+      }
+      function isFull() {
+          if (usePost) {
+              return countBytes() >= maxPostBytes;
+          }
+          else {
+              return events.length >= 1;
+          }
+      }
+      function createHeaders() {
+          var headers = new Headers();
+          if (usePost) {
+              headers.append('Content-Type', 'application/json; charset=UTF-8');
+          }
+          if (customHeaders) {
+              Object.keys(customHeaders).forEach(function (key) {
+                  headers.append(key, customHeaders[key]);
+              });
+          }
+          if (getServerAnonymizationOfExistingEvents()) {
+              headers.append('SP-Anonymous', '*');
+          }
+          return headers;
+      }
+      function getFullCollectorUrl() {
+          var collectorUrl = endpoint;
+          if (!endpoint.includes('://')) {
+              collectorUrl = "".concat(protocol, "://").concat(endpoint);
+          }
+          if (port) {
+              collectorUrl = "".concat(collectorUrl, ":").concat(port);
+          }
+          var path = usePost ? postPath : '/i';
+          return collectorUrl + path;
+      }
+      function makeRequest(url, options) {
+          closeRequest(false);
+          abortController = new AbortController();
+          timer = setTimeout(function () {
+              var reason = 'Request timed out';
+              console.error(reason);
+              timer = undefined;
+              closeRequest(false, reason);
+          }, connectionTimeout !== null && connectionTimeout !== void 0 ? connectionTimeout : 5000);
+          var requestOptions = __assign({ headers: createHeaders(), signal: abortController.signal, keepalive: keepalive, credentials: credentials }, options);
+          var request = new Request(url, requestOptions);
+          return request;
+      }
+      function makePostRequest() {
+          var batch = attachStmToEvent(events.map(function (event) { return event.getPOSTRequestBody(); }));
+          return makeRequest(getFullCollectorUrl(), {
+              method: 'POST',
+              body: encloseInPayloadDataEnvelope(batch),
+          });
+      }
+      function makeGetRequest() {
+          if (events.length !== 1) {
+              throw new Error('Only one event can be sent in a GET request');
+          }
+          var event = events[0];
+          var url = event.getGETRequestURL(getFullCollectorUrl(), useStm);
+          return makeRequest(url, {
+              method: 'GET',
+          });
+      }
+      function toRequest() {
+          if (events.length === 0) {
+              return undefined;
+          }
+          if (usePost) {
+              return makePostRequest();
+          }
+          else {
+              return makeGetRequest();
+          }
+      }
+      function closeRequest(successful, reason) {
+          if (timer !== undefined) {
+              clearTimeout(timer);
+              timer = undefined;
+          }
+          if (abortController !== undefined) {
+              var controller = abortController;
+              abortController = undefined;
+              if (!successful) {
+                  controller.abort(reason);
+              }
+          }
+      }
+      return {
+          addEvent: addEvent,
+          getEvents: getEvents,
+          toRequest: toRequest,
+          countBytes: countBytes,
+          countEvents: countEvents,
+          isFull: isFull,
+          closeRequest: closeRequest,
+      };
+  }
+
+  /**
+   * Count the number of bytes a string will occupy when UTF-8 encoded
+   * Taken from http://stackoverflow.com/questions/2848462/count-bytes-in-textarea-using-javascript/
+   *
+   * @param s - The string
+   * @returns number Length of s in bytes when UTF-8 encoded
+   */
+  function getUTF8Length(s) {
+      var len = 0;
+      for (var i = 0; i < s.length; i++) {
+          var code = s.charCodeAt(i);
+          if (code <= 0x7f) {
+              len += 1;
+          }
+          else if (code <= 0x7ff) {
+              len += 2;
+          }
+          else if (code >= 0xd800 && code <= 0xdfff) {
+              // Surrogate pair: These take 4 bytes in UTF-8 and 2 chars in UCS-2
+              // (Assume next char is the other [valid] half and just skip it)
+              len += 4;
+              i++;
+          }
+          else if (code < 0xffff) {
+              len += 3;
+          }
+          else {
+              len += 4;
+          }
+      }
+      return len;
+  }
+  /*
+    * Convert a dictionary to a querystring
+    * The context field is the last in the querystring
+    */
+  function getQuerystring(request) {
+      var lowPriorityKeys = { co: true, cx: true };
+      var args = [];
+      for (var key in request) {
+          if (request.hasOwnProperty(key) && !lowPriorityKeys[key]) {
+              args.push(key + '=' + encodeURIComponent(request[key]));
+          }
+      }
+      for (var contextKey in lowPriorityKeys) {
+          if (request.hasOwnProperty(contextKey) && lowPriorityKeys[contextKey]) {
+              args.push(contextKey + '=' + encodeURIComponent(request[contextKey]));
+          }
+      }
+      return '?' + args.join('&');
+  }
+  /*
+    * Convert numeric fields to strings to match payload_data schema
+    */
+  function preparePostBody(request) {
+      var cleanedRequest = Object.keys(request)
+          .map(function (k) { return [k, request[k]]; })
+          .reduce(function (acc, _a) {
+          var key = _a[0], value = _a[1];
+          acc[key] = value.toString();
+          return acc;
+      }, {});
+      return cleanedRequest;
+  }
+  function newEmitterEvent(eventStorePayload) {
+      var querystring = null;
+      var postBody = null;
+      var byteCountGET = null;
+      var byteCountPOST = null;
+      function getPayload() {
+          return eventStorePayload.payload;
+      }
+      function getServerAnonymization() {
+          var _a;
+          return (_a = eventStorePayload.svrAnon) !== null && _a !== void 0 ? _a : false;
+      }
+      function getCachedQuerystring(payload) {
+          if (querystring === null) {
+              querystring = getQuerystring(payload);
+          }
+          return querystring;
+      }
+      function getGETRequestURL(collectorUrl, useStm) {
+          var querystring = getCachedQuerystring(getPayload());
+          if (useStm) {
+              return collectorUrl + querystring.replace('?', '?stm=' + new Date().getTime() + '&');
+          }
+          return collectorUrl + querystring;
+      }
+      function getGETRequestBytesCount() {
+          if (byteCountGET === null) {
+              var querystring_1 = getCachedQuerystring(getPayload());
+              byteCountGET = getUTF8Length(querystring_1);
+          }
+          return byteCountGET;
+      }
+      function getPOSTRequestBody() {
+          if (postBody === null) {
+              postBody = preparePostBody(getPayload());
+          }
+          return postBody;
+      }
+      function getPOSTRequestBytesCount() {
+          if (byteCountPOST === null) {
+              byteCountPOST = getUTF8Length(JSON.stringify(getPOSTRequestBody()));
+          }
+          return byteCountPOST;
+      }
+      return {
+          getPayload: getPayload,
+          getServerAnonymization: getServerAnonymization,
+          getGETRequestURL: getGETRequestURL,
+          getGETRequestBytesCount: getGETRequestBytesCount,
+          getPOSTRequestBody: getPOSTRequestBody,
+          getPOSTRequestBytesCount: getPOSTRequestBytesCount,
+      };
+  }
+
+  function newEmitter(_a) {
+      var endpoint = _a.endpoint, _b = _a.eventMethod, eventMethod = _b === void 0 ? 'post' : _b, protocol = _a.protocol, port = _a.port, _c = _a.maxPostBytes, maxPostBytes = _c === void 0 ? 40000 : _c, maxGetBytes = _a.maxGetBytes, _d = _a.bufferSize, bufferSize = _d === void 0 ? 1 : _d, customHeaders = _a.customHeaders, serverAnonymization = _a.serverAnonymization, connectionTimeout = _a.connectionTimeout, keepalive = _a.keepalive, idService = _a.idService, _e = _a.dontRetryStatusCodes, dontRetryStatusCodes = _e === void 0 ? [] : _e, _f = _a.retryStatusCodes, retryStatusCodes = _f === void 0 ? [] : _f, _g = _a.retryFailedRequests, retryFailedRequests = _g === void 0 ? true : _g, onRequestFailure = _a.onRequestFailure, onRequestSuccess = _a.onRequestSuccess, _h = _a.customFetch, customFetch = _h === void 0 ? fetch : _h, useStm = _a.useStm, _j = _a.eventStore, eventStore = _j === void 0 ? newInMemoryEventStore({}) : _j, credentials = _a.credentials;
+      var idServiceCalled = false;
+      var flushInProgress = false;
+      var usePost = eventMethod.toLowerCase() === 'post';
+      dontRetryStatusCodes = dontRetryStatusCodes.concat([400, 401, 403, 410, 422]);
+      function shouldRetryForStatusCode(statusCode) {
+          // success, don't retry
+          if (statusCode >= 200 && statusCode < 300) {
+              return false;
+          }
+          if (!retryFailedRequests) {
+              return false;
+          }
+          // retry if status code among custom user-supplied retry codes
+          if (retryStatusCodes.includes(statusCode)) {
+              return true;
+          }
+          // retry if status code *not* among the don't retry codes
+          return !dontRetryStatusCodes.includes(statusCode);
+      }
+      function callOnRequestSuccess(payloads, response) {
+          if (onRequestSuccess !== undefined) {
+              setTimeout(function () {
+                  try {
+                      onRequestSuccess === null || onRequestSuccess === void 0 ? void 0 : onRequestSuccess(payloads, response);
+                  }
+                  catch (e) {
+                      LOG.error('Error in onRequestSuccess', e);
+                  }
+              }, 0);
+          }
+      }
+      function callOnRequestFailure(failure, response) {
+          if (onRequestFailure !== undefined) {
+              setTimeout(function () {
+                  try {
+                      onRequestFailure === null || onRequestFailure === void 0 ? void 0 : onRequestFailure(failure, response);
+                  }
+                  catch (e) {
+                      LOG.error('Error in onRequestFailure', e);
+                  }
+              }, 0);
+          }
+      }
+      function executeRequest(request) {
+          return __awaiter(this, void 0, void 0, function () {
+              var fetchRequest, payloads, response, willRetry, e_1, message;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          fetchRequest = request.toRequest();
+                          if (fetchRequest === undefined) {
+                              throw new Error('Empty batch');
+                          }
+                          payloads = request.getEvents().map(function (event) { return event.getPayload(); });
+                          _a.label = 1;
+                      case 1:
+                          _a.trys.push([1, 4, , 5]);
+                          return [4 /*yield*/, customFetch(fetchRequest)];
+                      case 2:
+                          response = _a.sent();
+                          return [4 /*yield*/, response.text()];
+                      case 3:
+                          _a.sent(); // wait for the response to be fully read
+                          request.closeRequest(true);
+                          if (response.ok) {
+                              callOnRequestSuccess(payloads, response);
+                              return [2 /*return*/, { success: true, retry: false, status: response.status }];
+                          }
+                          else {
+                              willRetry = shouldRetryForStatusCode(response.status);
+                              callOnRequestFailure({
+                                  events: payloads,
+                                  status: response.status,
+                                  message: response.statusText,
+                                  willRetry: willRetry,
+                              }, response);
+                              return [2 /*return*/, { success: false, retry: willRetry, status: response.status }];
+                          }
+                      case 4:
+                          e_1 = _a.sent();
+                          request.closeRequest(false);
+                          message = typeof e_1 === 'string' ? e_1 : e_1 ? e_1.message : 'Unknown error';
+                          callOnRequestFailure({
+                              events: payloads,
+                              message: message,
+                              willRetry: true,
+                          });
+                          return [2 /*return*/, { success: false, retry: true }];
+                      case 5: return [2 /*return*/];
+                  }
+              });
+          });
+      }
+      function newEmitterRequestWithConfig() {
+          return newEmitterRequest({
+              endpoint: endpoint,
+              protocol: protocol,
+              port: port,
+              eventMethod: eventMethod,
+              customHeaders: customHeaders,
+              connectionTimeout: connectionTimeout,
+              keepalive: keepalive,
+              maxPostBytes: maxPostBytes,
+              useStm: useStm,
+              credentials: credentials,
+          });
+      }
+      function shouldSkipEventStore(emitterEvent) {
+          var eventTooBigWarning = function (bytes, maxBytes) {
+              return LOG.warn('Event (' + bytes + 'B) too big, max is ' + maxBytes);
+          };
+          if (usePost) {
+              var bytes = emitterEvent.getPOSTRequestBytesCount() + 88; // 88 bytes for the payload_data envelope
+              var tooBig = bytes > maxPostBytes;
+              if (tooBig) {
+                  eventTooBigWarning(bytes, maxPostBytes);
+              }
+              return tooBig;
+          }
+          else {
+              if (maxGetBytes === undefined) {
+                  return false;
+              }
+              var bytes = emitterEvent.getGETRequestBytesCount();
+              var tooBig = bytes > maxGetBytes;
+              if (tooBig) {
+                  eventTooBigWarning(bytes, maxGetBytes);
+              }
+              return tooBig;
+          }
+      }
+      function callIdService() {
+          return __awaiter(this, void 0, void 0, function () {
+              var request;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          if (!(idService && !idServiceCalled)) return [3 /*break*/, 2];
+                          idServiceCalled = true;
+                          request = new Request(idService, { method: 'GET' });
+                          return [4 /*yield*/, customFetch(request)];
+                      case 1:
+                          _a.sent();
+                          _a.label = 2;
+                      case 2: return [2 /*return*/];
+                  }
+              });
+          });
+      }
+      function flush() {
+          return __awaiter(this, void 0, void 0, function () {
+              var e_2;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          if (!!flushInProgress) return [3 /*break*/, 5];
+                          flushInProgress = true;
+                          _a.label = 1;
+                      case 1:
+                          _a.trys.push([1, 3, 4, 5]);
+                          return [4 /*yield*/, continueFlush()];
+                      case 2:
+                          _a.sent();
+                          return [3 /*break*/, 5];
+                      case 3:
+                          e_2 = _a.sent();
+                          LOG.error('Error sending events', e_2);
+                          return [3 /*break*/, 5];
+                      case 4:
+                          flushInProgress = false;
+                          return [7 /*endfinally*/];
+                      case 5: return [2 /*return*/];
+                  }
+              });
+          });
+      }
+      function continueFlush() {
+          return __awaiter(this, void 0, void 0, function () {
+              var request, eventStoreIterator, _a, value, done, event_1, _b, success, retry, status;
+              return __generator(this, function (_c) {
+                  switch (_c.label) {
+                      case 0: return [4 /*yield*/, callIdService()];
+                      case 1:
+                          _c.sent();
+                          request = newEmitterRequestWithConfig();
+                          eventStoreIterator = eventStore.iterator();
+                          _c.label = 2;
+                      case 2:
+                          if (request.isFull()) {
+                              return [3 /*break*/, 4];
+                          }
+                          return [4 /*yield*/, eventStoreIterator.next()];
+                      case 3:
+                          _a = _c.sent(), value = _a.value, done = _a.done;
+                          if (done || value === undefined) {
+                              return [3 /*break*/, 4];
+                          }
+                          event_1 = newEmitterEvent(value);
+                          if (!request.addEvent(event_1)) {
+                              return [3 /*break*/, 4];
+                          }
+                          return [3 /*break*/, 2];
+                      case 4:
+                          if (request.countEvents() === 0) {
+                              return [2 /*return*/];
+                          }
+                          return [4 /*yield*/, executeRequest(request)];
+                      case 5:
+                          _b = _c.sent(), success = _b.success, retry = _b.retry, status = _b.status;
+                          if (!(success || !retry)) return [3 /*break*/, 7];
+                          if (!success) {
+                              LOG.error("Status ".concat(status, ", will not retry."));
+                          }
+                          return [4 /*yield*/, eventStore.removeHead(request.countEvents())];
+                      case 6:
+                          _c.sent();
+                          _c.label = 7;
+                      case 7:
+                          if (!success) return [3 /*break*/, 9];
+                          return [4 /*yield*/, continueFlush()];
+                      case 8:
+                          _c.sent();
+                          _c.label = 9;
+                      case 9: return [2 /*return*/];
+                  }
+              });
+          });
+      }
+      function input(payload) {
+          return __awaiter(this, void 0, void 0, function () {
+              var eventStorePayload, event, request, count;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          eventStorePayload = newEventStorePayload({ payload: payload, svrAnon: serverAnonymization });
+                          event = newEmitterEvent(eventStorePayload);
+                          if (!shouldSkipEventStore(event)) return [3 /*break*/, 2];
+                          request = newEmitterRequestWithConfig();
+                          request.addEvent(event);
+                          return [4 /*yield*/, executeRequest(request)];
+                      case 1:
+                          _a.sent();
+                          return [3 /*break*/, 5];
+                      case 2: return [4 /*yield*/, eventStore.add(eventStorePayload)];
+                      case 3:
+                          count = _a.sent();
+                          if (!(count >= bufferSize)) return [3 /*break*/, 5];
+                          return [4 /*yield*/, flush()];
+                      case 4:
+                          _a.sent();
+                          _a.label = 5;
+                      case 5: return [2 /*return*/];
+                  }
+              });
+          });
+      }
+      function setCollectorUrl(url) {
+          endpoint = url;
+      }
+      function setAnonymousTracking(at) {
+          serverAnonymization = at;
+      }
+      function setBufferSize(bs) {
+          bufferSize = bs;
+      }
+      return {
+          flush: flush,
+          input: input,
+          setCollectorUrl: setCollectorUrl,
+          setAnonymousTracking: setAnonymousTracking,
+          setBufferSize: setBufferSize,
+      };
+  }
+
+  /*
+   * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+   * All rights reserved.
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   *
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the documentation
+   *    and/or other materials provided with the distribution.
+   *
+   * 3. Neither the name of the copyright holder nor the names of its
+   *    contributors may be used to endorse or promote products derived from
+   *    this software without specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  var version = version$1;
+
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  var isPlainObj = value => {
+  	if (Object.prototype.toString.call(value) !== '[object Object]') {
+  		return false;
+  	}
+
+  	const prototype = Object.getPrototypeOf(value);
+  	return prototype === null || prototype === Object.prototype;
+  };
+
+  const isOptionObject = isPlainObj;
+
+  const {hasOwnProperty} = Object.prototype;
+  const {propertyIsEnumerable} = Object;
+  const defineProperty = (object, name, value) => Object.defineProperty(object, name, {
+  	value,
+  	writable: true,
+  	enumerable: true,
+  	configurable: true
+  });
+
+  const globalThis$1 = commonjsGlobal;
+  const defaultMergeOptions = {
+  	concatArrays: false,
+  	ignoreUndefined: false
+  };
+
+  const getEnumerableOwnPropertyKeys = value => {
+  	const keys = [];
+
+  	for (const key in value) {
+  		if (hasOwnProperty.call(value, key)) {
+  			keys.push(key);
+  		}
+  	}
+
+  	/* istanbul ignore else  */
+  	if (Object.getOwnPropertySymbols) {
+  		const symbols = Object.getOwnPropertySymbols(value);
+
+  		for (const symbol of symbols) {
+  			if (propertyIsEnumerable.call(value, symbol)) {
+  				keys.push(symbol);
+  			}
+  		}
+  	}
+
+  	return keys;
+  };
+
+  function clone(value) {
+  	if (Array.isArray(value)) {
+  		return cloneArray(value);
+  	}
+
+  	if (isOptionObject(value)) {
+  		return cloneOptionObject(value);
+  	}
+
+  	return value;
+  }
+
+  function cloneArray(array) {
+  	const result = array.slice(0, 0);
+
+  	getEnumerableOwnPropertyKeys(array).forEach(key => {
+  		defineProperty(result, key, clone(array[key]));
+  	});
+
+  	return result;
+  }
+
+  function cloneOptionObject(object) {
+  	const result = Object.getPrototypeOf(object) === null ? Object.create(null) : {};
+
+  	getEnumerableOwnPropertyKeys(object).forEach(key => {
+  		defineProperty(result, key, clone(object[key]));
+  	});
+
+  	return result;
+  }
+
+  /**
+   * @param {*} merged already cloned
+   * @param {*} source something to merge
+   * @param {string[]} keys keys to merge
+   * @param {Object} config Config Object
+   * @returns {*} cloned Object
+   */
+  const mergeKeys = (merged, source, keys, config) => {
+  	keys.forEach(key => {
+  		if (typeof source[key] === 'undefined' && config.ignoreUndefined) {
+  			return;
+  		}
+
+  		// Do not recurse into prototype chain of merged
+  		if (key in merged && merged[key] !== Object.getPrototypeOf(merged)) {
+  			defineProperty(merged, key, merge$1(merged[key], source[key], config));
+  		} else {
+  			defineProperty(merged, key, clone(source[key]));
+  		}
+  	});
+
+  	return merged;
+  };
+
+  /**
+   * @param {*} merged already cloned
+   * @param {*} source something to merge
+   * @param {Object} config Config Object
+   * @returns {*} cloned Object
+   *
+   * see [Array.prototype.concat ( ...arguments )](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.concat)
+   */
+  const concatArrays = (merged, source, config) => {
+  	let result = merged.slice(0, 0);
+  	let resultIndex = 0;
+
+  	[merged, source].forEach(array => {
+  		const indices = [];
+
+  		// `result.concat(array)` with cloning
+  		for (let k = 0; k < array.length; k++) {
+  			if (!hasOwnProperty.call(array, k)) {
+  				continue;
+  			}
+
+  			indices.push(String(k));
+
+  			if (array === merged) {
+  				// Already cloned
+  				defineProperty(result, resultIndex++, array[k]);
+  			} else {
+  				defineProperty(result, resultIndex++, clone(array[k]));
+  			}
+  		}
+
+  		// Merge non-index keys
+  		result = mergeKeys(result, array, getEnumerableOwnPropertyKeys(array).filter(key => !indices.includes(key)), config);
+  	});
+
+  	return result;
+  };
+
+  /**
+   * @param {*} merged already cloned
+   * @param {*} source something to merge
+   * @param {Object} config Config Object
+   * @returns {*} cloned Object
+   */
+  function merge$1(merged, source, config) {
+  	if (config.concatArrays && Array.isArray(merged) && Array.isArray(source)) {
+  		return concatArrays(merged, source, config);
+  	}
+
+  	if (!isOptionObject(source) || !isOptionObject(merged)) {
+  		return clone(source);
+  	}
+
+  	return mergeKeys(merged, source, getEnumerableOwnPropertyKeys(source), config);
+  }
+
+  var mergeOptions = function (...options) {
+  	const config = merge$1(clone(defaultMergeOptions), (this !== globalThis$1 && this) || {}, defaultMergeOptions);
+  	let merged = {_: {}};
+
+  	for (const option of options) {
+  		if (option === undefined) {
+  			continue;
+  		}
+
+  		if (!isOptionObject(option)) {
+  			throw new TypeError('`' + option + '` is not an Option Object');
+  		}
+
+  		merged = merge$1(merged, {_: option}, config);
+  	}
+
+  	return merged._;
+  };
+
+  var mergeOptions$1 = mergeOptions;
+
+  /**
+   * Copyright (c) Nicolas Gallagher.
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  // eslint-disable-next-line @typescript-eslint/ban-types
+
+  // eslint-disable-next-line @typescript-eslint/ban-types
+
+  const merge = mergeOptions$1.bind({
+    concatArrays: true,
+    ignoreUndefined: true
+  });
+  function mergeLocalStorageItem(key, value) {
+    const oldValue = window.localStorage.getItem(key);
+    if (oldValue) {
+      const oldObject = JSON.parse(oldValue);
+      const newObject = JSON.parse(value);
+      const nextValue = JSON.stringify(merge(oldObject, newObject));
+      window.localStorage.setItem(key, nextValue);
+    } else {
+      window.localStorage.setItem(key, value);
+    }
+  }
+  function createPromise(getValue, callback) {
+    return new Promise((resolve, reject) => {
+      try {
+        const value = getValue();
+        callback === null || callback === void 0 ? void 0 : callback(null, value);
+        resolve(value);
+      } catch (err) {
+        callback === null || callback === void 0 ? void 0 : callback(err);
+        reject(err);
+      }
+    });
+  }
+  function createPromiseAll(promises, callback, processResult) {
+    return Promise.all(promises).then(result => {
+      const value = (processResult === null || processResult === void 0 ? void 0 : processResult(result)) ?? null;
+      callback === null || callback === void 0 ? void 0 : callback(null, value);
+      return Promise.resolve(value);
+    }, errors => {
+      callback === null || callback === void 0 ? void 0 : callback(errors);
+      return Promise.reject(errors);
+    });
+  }
+  const AsyncStorage = {
+    /**
+     * Fetches `key` value.
+     */
+    getItem: (key, callback) => {
+      return createPromise(() => window.localStorage.getItem(key), callback);
+    },
+    /**
+     * Sets `value` for `key`.
+     */
+    setItem: (key, value, callback) => {
+      return createPromise(() => window.localStorage.setItem(key, value), callback);
+    },
+    /**
+     * Removes a `key`
+     */
+    removeItem: (key, callback) => {
+      return createPromise(() => window.localStorage.removeItem(key), callback);
+    },
+    /**
+     * Merges existing value with input value, assuming they are stringified JSON.
+     */
+    mergeItem: (key, value, callback) => {
+      return createPromise(() => mergeLocalStorageItem(key, value), callback);
+    },
+    /**
+     * Erases *all* AsyncStorage for the domain.
+     */
+    clear: callback => {
+      return createPromise(() => window.localStorage.clear(), callback);
+    },
+    /**
+     * Gets *all* keys known to the app, for all callers, libraries, etc.
+     */
+    getAllKeys: callback => {
+      return createPromise(() => {
+        const numberOfKeys = window.localStorage.length;
+        const keys = [];
+        for (let i = 0; i < numberOfKeys; i += 1) {
+          const key = window.localStorage.key(i) || "";
+          keys.push(key);
+        }
+        return keys;
+      }, callback);
+    },
+    /**
+     * (stub) Flushes any pending requests using a single batch call to get the data.
+     */
+    flushGetRequests: () => undefined,
+    /**
+     * multiGet resolves to an array of key-value pair arrays that matches the
+     * input format of multiSet.
+     *
+     *   multiGet(['k1', 'k2']) -> [['k1', 'val1'], ['k2', 'val2']]
+     */
+    multiGet: (keys, callback) => {
+      const promises = keys.map(key => AsyncStorage.getItem(key));
+      const processResult = result => result.map((value, i) => [keys[i], value]);
+      return createPromiseAll(promises, callback, processResult);
+    },
+    /**
+     * Takes an array of key-value array pairs.
+     *   multiSet([['k1', 'val1'], ['k2', 'val2']])
+     */
+    multiSet: (keyValuePairs, callback) => {
+      const promises = keyValuePairs.map(item => AsyncStorage.setItem(item[0], item[1]));
+      return createPromiseAll(promises, callback);
+    },
+    /**
+     * Delete all the keys in the `keys` array.
+     */
+    multiRemove: (keys, callback) => {
+      const promises = keys.map(key => AsyncStorage.removeItem(key));
+      return createPromiseAll(promises, callback);
+    },
+    /**
+     * Takes an array of key-value array pairs and merges them with existing
+     * values, assuming they are stringified JSON.
+     *
+     *   multiMerge([['k1', 'val1'], ['k2', 'val2']])
+     */
+    multiMerge: (keyValuePairs, callback) => {
+      const promises = keyValuePairs.map(item => AsyncStorage.mergeItem(item[0], item[1]));
+      return createPromiseAll(promises, callback);
+    }
+  };
+  var AsyncStorage$1 = AsyncStorage;
+
+  function newReactNativeEventStore(_a) {
+      var namespace = _a.namespace, _b = _a.maxEventStoreSize, maxEventStoreSize = _b === void 0 ? 1000 : _b, _c = _a.useAsyncStorageForEventStore, useAsyncStorage = _c === void 0 ? true : _c;
+      return __awaiter(this, void 0, void 0, function () {
+          function newInMemoryEventStoreForReactNative() {
+              return __awaiter(this, void 0, void 0, function () {
+                  var data, events;
+                  return __generator(this, function (_a) {
+                      switch (_a.label) {
+                          case 0:
+                              if (!useAsyncStorage) return [3 /*break*/, 2];
+                              return [4 /*yield*/, AsyncStorage$1.getItem(queueName)];
+                          case 1:
+                              data = _a.sent();
+                              events = data ? JSON.parse(data) : [];
+                              return [2 /*return*/, newInMemoryEventStore({ maxSize: maxEventStoreSize, events: events })];
+                          case 2: return [2 /*return*/, newInMemoryEventStore({ maxSize: maxEventStoreSize })];
+                      }
+                  });
+              });
+          }
+          function sync() {
+              return __awaiter(this, void 0, void 0, function () {
+                  var events;
+                  return __generator(this, function (_a) {
+                      switch (_a.label) {
+                          case 0:
+                              if (!useAsyncStorage) return [3 /*break*/, 3];
+                              return [4 /*yield*/, getAll()];
+                          case 1:
+                              events = _a.sent();
+                              return [4 /*yield*/, AsyncStorage$1.setItem(queueName, JSON.stringify(events))];
+                          case 2:
+                              _a.sent();
+                              _a.label = 3;
+                          case 3: return [2 /*return*/];
+                      }
+                  });
+              });
+          }
+          var queueName, eventStore, getAll, getAllPayloads, add, count, iterator, removeHead;
+          var _this = this;
+          return __generator(this, function (_d) {
+              switch (_d.label) {
+                  case 0:
+                      queueName = "snowplow_".concat(namespace);
+                      return [4 /*yield*/, newInMemoryEventStoreForReactNative()];
+                  case 1:
+                      eventStore = _d.sent();
+                      getAll = eventStore.getAll, getAllPayloads = eventStore.getAllPayloads, add = eventStore.add, count = eventStore.count, iterator = eventStore.iterator, removeHead = eventStore.removeHead;
+                      return [2 /*return*/, {
+                              count: count,
+                              add: function (payload) { return __awaiter(_this, void 0, void 0, function () {
+                                  return __generator(this, function (_a) {
+                                      switch (_a.label) {
+                                          case 0: return [4 /*yield*/, add(payload)];
+                                          case 1:
+                                              _a.sent();
+                                              return [4 /*yield*/, sync()];
+                                          case 2:
+                                              _a.sent();
+                                              return [4 /*yield*/, count()];
+                                          case 3: return [2 /*return*/, _a.sent()];
+                                      }
+                                  });
+                              }); },
+                              removeHead: function (n) { return __awaiter(_this, void 0, void 0, function () {
+                                  return __generator(this, function (_a) {
+                                      switch (_a.label) {
+                                          case 0:
+                                              removeHead(n);
+                                              return [4 /*yield*/, sync()];
+                                          case 1:
+                                              _a.sent();
+                                              return [2 /*return*/];
+                                      }
+                                  });
+                              }); },
+                              iterator: iterator,
+                              getAll: getAll,
+                              getAllPayloads: getAllPayloads,
+                          }];
+              }
+          });
+      });
+  }
+
+  function newTrackEventFunctions(core) {
+      var trackSelfDescribingEvent = function (argmap, contexts) {
+          core.track(buildSelfDescribingEvent({ event: argmap }), contexts);
+      };
+      var trackStructuredEvent = function (argmap, contexts) {
+          var _a;
+          return (_a = core.track(buildStructEvent(argmap), contexts)) === null || _a === void 0 ? void 0 : _a.eid;
+      };
+      var trackPageViewEvent = function (argmap, contexts) {
+          var _a;
+          return (_a = core.track(buildPageView(argmap), contexts)) === null || _a === void 0 ? void 0 : _a.eid;
+      };
+      var trackTimingEvent = function (argmap, contexts) {
+          trackSelfDescribingEvent({
+              schema: 'iglu:com.snowplowanalytics.snowplow/timing/jsonschema/1-0-0',
+              data: argmap,
+          }, contexts);
+      };
+      var trackMessageNotificationEvent = function (argmap, contexts) {
+          trackSelfDescribingEvent({
+              schema: 'iglu:com.snowplowanalytics.mobile/message_notification/jsonschema/1-0-0',
+              data: argmap,
+          }, contexts);
+      };
+      return {
+          trackSelfDescribingEvent: trackSelfDescribingEvent,
+          trackStructuredEvent: trackStructuredEvent,
+          trackPageViewEvent: trackPageViewEvent,
+          trackTimingEvent: trackTimingEvent,
+          trackMessageNotificationEvent: trackMessageNotificationEvent,
+      };
+  }
+
+  function newSubject(core, configuration) {
+      var domainUserId;
+      var networkUserId;
+      var addSubjectToPayload = function (payload) {
+          payload.add('duid', domainUserId);
+          payload.add('nuid', networkUserId);
+      };
+      var setScreenResolution = function (screenSize) {
+          return core.setScreenResolution(String(screenSize[0]), String(screenSize[1]));
+      };
+      var setNetworkUserId = function (userId) {
+          networkUserId = userId;
+      };
+      var setDomainUserId = function (userId) {
+          domainUserId = userId;
+      };
+      var setColorDepth = function (colorDepth) {
+          core.setColorDepth(String(colorDepth));
+      };
+      var setScreenViewport = function (screenSize) {
+          core.setViewport(String(screenSize[0]), String(screenSize[1]));
+      };
+      var setSubjectData = function (data) {
+          setNetworkUserId(data.networkUserId);
+          setDomainUserId(data.domainUserId);
+          if (data.userId) {
+              core.setUserId(data.userId);
+          }
+          if (data.useragent) {
+              core.setUseragent(data.useragent);
+          }
+          if (data.ipAddress) {
+              core.setIpAddress(data.ipAddress);
+          }
+          if (data.timezone) {
+              core.setTimezone(data.timezone);
+          }
+          if (data.language) {
+              core.setLang(data.language);
+          }
+          if (data.screenResolution) {
+              setScreenResolution(data.screenResolution);
+          }
+          if (data.colorDepth) {
+              setColorDepth(data.colorDepth);
+          }
+          if (data.screenViewport) {
+              setScreenViewport(data.screenViewport);
+          }
+      };
+      if (configuration) {
+          setSubjectData(configuration);
+      }
+      var subjectPlugin = {
+          plugin: {
+              beforeTrack: addSubjectToPayload,
+          },
+      };
+      return {
+          subjectPlugin: subjectPlugin,
+          properties: {
+              setUserId: core.setUserId,
+              setIpAddress: core.setIpAddress,
+              setUseragent: core.setUseragent,
+              setTimezone: core.setTimezone,
+              setLanguage: core.setLang,
+              setScreenResolution: setScreenResolution,
+              setNetworkUserId: setNetworkUserId,
+              setDomainUserId: setDomainUserId,
+              setSubjectData: setSubjectData,
+              setColorDepth: setColorDepth,
+              setScreenViewport: setScreenViewport,
+          },
+      };
+  }
+
+  /**
+   * Creates a new tracker instance with the given configuration
+   * @param configuration - Configuration for the tracker
+   * @returns Tracker instance
+   */
+  function newTracker(configuration) {
+      return __awaiter(this, void 0, void 0, function () {
+          var namespace, appId, _a, encodeBase64, _b, emitter, callback, core, subject;
+          return __generator(this, function (_c) {
+              switch (_c.label) {
+                  case 0:
+                      namespace = configuration.namespace, appId = configuration.appId, _a = configuration.encodeBase64, encodeBase64 = _a === void 0 ? false : _a;
+                      if (!(configuration.eventStore === undefined)) return [3 /*break*/, 2];
+                      _b = configuration;
+                      return [4 /*yield*/, newReactNativeEventStore(configuration)];
+                  case 1:
+                      _b.eventStore = _c.sent();
+                      _c.label = 2;
+                  case 2:
+                      emitter = newEmitter(configuration);
+                      callback = function (payload) {
+                          emitter.input(payload.build());
+                      };
+                      core = trackerCore({ base64: encodeBase64, callback: callback });
+                      subject = newSubject(core, configuration);
+                      core.addPlugin(subject.subjectPlugin);
+                      core.setPlatform('mob'); // default platform
+                      core.setTrackerVersion('rn-' + version);
+                      core.setTrackerNamespace(namespace);
+                      if (appId) {
+                          core.setAppId(appId);
+                      }
+                      return [2 /*return*/, __assign(__assign(__assign({}, newTrackEventFunctions(core)), subject.properties), { setAppId: core.setAppId, setPlatform: core.setPlatform, flush: emitter.flush, addGlobalContexts: core.addGlobalContexts, removeGlobalContexts: core.removeGlobalContexts, clearGlobalContexts: core.clearGlobalContexts, addPlugin: core.addPlugin })];
+              }
+          });
+      });
+  }
+
+  if (typeof crypto === 'undefined') {
+      throw new Error('Web Crypto is not available. Please use a polyfill like react-native-get-random-values');
+  }
+
+  exports.newTracker = newTracker;
+  exports.version = version;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.cjs.js.map