core-outline 1.1.21 → 1.1.23

package/dist/index.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
 var uuid = require('uuid');
-var engine_ioClient = require('engine.io-client');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -46,6 +45,14 @@ function _asyncToGenerator(n) {
     });
   };
 }
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
 function _iterableToArray(r) {
   if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
 }
@@ -82,6 +89,27 @@ function _nonIterableRest() {
 function _nonIterableSpread() {
   throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
 function _regeneratorRuntime() {
   _regeneratorRuntime = function () {
     return e;
@@ -389,6 +417,20 @@ function _slicedToArray(r, e) {
 function _toConsumableArray(r) {
   return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
 }
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
 function _unsupportedIterableToArray(r, a) {
   if (r) {
     if ("string" == typeof r) return _arrayLikeToArray(r, a);
@@ -1419,7 +1461,7 @@ function snapshot(n, options) {
     });
 }
 
-function on$1(type, fn, target = document) {
+function on(type, fn, target = document) {
     const options = { capture: true, passive: true };
     target.addEventListener(type, fn, options);
     return () => target.removeEventListener(type, fn, options);
@@ -2322,9 +2364,9 @@ function initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {
         trailing: false,
     });
     const handlers = [
-        on$1('mousemove', updatePosition, doc),
-        on$1('touchmove', updatePosition, doc),
-        on$1('drag', updatePosition, doc),
+        on('mousemove', updatePosition, doc),
+        on('touchmove', updatePosition, doc),
+        on('drag', updatePosition, doc),
     ];
     return () => {
         handlers.forEach((h) => h());
@@ -2367,7 +2409,7 @@ function initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockCl
         .forEach((eventKey) => {
         const eventName = eventKey.toLowerCase();
         const handler = getHandler(eventKey);
-        handlers.push(on$1(eventName, handler, doc));
+        handlers.push(on(eventName, handler, doc));
     });
     return () => {
         handlers.forEach((h) => h());
@@ -2396,7 +2438,7 @@ function initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector,
             });
         }
     }, sampling.scroll || 100);
-    return on$1('scroll', updatePosition, doc);
+    return on('scroll', updatePosition, doc);
 }
 function initViewportResizeObserver({ viewportResizeCb, }) {
     let lastH = -1;
@@ -2413,7 +2455,7 @@ function initViewportResizeObserver({ viewportResizeCb, }) {
             lastW = width;
         }
     }, 200);
-    return on$1('resize', updateDimension, window);
+    return on('resize', updateDimension, window);
 }
 function wrapEventWithUserTriggeredFlag(v, enable) {
     const value = Object.assign({}, v);
@@ -2481,7 +2523,7 @@ function initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, ig
         }
     }
     const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];
-    const handlers = events.map((eventName) => on$1(eventName, eventHandler, doc));
+    const handlers = events.map((eventName) => on(eventName, eventHandler, doc));
     const currentWindow = doc.defaultView;
     if (!currentWindow) {
         return () => {
@@ -2775,11 +2817,11 @@ function initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSel
         });
     }, sampling.media || 500);
     const handlers = [
-        on$1('play', handler(0)),
-        on$1('pause', handler(1)),
-        on$1('seeked', handler(2)),
-        on$1('volumechange', handler(3)),
-        on$1('ratechange', handler(4)),
+        on('play', handler(0)),
+        on('pause', handler(1)),
+        on('seeked', handler(2)),
+        on('volumechange', handler(3)),
+        on('ratechange', handler(4)),
     ];
     return () => {
         handlers.forEach((h) => h());
@@ -2853,7 +2895,7 @@ function initSelectionObserver(param) {
         selectionCb({ ranges });
     };
     updateSelection();
-    return on$1('selectionchange', updateSelection);
+    return on('selectionchange', updateSelection);
 }
 function mergeHooks(o, hooks) {
     const { mutationCb, mousemoveCb, mouseInteractionCb, scrollCb, viewportResizeCb, inputCb, mediaInteractionCb, styleSheetRuleCb, styleDeclarationCb, canvasMutationCb, fontCb, selectionCb, } = o;
@@ -3329,9 +3371,9 @@ function __awaiter(thisArg, _arguments, P, generator) {
  */
 var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 // Use a lookup table to find the index.
-var lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
 for (var i = 0; i < chars.length; i++) {
-    lookup$1[chars.charCodeAt(i)] = i;
+    lookup[chars.charCodeAt(i)] = i;
 }
 var encode = function (arraybuffer) {
     var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';
@@ -4174,7 +4216,7 @@ function record(options = {}) {
     };
     try {
         const handlers = [];
-        handlers.push(on$1('DOMContentLoaded', () => {
+        handlers.push(on('DOMContentLoaded', () => {
             wrappedEmit(wrapEvent({
                 type: EventType.DomContentLoaded,
                 data: {},
@@ -4277,7 +4319,7 @@ function record(options = {}) {
             init();
         }
         else {
-            handlers.push(on$1('load', () => {
+            handlers.push(on('load', () => {
                 wrappedEmit(wrapEvent({
                     type: EventType.Load,
                     data: {},
@@ -4317,2250 +4359,334 @@ record.takeFullSnapshot = (isCheckout) => {
 };
 record.mirror = mirror;
 
-/**
- * URL parser.
- *
- * @param uri - url
- * @param path - the request path of the connection
- * @param loc - An object meant to mimic window.location.
- *        Defaults to window.location.
- * @public
- */
-function url(uri, path = "", loc) {
-    let obj = uri;
-    // default to window.location
-    loc = loc || (typeof location !== "undefined" && location);
-    if (null == uri)
-        uri = loc.protocol + "//" + loc.host;
-    // relative path support
-    if (typeof uri === "string") {
-        if ("/" === uri.charAt(0)) {
-            if ("/" === uri.charAt(1)) {
-                uri = loc.protocol + uri;
-            }
-            else {
-                uri = loc.host + uri;
-            }
-        }
-        if (!/^(https?|wss?):\/\//.test(uri)) {
-            if ("undefined" !== typeof loc) {
-                uri = loc.protocol + "//" + uri;
-            }
-            else {
-                uri = "https://" + uri;
-            }
-        }
-        // parse
-        obj = engine_ioClient.parse(uri);
-    }
-    // make sure we treat `localhost:80` and `localhost` equally
-    if (!obj.port) {
-        if (/^(http|ws)$/.test(obj.protocol)) {
-            obj.port = "80";
-        }
-        else if (/^(http|ws)s$/.test(obj.protocol)) {
-            obj.port = "443";
-        }
-    }
-    obj.path = obj.path || "/";
-    const ipv6 = obj.host.indexOf(":") !== -1;
-    const host = ipv6 ? "[" + obj.host + "]" : obj.host;
-    // define unique id
-    obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
-    // define href
-    obj.href =
-        obj.protocol +
-            "://" +
-            host +
-            (loc && loc.port === obj.port ? "" : ":" + obj.port);
-    return obj;
-}
-
-/**
- * Initialize a new `Emitter`.
- *
- * @api public
- */
-
-function Emitter(obj) {
-  if (obj) return mixin(obj);
-}
-
-/**
- * Mixin the emitter properties.
- *
- * @param {Object} obj
- * @return {Object}
- * @api private
- */
-
-function mixin(obj) {
-  for (var key in Emitter.prototype) {
-    obj[key] = Emitter.prototype[key];
+var ANON_ID_KEY = 'co_anon_id';
+var SESSION_ID_KEY = 'co_session_id';
+function getAnonymousId() {
+  var id = localStorage.getItem(ANON_ID_KEY);
+  if (!id) {
+    id = uuid.v4();
+    localStorage.setItem(ANON_ID_KEY, id);
   }
-  return obj;
+  return id;
 }
-
-/**
- * Listen on the given `event` with `fn`.
- *
- * @param {String} event
- * @param {Function} fn
- * @return {Emitter}
- * @api public
- */
-
-Emitter.prototype.on =
-Emitter.prototype.addEventListener = function(event, fn){
-  this._callbacks = this._callbacks || {};
-  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])
-    .push(fn);
-  return this;
-};
-
-/**
- * Adds an `event` listener that will be invoked a single
- * time then automatically removed.
- *
- * @param {String} event
- * @param {Function} fn
- * @return {Emitter}
- * @api public
- */
-
-Emitter.prototype.once = function(event, fn){
-  function on() {
-    this.off(event, on);
-    fn.apply(this, arguments);
+function getSessionId() {
+  var id = sessionStorage.getItem(SESSION_ID_KEY);
+  if (!id) {
+    id = uuid.v4();
+    sessionStorage.setItem(SESSION_ID_KEY, id);
   }
-
-  on.fn = fn;
-  this.on(event, on);
-  return this;
-};
-
-/**
- * Remove the given callback for `event` or all
- * registered callbacks.
- *
- * @param {String} event
- * @param {Function} fn
- * @return {Emitter}
- * @api public
- */
-
-Emitter.prototype.off =
-Emitter.prototype.removeListener =
-Emitter.prototype.removeAllListeners =
-Emitter.prototype.removeEventListener = function(event, fn){
-  this._callbacks = this._callbacks || {};
-
-  // all
-  if (0 == arguments.length) {
-    this._callbacks = {};
-    return this;
-  }
-
-  // specific event
-  var callbacks = this._callbacks['$' + event];
-  if (!callbacks) return this;
-
-  // remove all handlers
-  if (1 == arguments.length) {
-    delete this._callbacks['$' + event];
-    return this;
-  }
-
-  // remove specific handler
-  var cb;
-  for (var i = 0; i < callbacks.length; i++) {
-    cb = callbacks[i];
-    if (cb === fn || cb.fn === fn) {
-      callbacks.splice(i, 1);
-      break;
-    }
-  }
-
-  // Remove event specific arrays for event types that no
-  // one is subscribed for to avoid memory leak.
-  if (callbacks.length === 0) {
-    delete this._callbacks['$' + event];
-  }
-
-  return this;
-};
-
-/**
- * Emit `event` with the given args.
- *
- * @param {String} event
- * @param {Mixed} ...
- * @return {Emitter}
- */
-
-Emitter.prototype.emit = function(event){
-  this._callbacks = this._callbacks || {};
-
-  var args = new Array(arguments.length - 1)
-    , callbacks = this._callbacks['$' + event];
-
-  for (var i = 1; i < arguments.length; i++) {
-    args[i - 1] = arguments[i];
-  }
-
-  if (callbacks) {
-    callbacks = callbacks.slice(0);
-    for (var i = 0, len = callbacks.length; i < len; ++i) {
-      callbacks[i].apply(this, args);
-    }
-  }
-
-  return this;
-};
-
-// alias used for reserved events (protected method)
-Emitter.prototype.emitReserved = Emitter.prototype.emit;
-
-/**
- * Return array of callbacks for `event`.
- *
- * @param {String} event
- * @return {Array}
- * @api public
- */
-
-Emitter.prototype.listeners = function(event){
-  this._callbacks = this._callbacks || {};
-  return this._callbacks['$' + event] || [];
-};
-
-/**
- * Check if this emitter has `event` handlers.
- *
- * @param {String} event
- * @return {Boolean}
- * @api public
- */
-
-Emitter.prototype.hasListeners = function(event){
-  return !! this.listeners(event).length;
-};
-
-const withNativeArrayBuffer = typeof ArrayBuffer === "function";
-const isView = (obj) => {
-    return typeof ArrayBuffer.isView === "function"
-        ? ArrayBuffer.isView(obj)
-        : obj.buffer instanceof ArrayBuffer;
-};
-const toString = Object.prototype.toString;
-const withNativeBlob = typeof Blob === "function" ||
-    (typeof Blob !== "undefined" &&
-        toString.call(Blob) === "[object BlobConstructor]");
-const withNativeFile = typeof File === "function" ||
-    (typeof File !== "undefined" &&
-        toString.call(File) === "[object FileConstructor]");
-/**
- * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
- *
- * @private
- */
-function isBinary(obj) {
-    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||
-        (withNativeBlob && obj instanceof Blob) ||
-        (withNativeFile && obj instanceof File));
+  return id;
 }
-function hasBinary(obj, toJSON) {
-    if (!obj || typeof obj !== "object") {
-        return false;
-    }
-    if (Array.isArray(obj)) {
-        for (let i = 0, l = obj.length; i < l; i++) {
-            if (hasBinary(obj[i])) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if (isBinary(obj)) {
-        return true;
-    }
-    if (obj.toJSON &&
-        typeof obj.toJSON === "function" &&
-        arguments.length === 1) {
-        return hasBinary(obj.toJSON(), true);
-    }
-    for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
-            return true;
-        }
-    }
-    return false;
+function getUtmParams() {
+  var params = new URLSearchParams(window.location.search);
+  return {
+    utm_source: params.get('utm_source') || undefined,
+    utm_medium: params.get('utm_medium') || undefined,
+    utm_campaign: params.get('utm_campaign') || undefined,
+    utm_term: params.get('utm_term') || undefined,
+    utm_content: params.get('utm_content') || undefined
+  };
 }
-
-/**
- * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
- *
- * @param {Object} packet - socket.io event packet
- * @return {Object} with deconstructed packet and list of buffers
- * @public
- */
-function deconstructPacket(packet) {
-    const buffers = [];
-    const packetData = packet.data;
-    const pack = packet;
-    pack.data = _deconstructPacket(packetData, buffers);
-    pack.attachments = buffers.length; // number of binary 'attachments'
-    return { packet: pack, buffers: buffers };
+function detectDeviceType() {
+  var ua = navigator.userAgent;
+  if (/Mobi|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua)) {
+    if (/iPad|Tablet/i.test(ua)) return 'tablet';
+    return 'mobile';
+  }
+  return 'desktop';
 }
-function _deconstructPacket(data, buffers) {
-    if (!data)
-        return data;
-    if (isBinary(data)) {
-        const placeholder = { _placeholder: true, num: buffers.length };
-        buffers.push(data);
-        return placeholder;
-    }
-    else if (Array.isArray(data)) {
-        const newData = new Array(data.length);
-        for (let i = 0; i < data.length; i++) {
-            newData[i] = _deconstructPacket(data[i], buffers);
-        }
-        return newData;
-    }
-    else if (typeof data === "object" && !(data instanceof Date)) {
-        const newData = {};
-        for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
-                newData[key] = _deconstructPacket(data[key], buffers);
-            }
-        }
-        return newData;
-    }
-    return data;
+function detectOS() {
+  var ua = navigator.userAgent;
+  if (/iPhone|iPad|iPod/i.test(ua)) return 'iOS';
+  if (/Android/i.test(ua)) return 'Android';
+  if (/Win/i.test(ua)) return 'Windows';
+  if (/Mac/i.test(ua)) return 'macOS';
+  if (/Linux/i.test(ua)) return 'Linux';
+  return 'Other';
 }
-/**
- * Reconstructs a binary packet from its placeholder packet and buffers
- *
- * @param {Object} packet - event packet with placeholders
- * @param {Array} buffers - binary buffers to put in placeholder positions
- * @return {Object} reconstructed packet
- * @public
- */
-function reconstructPacket(packet, buffers) {
-    packet.data = _reconstructPacket(packet.data, buffers);
-    delete packet.attachments; // no longer useful
-    return packet;
+function getBrowserName() {
+  var ua = navigator.userAgent;
+  if (ua.indexOf('Firefox') > -1) return 'Firefox';
+  if (ua.indexOf('Opera') > -1 || ua.indexOf('OPR') > -1) return 'Opera';
+  if (ua.indexOf('Chrome') > -1) return 'Chrome';
+  if (ua.indexOf('Safari') > -1) return 'Safari';
+  if (ua.indexOf('MSIE') > -1 || ua.indexOf('Trident/') > -1) return 'IE';
+  return 'Unknown';
 }
-function _reconstructPacket(data, buffers) {
-    if (!data)
-        return data;
-    if (data && data._placeholder === true) {
-        const isIndexValid = typeof data.num === "number" &&
-            data.num >= 0 &&
-            data.num < buffers.length;
-        if (isIndexValid) {
-            return buffers[data.num]; // appropriate buffer (should be natural order anyway)
-        }
-        else {
-            throw new Error("illegal attachments");
-        }
-    }
-    else if (Array.isArray(data)) {
-        for (let i = 0; i < data.length; i++) {
-            data[i] = _reconstructPacket(data[i], buffers);
-        }
-    }
-    else if (typeof data === "object") {
-        for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
-                data[key] = _reconstructPacket(data[key], buffers);
-            }
-        }
-    }
-    return data;
+function getPagePath() {
+  return window.location.pathname;
 }
 
-/**
- * These strings must not be used as event names, as they have a special meaning.
- */
-const RESERVED_EVENTS$1 = [
-    "connect",
-    "connect_error",
-    "disconnect",
-    "disconnecting",
-    "newListener",
-    "removeListener", // used by the Node.js EventEmitter
-];
-/**
- * Protocol version.
- *
- * @public
- */
-const protocol = 5;
-var PacketType;
-(function (PacketType) {
-    PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
-    PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
-    PacketType[PacketType["EVENT"] = 2] = "EVENT";
-    PacketType[PacketType["ACK"] = 3] = "ACK";
-    PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
-    PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
-    PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
-})(PacketType || (PacketType = {}));
-/**
- * A socket.io Encoder instance
- */
-class Encoder {
-    /**
-     * Encoder constructor
-     *
-     * @param {function} replacer - custom replacer to pass down to JSON.parse
-     */
-    constructor(replacer) {
-        this.replacer = replacer;
-    }
-    /**
-     * Encode a packet as a single string if non-binary, or as a
-     * buffer sequence, depending on packet type.
-     *
-     * @param {Object} obj - packet object
-     */
-    encode(obj) {
-        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
-            if (hasBinary(obj)) {
-                return this.encodeAsBinary({
-                    type: obj.type === PacketType.EVENT
-                        ? PacketType.BINARY_EVENT
-                        : PacketType.BINARY_ACK,
-                    nsp: obj.nsp,
-                    data: obj.data,
-                    id: obj.id,
-                });
-            }
-        }
-        return [this.encodeAsString(obj)];
-    }
-    /**
-     * Encode packet as string.
-     */
-    encodeAsString(obj) {
-        // first is type
-        let str = "" + obj.type;
-        // attachments if we have them
-        if (obj.type === PacketType.BINARY_EVENT ||
-            obj.type === PacketType.BINARY_ACK) {
-            str += obj.attachments + "-";
-        }
-        // if we have a namespace other than `/`
-        // we append it followed by a comma `,`
-        if (obj.nsp && "/" !== obj.nsp) {
-            str += obj.nsp + ",";
-        }
-        // immediately followed by the id
-        if (null != obj.id) {
-            str += obj.id;
-        }
-        // json data
-        if (null != obj.data) {
-            str += JSON.stringify(obj.data, this.replacer);
-        }
-        return str;
-    }
-    /**
-     * Encode packet as 'buffer sequence' by removing blobs, and
-     * deconstructing packet into object with placeholders and
-     * a list of buffers.
-     */
-    encodeAsBinary(obj) {
-        const deconstruction = deconstructPacket(obj);
-        const pack = this.encodeAsString(deconstruction.packet);
-        const buffers = deconstruction.buffers;
-        buffers.unshift(pack); // add packet info to beginning of data list
-        return buffers; // write all the buffers
-    }
-}
-// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript
-function isObject(value) {
-    return Object.prototype.toString.call(value) === "[object Object]";
-}
-/**
- * A socket.io Decoder instance
- *
- * @return {Object} decoder
- */
-class Decoder extends Emitter {
-    /**
-     * Decoder constructor
-     *
-     * @param {function} reviver - custom reviver to pass down to JSON.stringify
-     */
-    constructor(reviver) {
-        super();
-        this.reviver = reviver;
-    }
-    /**
-     * Decodes an encoded packet string into packet JSON.
-     *
-     * @param {String} obj - encoded packet
-     */
-    add(obj) {
-        let packet;
-        if (typeof obj === "string") {
-            if (this.reconstructor) {
-                throw new Error("got plaintext data when reconstructing a packet");
-            }
-            packet = this.decodeString(obj);
-            const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
-            if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
-                packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
-                // binary packet's json
-                this.reconstructor = new BinaryReconstructor(packet);
-                // no attachments, labeled binary but no binary data to follow
-                if (packet.attachments === 0) {
-                    super.emitReserved("decoded", packet);
-                }
-            }
-            else {
-                // non-binary full packet
-                super.emitReserved("decoded", packet);
-            }
-        }
-        else if (isBinary(obj) || obj.base64) {
-            // raw binary data
-            if (!this.reconstructor) {
-                throw new Error("got binary data when not reconstructing a packet");
-            }
-            else {
-                packet = this.reconstructor.takeBinaryData(obj);
-                if (packet) {
-                    // received final buffer
-                    this.reconstructor = null;
-                    super.emitReserved("decoded", packet);
-                }
-            }
-        }
-        else {
-            throw new Error("Unknown type: " + obj);
-        }
-    }
-    /**
-     * Decode a packet String (JSON data)
-     *
-     * @param {String} str
-     * @return {Object} packet
-     */
-    decodeString(str) {
-        let i = 0;
-        // look up type
-        const p = {
-            type: Number(str.charAt(0)),
-        };
-        if (PacketType[p.type] === undefined) {
-            throw new Error("unknown packet type " + p.type);
-        }
-        // look up attachments if type binary
-        if (p.type === PacketType.BINARY_EVENT ||
-            p.type === PacketType.BINARY_ACK) {
-            const start = i + 1;
-            while (str.charAt(++i) !== "-" && i != str.length) { }
-            const buf = str.substring(start, i);
-            if (buf != Number(buf) || str.charAt(i) !== "-") {
-                throw new Error("Illegal attachments");
-            }
-            p.attachments = Number(buf);
-        }
-        // look up namespace (if any)
-        if ("/" === str.charAt(i + 1)) {
-            const start = i + 1;
-            while (++i) {
-                const c = str.charAt(i);
-                if ("," === c)
-                    break;
-                if (i === str.length)
-                    break;
-            }
-            p.nsp = str.substring(start, i);
-        }
-        else {
-            p.nsp = "/";
-        }
-        // look up id
-        const next = str.charAt(i + 1);
-        if ("" !== next && Number(next) == next) {
-            const start = i + 1;
-            while (++i) {
-                const c = str.charAt(i);
-                if (null == c || Number(c) != c) {
-                    --i;
-                    break;
-                }
-                if (i === str.length)
-                    break;
-            }
-            p.id = Number(str.substring(start, i + 1));
-        }
-        // look up json data
-        if (str.charAt(++i)) {
-            const payload = this.tryParse(str.substr(i));
-            if (Decoder.isPayloadValid(p.type, payload)) {
-                p.data = payload;
-            }
-            else {
-                throw new Error("invalid payload");
-            }
-        }
-        return p;
-    }
-    tryParse(str) {
-        try {
-            return JSON.parse(str, this.reviver);
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    static isPayloadValid(type, payload) {
-        switch (type) {
-            case PacketType.CONNECT:
-                return isObject(payload);
-            case PacketType.DISCONNECT:
-                return payload === undefined;
-            case PacketType.CONNECT_ERROR:
-                return typeof payload === "string" || isObject(payload);
-            case PacketType.EVENT:
-            case PacketType.BINARY_EVENT:
-                return (Array.isArray(payload) &&
-                    (typeof payload[0] === "number" ||
-                        (typeof payload[0] === "string" &&
-                            RESERVED_EVENTS$1.indexOf(payload[0]) === -1)));
-            case PacketType.ACK:
-            case PacketType.BINARY_ACK:
-                return Array.isArray(payload);
-        }
-    }
-    /**
-     * Deallocates a parser's resources
-     */
-    destroy() {
-        if (this.reconstructor) {
-            this.reconstructor.finishedReconstruction();
-            this.reconstructor = null;
-        }
-    }
+var INGEST_BASE = 'https://atlas-orchestrator.atlas.coreoutline.com';
+var FLUSH_INTERVAL_MS = 5000;
+var _token = null;
+var _warehouseId = null;
+var _organizationId = null;
+var _dataSourceId = null;
+var _buffer = [];
+var _flushInterval = null;
+function initIngest(_x, _x2, _x3) {
+  return _initIngest.apply(this, arguments);
 }
-/**
- * A manager of a binary event's 'buffer sequence'. Should
- * be constructed whenever a packet of type BINARY_EVENT is
- * decoded.
- *
- * @param {Object} packet
- * @return {BinaryReconstructor} initialized reconstructor
- */
-class BinaryReconstructor {
-    constructor(packet) {
-        this.packet = packet;
-        this.buffers = [];
-        this.reconPack = packet;
-    }
-    /**
-     * Method to be called when binary data received from connection
-     * after a BINARY_EVENT packet.
-     *
-     * @param {Buffer | ArrayBuffer} binData - the raw binary data received
-     * @return {null | Object} returns null if more binary data is expected or
-     *   a reconstructed packet object if all buffers have been received.
-     */
-    takeBinaryData(binData) {
-        this.buffers.push(binData);
-        if (this.buffers.length === this.reconPack.attachments) {
-            // done with buffer list
-            const packet = reconstructPacket(this.reconPack, this.buffers);
-            this.finishedReconstruction();
-            return packet;
-        }
-        return null;
-    }
-    /**
-     * Cleans up binary packet reconstruction variables.
-     */
-    finishedReconstruction() {
-        this.reconPack = null;
-        this.buffers = [];
-    }
+function _initIngest() {
+  _initIngest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(warehouseId, dataSourceId, dataSourceSecret) {
+    var res, data;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _warehouseId = warehouseId;
+          _dataSourceId = dataSourceId;
+          _context.prev = 2;
+          _context.next = 5;
+          return fetch("".concat(INGEST_BASE, "/api/ingest/authorize"), {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              warehouse_id: warehouseId,
+              data_source_id: dataSourceId,
+              data_source_secret: dataSourceSecret
+            })
+          });
+        case 5:
+          res = _context.sent;
+          if (res.ok) {
+            _context.next = 9;
+            break;
+          }
+          console.error('[CoreOutline] Authorization failed:', res.status);
+          return _context.abrupt("return", false);
+        case 9:
+          _context.next = 11;
+          return res.json();
+        case 11:
+          data = _context.sent;
+          _token = data.access_token;
+          _organizationId = data.organization_id;
+          return _context.abrupt("return", true);
+        case 17:
+          _context.prev = 17;
+          _context.t0 = _context["catch"](2);
+          console.error('[CoreOutline] Authorization error:', _context.t0);
+          return _context.abrupt("return", false);
+        case 21:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 17]]);
+  }));
+  return _initIngest.apply(this, arguments);
 }
-
-var parser = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  protocol: protocol,
-  get PacketType () { return PacketType; },
-  Encoder: Encoder,
-  Decoder: Decoder
-});
-
-function on(obj, ev, fn) {
-    obj.on(ev, fn);
-    return function subDestroy() {
-        obj.off(ev, fn);
-    };
+function trackEvent(eventType, payload) {
+  if (!_token) return;
+  var event = _objectSpread2({
+    event_id: uuid.v4(),
+    event_type: eventType,
+    event_ts: new Date().toISOString()
+  }, payload);
+  _buffer.push(event);
+  if (!_flushInterval) {
+    _flushInterval = setInterval(flush, FLUSH_INTERVAL_MS);
+  }
 }
-
-/**
- * Internal events.
- * These events can't be emitted by the user.
- */
-const RESERVED_EVENTS = Object.freeze({
-    connect: 1,
-    connect_error: 1,
-    disconnect: 1,
-    disconnecting: 1,
-    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
-    newListener: 1,
-    removeListener: 1,
-});
-/**
- * A Socket is the fundamental class for interacting with the server.
- *
- * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
- *
- * @example
- * const socket = io();
- *
- * socket.on("connect", () => {
- *   console.log("connected");
- * });
- *
- * // send an event to the server
- * socket.emit("foo", "bar");
- *
- * socket.on("foobar", () => {
- *   // an event was received from the server
- * });
- *
- * // upon disconnection
- * socket.on("disconnect", (reason) => {
- *   console.log(`disconnected due to ${reason}`);
- * });
- */
-class Socket extends Emitter {
-    /**
-     * `Socket` constructor.
-     */
-    constructor(io, nsp, opts) {
-        super();
-        /**
-         * Whether the socket is currently connected to the server.
-         *
-         * @example
-         * const socket = io();
-         *
-         * socket.on("connect", () => {
-         *   console.log(socket.connected); // true
-         * });
-         *
-         * socket.on("disconnect", () => {
-         *   console.log(socket.connected); // false
-         * });
-         */
-        this.connected = false;
-        /**
-         * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
-         * be transmitted by the server.
-         */
-        this.recovered = false;
-        /**
-         * Buffer for packets received before the CONNECT packet
-         */
-        this.receiveBuffer = [];
-        /**
-         * Buffer for packets that will be sent once the socket is connected
-         */
-        this.sendBuffer = [];
-        /**
-         * The queue of packets to be sent with retry in case of failure.
-         *
-         * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.
-         * @private
-         */
-        this._queue = [];
-        /**
-         * A sequence to generate the ID of the {@link QueuedPacket}.
-         * @private
-         */
-        this._queueSeq = 0;
-        this.ids = 0;
-        /**
-         * A map containing acknowledgement handlers.
-         *
-         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:
-         *
-         * - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
-         * - `socket.timeout(5000).emit("test", (err, value) => { ... })`
-         * - `const value = await socket.emitWithAck("test")`
-         *
-         * From those that don't:
-         *
-         * - `socket.emit("test", (value) => { ... });`
-         *
-         * In the first case, the handlers will be called with an error when:
-         *
-         * - the timeout is reached
-         * - the socket gets disconnected
-         *
-         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
-         * an acknowledgement from the server.
-         *
-         * @private
-         */
-        this.acks = {};
-        this.flags = {};
-        this.io = io;
-        this.nsp = nsp;
-        if (opts && opts.auth) {
-            this.auth = opts.auth;
-        }
-        this._opts = Object.assign({}, opts);
-        if (this.io._autoConnect)
-            this.open();
-    }
-    /**
-     * Whether the socket is currently disconnected
-     *
-     * @example
-     * const socket = io();
-     *
-     * socket.on("connect", () => {
-     *   console.log(socket.disconnected); // false
-     * });
-     *
-     * socket.on("disconnect", () => {
-     *   console.log(socket.disconnected); // true
-     * });
-     */
-    get disconnected() {
-        return !this.connected;
-    }
-    /**
-     * Subscribe to open, close and packet events
-     *
-     * @private
-     */
-    subEvents() {
-        if (this.subs)
-            return;
-        const io = this.io;
-        this.subs = [
-            on(io, "open", this.onopen.bind(this)),
-            on(io, "packet", this.onpacket.bind(this)),
-            on(io, "error", this.onerror.bind(this)),
-            on(io, "close", this.onclose.bind(this)),
-        ];
-    }
-    /**
-     * Whether the Socket will try to reconnect when its Manager connects or reconnects.
-     *
-     * @example
-     * const socket = io();
-     *
-     * console.log(socket.active); // true
-     *
-     * socket.on("disconnect", (reason) => {
-     *   if (reason === "io server disconnect") {
-     *     // the disconnection was initiated by the server, you need to manually reconnect
-     *     console.log(socket.active); // false
-     *   }
-     *   // else the socket will automatically try to reconnect
-     *   console.log(socket.active); // true
-     * });
-     */
-    get active() {
-        return !!this.subs;
-    }
-    /**
-     * "Opens" the socket.
-     *
-     * @example
-     * const socket = io({
-     *   autoConnect: false
-     * });
-     *
-     * socket.connect();
-     */
-    connect() {
-        if (this.connected)
-            return this;
-        this.subEvents();
-        if (!this.io["_reconnecting"])
-            this.io.open(); // ensure open
-        if ("open" === this.io._readyState)
-            this.onopen();
-        return this;
-    }
-    /**
-     * Alias for {@link connect()}.
-     */
-    open() {
-        return this.connect();
-    }
-    /**
-     * Sends a `message` event.
-     *
-     * This method mimics the WebSocket.send() method.
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
-     *
-     * @example
-     * socket.send("hello");
-     *
-     * // this is equivalent to
-     * socket.emit("message", "hello");
-     *
-     * @return self
-     */
-    send(...args) {
-        args.unshift("message");
-        this.emit.apply(this, args);
-        return this;
-    }
-    /**
-     * Override `emit`.
-     * If the event is in `events`, it's emitted normally.
-     *
-     * @example
-     * socket.emit("hello", "world");
-     *
-     * // all serializable datastructures are supported (no need to call JSON.stringify)
-     * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
-     *
-     * // with an acknowledgement from the server
-     * socket.emit("hello", "world", (val) => {
-     *   // ...
-     * });
-     *
-     * @return self
-     */
-    emit(ev, ...args) {
-        var _a, _b, _c;
-        if (RESERVED_EVENTS.hasOwnProperty(ev)) {
-            throw new Error('"' + ev.toString() + '" is a reserved event name');
-        }
-        args.unshift(ev);
-        if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
-            this._addToQueue(args);
-            return this;
-        }
-        const packet = {
-            type: PacketType.EVENT,
-            data: args,
-        };
-        packet.options = {};
-        packet.options.compress = this.flags.compress !== false;
-        // event ack callback
-        if ("function" === typeof args[args.length - 1]) {
-            const id = this.ids++;
-            const ack = args.pop();
-            this._registerAckCallback(id, ack);
-            packet.id = id;
-        }
-        const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
-        const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
-        const discardPacket = this.flags.volatile && !isTransportWritable;
-        if (discardPacket) ;
-        else if (isConnected) {
-            this.notifyOutgoingListeners(packet);
-            this.packet(packet);
-        }
-        else {
-            this.sendBuffer.push(packet);
-        }
-        this.flags = {};
-        return this;
-    }
-    /**
-     * @private
-     */
-    _registerAckCallback(id, ack) {
-        var _a;
-        const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
-        if (timeout === undefined) {
-            this.acks[id] = ack;
-            return;
-        }
-        // @ts-ignore
-        const timer = this.io.setTimeoutFn(() => {
-            delete this.acks[id];
-            for (let i = 0; i < this.sendBuffer.length; i++) {
-                if (this.sendBuffer[i].id === id) {
-                    this.sendBuffer.splice(i, 1);
-                }
-            }
-            ack.call(this, new Error("operation has timed out"));
-        }, timeout);
-        const fn = (...args) => {
-            // @ts-ignore
-            this.io.clearTimeoutFn(timer);
-            ack.apply(this, args);
-        };
-        fn.withError = true;
-        this.acks[id] = fn;
-    }
-    /**
-     * Emits an event and waits for an acknowledgement
-     *
-     * @example
-     * // without timeout
-     * const response = await socket.emitWithAck("hello", "world");
-     *
-     * // with a specific timeout
-     * try {
-     *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
-     * } catch (err) {
-     *   // the server did not acknowledge the event in the given delay
-     * }
-     *
-     * @return a Promise that will be fulfilled when the server acknowledges the event
-     */
-    emitWithAck(ev, ...args) {
-        return new Promise((resolve, reject) => {
-            const fn = (arg1, arg2) => {
-                return arg1 ? reject(arg1) : resolve(arg2);
-            };
-            fn.withError = true;
-            args.push(fn);
-            this.emit(ev, ...args);
-        });
-    }
-    /**
-     * Add the packet to the queue.
-     * @param args
-     * @private
-     */
-    _addToQueue(args) {
-        let ack;
-        if (typeof args[args.length - 1] === "function") {
-            ack = args.pop();
-        }
-        const packet = {
-            id: this._queueSeq++,
-            tryCount: 0,
-            pending: false,
-            args,
-            flags: Object.assign({ fromQueue: true }, this.flags),
-        };
-        args.push((err, ...responseArgs) => {
-            if (packet !== this._queue[0]) {
-                // the packet has already been acknowledged
-                return;
-            }
-            const hasError = err !== null;
-            if (hasError) {
-                if (packet.tryCount > this._opts.retries) {
-                    this._queue.shift();
-                    if (ack) {
-                        ack(err);
-                    }
-                }
-            }
-            else {
-                this._queue.shift();
-                if (ack) {
-                    ack(null, ...responseArgs);
-                }
-            }
-            packet.pending = false;
-            return this._drainQueue();
-        });
-        this._queue.push(packet);
-        this._drainQueue();
-    }
-    /**
-     * Send the first packet of the queue, and wait for an acknowledgement from the server.
-     * @param force - whether to resend a packet that has not been acknowledged yet
-     *
-     * @private
-     */
-    _drainQueue(force = false) {
-        if (!this.connected || this._queue.length === 0) {
-            return;
-        }
-        const packet = this._queue[0];
-        if (packet.pending && !force) {
-            return;
-        }
-        packet.pending = true;
-        packet.tryCount++;
-        this.flags = packet.flags;
-        this.emit.apply(this, packet.args);
-    }
-    /**
-     * Sends a packet.
-     *
-     * @param packet
-     * @private
-     */
-    packet(packet) {
-        packet.nsp = this.nsp;
-        this.io._packet(packet);
-    }
-    /**
-     * Called upon engine `open`.
-     *
-     * @private
-     */
-    onopen() {
-        if (typeof this.auth == "function") {
-            this.auth((data) => {
-                this._sendConnectPacket(data);
-            });
-        }
-        else {
-            this._sendConnectPacket(this.auth);
-        }
-    }
-    /**
-     * Sends a CONNECT packet to initiate the Socket.IO session.
-     *
-     * @param data
-     * @private
-     */
-    _sendConnectPacket(data) {
-        this.packet({
-            type: PacketType.CONNECT,
-            data: this._pid
-                ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
-                : data,
-        });
-    }
-    /**
-     * Called upon engine or manager `error`.
-     *
-     * @param err
-     * @private
-     */
-    onerror(err) {
-        if (!this.connected) {
-            this.emitReserved("connect_error", err);
-        }
-    }
-    /**
-     * Called upon engine `close`.
-     *
-     * @param reason
-     * @param description
-     * @private
-     */
-    onclose(reason, description) {
-        this.connected = false;
-        delete this.id;
-        this.emitReserved("disconnect", reason, description);
-        this._clearAcks();
-    }
-    /**
-     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
-     * the server.
-     *
-     * @private
-     */
-    _clearAcks() {
-        Object.keys(this.acks).forEach((id) => {
-            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
-            if (!isBuffered) {
-                // note: handlers that do not accept an error as first argument are ignored here
-                const ack = this.acks[id];
-                delete this.acks[id];
-                if (ack.withError) {
-                    ack.call(this, new Error("socket has been disconnected"));
-                }
-            }
-        });
-    }
-    /**
-     * Called with socket packet.
-     *
-     * @param packet
-     * @private
-     */
-    onpacket(packet) {
-        const sameNamespace = packet.nsp === this.nsp;
-        if (!sameNamespace)
-            return;
-        switch (packet.type) {
-            case PacketType.CONNECT:
-                if (packet.data && packet.data.sid) {
-                    this.onconnect(packet.data.sid, packet.data.pid);
-                }
-                else {
-                    this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
-                }
-                break;
-            case PacketType.EVENT:
-            case PacketType.BINARY_EVENT:
-                this.onevent(packet);
-                break;
-            case PacketType.ACK:
-            case PacketType.BINARY_ACK:
-                this.onack(packet);
-                break;
-            case PacketType.DISCONNECT:
-                this.ondisconnect();
-                break;
-            case PacketType.CONNECT_ERROR:
-                this.destroy();
-                const err = new Error(packet.data.message);
-                // @ts-ignore
-                err.data = packet.data.data;
-                this.emitReserved("connect_error", err);
-                break;
-        }
-    }
-    /**
-     * Called upon a server event.
-     *
-     * @param packet
-     * @private
-     */
-    onevent(packet) {
-        const args = packet.data || [];
-        if (null != packet.id) {
-            args.push(this.ack(packet.id));
-        }
-        if (this.connected) {
-            this.emitEvent(args);
-        }
-        else {
-            this.receiveBuffer.push(Object.freeze(args));
-        }
-    }
-    emitEvent(args) {
-        if (this._anyListeners && this._anyListeners.length) {
-            const listeners = this._anyListeners.slice();
-            for (const listener of listeners) {
-                listener.apply(this, args);
-            }
-        }
-        super.emit.apply(this, args);
-        if (this._pid && args.length && typeof args[args.length - 1] === "string") {
-            this._lastOffset = args[args.length - 1];
-        }
-    }
-    /**
-     * Produces an ack callback to emit with an event.
-     *
-     * @private
-     */
-    ack(id) {
-        const self = this;
-        let sent = false;
-        return function (...args) {
-            // prevent double callbacks
-            if (sent)
-                return;
-            sent = true;
-            self.packet({
-                type: PacketType.ACK,
-                id: id,
-                data: args,
-            });
-        };
-    }
-    /**
-     * Called upon a server acknowledgement.
-     *
-     * @param packet
-     * @private
-     */
-    onack(packet) {
-        const ack = this.acks[packet.id];
-        if (typeof ack !== "function") {
-            return;
-        }
-        delete this.acks[packet.id];
-        // @ts-ignore FIXME ack is incorrectly inferred as 'never'
-        if (ack.withError) {
-            packet.data.unshift(null);
-        }
-        // @ts-ignore
-        ack.apply(this, packet.data);
-    }
-    /**
-     * Called upon server connect.
-     *
-     * @private
-     */
-    onconnect(id, pid) {
-        this.id = id;
-        this.recovered = pid && this._pid === pid;
-        this._pid = pid; // defined only if connection state recovery is enabled
-        this.connected = true;
-        this.emitBuffered();
-        this.emitReserved("connect");
-        this._drainQueue(true);
-    }
-    /**
-     * Emit buffered events (received and emitted).
-     *
-     * @private
-     */
-    emitBuffered() {
-        this.receiveBuffer.forEach((args) => this.emitEvent(args));
-        this.receiveBuffer = [];
-        this.sendBuffer.forEach((packet) => {
-            this.notifyOutgoingListeners(packet);
-            this.packet(packet);
-        });
-        this.sendBuffer = [];
-    }
-    /**
-     * Called upon server disconnect.
-     *
-     * @private
-     */
-    ondisconnect() {
-        this.destroy();
-        this.onclose("io server disconnect");
-    }
-    /**
-     * Called upon forced client/server side disconnections,
-     * this method ensures the manager stops tracking us and
-     * that reconnections don't get triggered for this.
-     *
-     * @private
-     */
-    destroy() {
-        if (this.subs) {
-            // clean subscriptions to avoid reconnections
-            this.subs.forEach((subDestroy) => subDestroy());
-            this.subs = undefined;
-        }
-        this.io["_destroy"](this);
-    }
-    /**
-     * Disconnects the socket manually. In that case, the socket will not try to reconnect.
-     *
-     * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
-     *
-     * @example
-     * const socket = io();
-     *
-     * socket.on("disconnect", (reason) => {
-     *   // console.log(reason); prints "io client disconnect"
-     * });
-     *
-     * socket.disconnect();
-     *
-     * @return self
-     */
-    disconnect() {
-        if (this.connected) {
-            this.packet({ type: PacketType.DISCONNECT });
-        }
-        // remove socket from pool
-        this.destroy();
-        if (this.connected) {
-            // fire events
-            this.onclose("io client disconnect");
-        }
-        return this;
-    }
-    /**
-     * Alias for {@link disconnect()}.
-     *
-     * @return self
-     */
-    close() {
-        return this.disconnect();
-    }
-    /**
-     * Sets the compress flag.
-     *
-     * @example
-     * socket.compress(false).emit("hello");
-     *
-     * @param compress - if `true`, compresses the sending data
-     * @return self
-     */
-    compress(compress) {
-        this.flags.compress = compress;
-        return this;
-    }
-    /**
-     * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
-     * ready to send messages.
-     *
-     * @example
-     * socket.volatile.emit("hello"); // the server may or may not receive it
-     *
-     * @returns self
-     */
-    get volatile() {
-        this.flags.volatile = true;
-        return this;
-    }
-    /**
-     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
-     * given number of milliseconds have elapsed without an acknowledgement from the server:
-     *
-     * @example
-     * socket.timeout(5000).emit("my-event", (err) => {
-     *   if (err) {
-     *     // the server did not acknowledge the event in the given delay
-     *   }
-     * });
-     *
-     * @returns self
-     */
-    timeout(timeout) {
-        this.flags.timeout = timeout;
-        return this;
-    }
-    /**
-     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
-     * callback.
-     *
-     * @example
-     * socket.onAny((event, ...args) => {
-     *   console.log(`got ${event}`);
-     * });
-     *
-     * @param listener
-     */
-    onAny(listener) {
-        this._anyListeners = this._anyListeners || [];
-        this._anyListeners.push(listener);
-        return this;
-    }
-    /**
-     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
-     * callback. The listener is added to the beginning of the listeners array.
-     *
-     * @example
-     * socket.prependAny((event, ...args) => {
-     *   console.log(`got event ${event}`);
-     * });
-     *
-     * @param listener
-     */
-    prependAny(listener) {
-        this._anyListeners = this._anyListeners || [];
-        this._anyListeners.unshift(listener);
-        return this;
-    }
-    /**
-     * Removes the listener that will be fired when any event is emitted.
-     *
-     * @example
-     * const catchAllListener = (event, ...args) => {
-     *   console.log(`got event ${event}`);
-     * }
-     *
-     * socket.onAny(catchAllListener);
-     *
-     * // remove a specific listener
-     * socket.offAny(catchAllListener);
-     *
-     * // or remove all listeners
-     * socket.offAny();
-     *
-     * @param listener
-     */
-    offAny(listener) {
-        if (!this._anyListeners) {
-            return this;
-        }
-        if (listener) {
-            const listeners = this._anyListeners;
-            for (let i = 0; i < listeners.length; i++) {
-                if (listener === listeners[i]) {
-                    listeners.splice(i, 1);
-                    return this;
-                }
-            }
-        }
-        else {
-            this._anyListeners = [];
-        }
-        return this;
-    }
-    /**
-     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
-     * e.g. to remove listeners.
-     */
-    listenersAny() {
-        return this._anyListeners || [];
-    }
-    /**
-     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
-     * callback.
-     *
-     * Note: acknowledgements sent to the server are not included.
-     *
-     * @example
-     * socket.onAnyOutgoing((event, ...args) => {
-     *   console.log(`sent event ${event}`);
-     * });
-     *
-     * @param listener
-     */
-    onAnyOutgoing(listener) {
-        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
-        this._anyOutgoingListeners.push(listener);
-        return this;
-    }
-    /**
-     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
-     * callback. The listener is added to the beginning of the listeners array.
-     *
-     * Note: acknowledgements sent to the server are not included.
-     *
-     * @example
-     * socket.prependAnyOutgoing((event, ...args) => {
-     *   console.log(`sent event ${event}`);
-     * });
-     *
-     * @param listener
-     */
-    prependAnyOutgoing(listener) {
-        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
-        this._anyOutgoingListeners.unshift(listener);
-        return this;
-    }
-    /**
-     * Removes the listener that will be fired when any event is emitted.
-     *
-     * @example
-     * const catchAllListener = (event, ...args) => {
-     *   console.log(`sent event ${event}`);
-     * }
-     *
-     * socket.onAnyOutgoing(catchAllListener);
-     *
-     * // remove a specific listener
-     * socket.offAnyOutgoing(catchAllListener);
-     *
-     * // or remove all listeners
-     * socket.offAnyOutgoing();
-     *
-     * @param [listener] - the catch-all listener (optional)
-     */
-    offAnyOutgoing(listener) {
-        if (!this._anyOutgoingListeners) {
-            return this;
-        }
-        if (listener) {
-            const listeners = this._anyOutgoingListeners;
-            for (let i = 0; i < listeners.length; i++) {
-                if (listener === listeners[i]) {
-                    listeners.splice(i, 1);
-                    return this;
-                }
-            }
-        }
-        else {
-            this._anyOutgoingListeners = [];
-        }
-        return this;
-    }
-    /**
-     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
-     * e.g. to remove listeners.
-     */
-    listenersAnyOutgoing() {
-        return this._anyOutgoingListeners || [];
-    }
-    /**
-     * Notify the listeners for each packet sent
-     *
-     * @param packet
-     *
-     * @private
-     */
-    notifyOutgoingListeners(packet) {
-        if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
-            const listeners = this._anyOutgoingListeners.slice();
-            for (const listener of listeners) {
-                listener.apply(this, packet.data);
-            }
-        }
-    }
+function flush() {
+  if (!_token || _buffer.length === 0) return;
+  var events = _buffer.splice(0, _buffer.length);
+  var body = JSON.stringify({
+    warehouse_id: _warehouseId,
+    organization_id: _organizationId,
+    events: events
+  });
+  var headers = {
+    'Content-Type': 'application/json',
+    Authorization: "Bearer ".concat(_token)
+  };
+  if (navigator.sendBeacon) {
+    var blob = new Blob([body], {
+      type: 'application/json'
+    });
+    navigator.sendBeacon("".concat(INGEST_BASE, "/api/ingest/events"), blob);
+  } else {
+    fetch("".concat(INGEST_BASE, "/api/ingest/events"), {
+      method: 'POST',
+      headers: headers,
+      body: body,
+      keepalive: true
+    })["catch"](function (err) {
+      return console.error('[CoreOutline] Flush error:', err);
+    });
+  }
 }
-
-/**
- * Initialize backoff timer with `opts`.
- *
- * - `min` initial timeout in milliseconds [100]
- * - `max` max timeout [10000]
- * - `jitter` [0]
- * - `factor` [2]
- *
- * @param {Object} opts
- * @api public
- */
-function Backoff(opts) {
-    opts = opts || {};
-    this.ms = opts.min || 100;
-    this.max = opts.max || 10000;
-    this.factor = opts.factor || 2;
-    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
-    this.attempts = 0;
+function sendRrwebBatch(_x4, _x5) {
+  return _sendRrwebBatch.apply(this, arguments);
 }
-/**
- * Return the backoff duration.
- *
- * @return {Number}
- * @api public
- */
-Backoff.prototype.duration = function () {
-    var ms = this.ms * Math.pow(this.factor, this.attempts++);
-    if (this.jitter) {
-        var rand = Math.random();
-        var deviation = Math.floor(rand * this.jitter * ms);
-        ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
-    }
-    return Math.min(ms, this.max) | 0;
-};
-/**
- * Reset the number of attempts.
- *
- * @api public
- */
-Backoff.prototype.reset = function () {
-    this.attempts = 0;
-};
-/**
- * Set the minimum duration
- *
- * @api public
- */
-Backoff.prototype.setMin = function (min) {
-    this.ms = min;
-};
-/**
- * Set the maximum duration
- *
- * @api public
- */
-Backoff.prototype.setMax = function (max) {
-    this.max = max;
-};
-/**
- * Set the jitter
- *
- * @api public
- */
-Backoff.prototype.setJitter = function (jitter) {
-    this.jitter = jitter;
-};
-
-class Manager extends Emitter {
-    constructor(uri, opts) {
-        var _a;
-        super();
-        this.nsps = {};
-        this.subs = [];
-        if (uri && "object" === typeof uri) {
-            opts = uri;
-            uri = undefined;
-        }
-        opts = opts || {};
-        opts.path = opts.path || "/socket.io";
-        this.opts = opts;
-        engine_ioClient.installTimerFunctions(this, opts);
-        this.reconnection(opts.reconnection !== false);
-        this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
-        this.reconnectionDelay(opts.reconnectionDelay || 1000);
-        this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
-        this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
-        this.backoff = new Backoff({
-            min: this.reconnectionDelay(),
-            max: this.reconnectionDelayMax(),
-            jitter: this.randomizationFactor(),
-        });
-        this.timeout(null == opts.timeout ? 20000 : opts.timeout);
-        this._readyState = "closed";
-        this.uri = uri;
-        const _parser = opts.parser || parser;
-        this.encoder = new _parser.Encoder();
-        this.decoder = new _parser.Decoder();
-        this._autoConnect = opts.autoConnect !== false;
-        if (this._autoConnect)
-            this.open();
-    }
-    reconnection(v) {
-        if (!arguments.length)
-            return this._reconnection;
-        this._reconnection = !!v;
-        if (!v) {
-            this.skipReconnect = true;
-        }
-        return this;
-    }
-    reconnectionAttempts(v) {
-        if (v === undefined)
-            return this._reconnectionAttempts;
-        this._reconnectionAttempts = v;
-        return this;
-    }
-    reconnectionDelay(v) {
-        var _a;
-        if (v === undefined)
-            return this._reconnectionDelay;
-        this._reconnectionDelay = v;
-        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
-        return this;
-    }
-    randomizationFactor(v) {
-        var _a;
-        if (v === undefined)
-            return this._randomizationFactor;
-        this._randomizationFactor = v;
-        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
-        return this;
-    }
-    reconnectionDelayMax(v) {
-        var _a;
-        if (v === undefined)
-            return this._reconnectionDelayMax;
-        this._reconnectionDelayMax = v;
-        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
-        return this;
-    }
-    timeout(v) {
-        if (!arguments.length)
-            return this._timeout;
-        this._timeout = v;
-        return this;
-    }
-    /**
-     * Starts trying to reconnect if reconnection is enabled and we have not
-     * started reconnecting yet
-     *
-     * @private
-     */
-    maybeReconnectOnOpen() {
-        // Only try to reconnect if it's the first time we're connecting
-        if (!this._reconnecting &&
-            this._reconnection &&
-            this.backoff.attempts === 0) {
-            // keeps reconnection from firing twice for the same reconnection loop
-            this.reconnect();
-        }
-    }
-    /**
-     * Sets the current transport `socket`.
-     *
-     * @param {Function} fn - optional, callback
-     * @return self
-     * @public
-     */
-    open(fn) {
-        if (~this._readyState.indexOf("open"))
-            return this;
-        this.engine = new engine_ioClient.Socket(this.uri, this.opts);
-        const socket = this.engine;
-        const self = this;
-        this._readyState = "opening";
-        this.skipReconnect = false;
-        // emit `open`
-        const openSubDestroy = on(socket, "open", function () {
-            self.onopen();
-            fn && fn();
-        });
-        const onError = (err) => {
-            this.cleanup();
-            this._readyState = "closed";
-            this.emitReserved("error", err);
-            if (fn) {
-                fn(err);
-            }
-            else {
-                // Only do this if there is no fn to handle the error
-                this.maybeReconnectOnOpen();
-            }
-        };
-        // emit `error`
-        const errorSub = on(socket, "error", onError);
-        if (false !== this._timeout) {
-            const timeout = this._timeout;
-            // set timer
-            const timer = this.setTimeoutFn(() => {
-                openSubDestroy();
-                onError(new Error("timeout"));
-                socket.close();
-            }, timeout);
-            if (this.opts.autoUnref) {
-                timer.unref();
-            }
-            this.subs.push(() => {
-                this.clearTimeoutFn(timer);
-            });
-        }
-        this.subs.push(openSubDestroy);
-        this.subs.push(errorSub);
-        return this;
-    }
-    /**
-     * Alias for open()
-     *
-     * @return self
-     * @public
-     */
-    connect(fn) {
-        return this.open(fn);
-    }
-    /**
-     * Called upon transport open.
-     *
-     * @private
-     */
-    onopen() {
-        // clear old subs
-        this.cleanup();
-        // mark as open
-        this._readyState = "open";
-        this.emitReserved("open");
-        // add new subs
-        const socket = this.engine;
-        this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), 
-        // @ts-ignore
-        on(this.decoder, "decoded", this.ondecoded.bind(this)));
-    }
-    /**
-     * Called upon a ping.
-     *
-     * @private
-     */
-    onping() {
-        this.emitReserved("ping");
-    }
-    /**
-     * Called with data.
-     *
-     * @private
-     */
-    ondata(data) {
-        try {
-            this.decoder.add(data);
-        }
-        catch (e) {
-            this.onclose("parse error", e);
-        }
-    }
-    /**
-     * Called when parser fully decodes a packet.
-     *
-     * @private
-     */
-    ondecoded(packet) {
-        // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
-        engine_ioClient.nextTick(() => {
-            this.emitReserved("packet", packet);
-        }, this.setTimeoutFn);
-    }
-    /**
-     * Called upon socket error.
-     *
-     * @private
-     */
-    onerror(err) {
-        this.emitReserved("error", err);
-    }
-    /**
-     * Creates a new socket for the given `nsp`.
-     *
-     * @return {Socket}
-     * @public
-     */
-    socket(nsp, opts) {
-        let socket = this.nsps[nsp];
-        if (!socket) {
-            socket = new Socket(this, nsp, opts);
-            this.nsps[nsp] = socket;
-        }
-        else if (this._autoConnect && !socket.active) {
-            socket.connect();
-        }
-        return socket;
-    }
-    /**
-     * Called upon a socket close.
-     *
-     * @param socket
-     * @private
-     */
-    _destroy(socket) {
-        const nsps = Object.keys(this.nsps);
-        for (const nsp of nsps) {
-            const socket = this.nsps[nsp];
-            if (socket.active) {
-                return;
-            }
-        }
-        this._close();
-    }
-    /**
-     * Writes a packet.
-     *
-     * @param packet
-     * @private
-     */
-    _packet(packet) {
-        const encodedPackets = this.encoder.encode(packet);
-        for (let i = 0; i < encodedPackets.length; i++) {
-            this.engine.write(encodedPackets[i], packet.options);
-        }
-    }
-    /**
-     * Clean up transport subscriptions and packet buffer.
-     *
-     * @private
-     */
-    cleanup() {
-        this.subs.forEach((subDestroy) => subDestroy());
-        this.subs.length = 0;
-        this.decoder.destroy();
-    }
-    /**
-     * Close the current socket.
-     *
-     * @private
-     */
-    _close() {
-        this.skipReconnect = true;
-        this._reconnecting = false;
-        this.onclose("forced close");
-    }
-    /**
-     * Alias for close()
-     *
-     * @private
-     */
-    disconnect() {
-        return this._close();
-    }
-    /**
-     * Called when:
-     *
-     * - the low-level engine is closed
-     * - the parser encountered a badly formatted packet
-     * - all sockets are disconnected
-     *
-     * @private
-     */
-    onclose(reason, description) {
-        var _a;
-        this.cleanup();
-        (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();
-        this.backoff.reset();
-        this._readyState = "closed";
-        this.emitReserved("close", reason, description);
-        if (this._reconnection && !this.skipReconnect) {
-            this.reconnect();
-        }
-    }
-    /**
-     * Attempt a reconnection.
-     *
-     * @private
-     */
-    reconnect() {
-        if (this._reconnecting || this.skipReconnect)
-            return this;
-        const self = this;
-        if (this.backoff.attempts >= this._reconnectionAttempts) {
-            this.backoff.reset();
-            this.emitReserved("reconnect_failed");
-            this._reconnecting = false;
-        }
-        else {
-            const delay = this.backoff.duration();
-            this._reconnecting = true;
-            const timer = this.setTimeoutFn(() => {
-                if (self.skipReconnect)
-                    return;
-                this.emitReserved("reconnect_attempt", self.backoff.attempts);
-                // check again for the case socket closed in above events
-                if (self.skipReconnect)
-                    return;
-                self.open((err) => {
-                    if (err) {
-                        self._reconnecting = false;
-                        self.reconnect();
-                        this.emitReserved("reconnect_error", err);
-                    }
-                    else {
-                        self.onreconnect();
-                    }
-                });
-            }, delay);
-            if (this.opts.autoUnref) {
-                timer.unref();
-            }
-            this.subs.push(() => {
-                this.clearTimeoutFn(timer);
-            });
-        }
-    }
-    /**
-     * Called upon successful reconnect.
-     *
-     * @private
-     */
-    onreconnect() {
-        const attempt = this.backoff.attempts;
-        this._reconnecting = false;
-        this.backoff.reset();
-        this.emitReserved("reconnect", attempt);
-    }
+function _sendRrwebBatch() {
+  _sendRrwebBatch = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(chunks, sessionId) {
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!(!_token || !chunks || chunks.length === 0)) {
+            _context2.next = 2;
+            break;
+          }
+          return _context2.abrupt("return");
+        case 2:
+          _context2.prev = 2;
+          _context2.next = 5;
+          return fetch("".concat(INGEST_BASE, "/api/ingest/rrweb"), {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: "Bearer ".concat(_token)
+            },
+            body: JSON.stringify({
+              warehouse_id: _warehouseId,
+              organization_id: _organizationId,
+              session_id: sessionId,
+              data_source_id: _dataSourceId,
+              chunks: chunks
+            }),
+            keepalive: true
+          });
+        case 5:
+          _context2.next = 10;
+          break;
+        case 7:
+          _context2.prev = 7;
+          _context2.t0 = _context2["catch"](2);
+          console.error('[CoreOutline] rrweb upload error:', _context2.t0);
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[2, 7]]);
+  }));
+  return _sendRrwebBatch.apply(this, arguments);
 }
-
-/**
- * Managers cache.
- */
-const cache = {};
-function lookup(uri, opts) {
-    if (typeof uri === "object") {
-        opts = uri;
-        uri = undefined;
-    }
-    opts = opts || {};
-    const parsed = url(uri, opts.path || "/socket.io");
-    const source = parsed.source;
-    const id = parsed.id;
-    const path = parsed.path;
-    const sameNamespace = cache[id] && path in cache[id]["nsps"];
-    const newConnection = opts.forceNew ||
-        opts["force new connection"] ||
-        false === opts.multiplex ||
-        sameNamespace;
-    let io;
-    if (newConnection) {
-        io = new Manager(source, opts);
-    }
-    else {
-        if (!cache[id]) {
-            cache[id] = new Manager(source, opts);
-        }
-        io = cache[id];
-    }
-    if (parsed.query && !opts.query) {
-        opts.query = parsed.queryKey;
-    }
-    return io.socket(parsed.path, opts);
+function stopFlushInterval() {
+  if (_flushInterval) {
+    clearInterval(_flushInterval);
+    _flushInterval = null;
+  }
 }
-// so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
-// namespace (e.g. `io.connect(...)`), for backward compatibility
-Object.assign(lookup, {
-    Manager,
-    Socket,
-    io: lookup,
-    connect: lookup,
-});
-
-var socket = lookup('http://streams.coreoutline.com');
 
 var CoreOutline = function CoreOutline(_ref) {
   var children = _ref.children,
     data_source_id = _ref.data_source_id,
-    data_source_secret = _ref.data_source_secret;
+    data_source_secret = _ref.data_source_secret,
+    warehouse_id = _ref.warehouse_id;
   var _useState = React.useState([]),
     _useState2 = _slicedToArray(_useState, 2),
-    events = _useState2[0],
-    setEvents = _useState2[1];
-  var _useState3 = React.useState([]),
-    _useState4 = _slicedToArray(_useState3, 2),
-    replayEvents = _useState4[0],
-    setReplayEvents = _useState4[1];
+    replayEvents = _useState2[0],
+    setReplayEvents = _useState2[1];
   var recorderActive = React.useRef(false);
-  var _useState5 = React.useState(window.location.href),
-    _useState6 = _slicedToArray(_useState5, 2),
-    currentPage = _useState6[0],
-    setCurrentPage = _useState6[1];
-  var _useState7 = React.useState({
-      latitude: null,
-      longitude: null
-    }),
-    _useState8 = _slicedToArray(_useState7, 2),
-    location = _useState8[0],
-    setLocation = _useState8[1];
-  var _useState9 = React.useState(getBrowserInfo()),
-    _useState10 = _slicedToArray(_useState9, 2),
-    browser = _useState10[0];
-    _useState10[1];
-  var _useState11 = React.useState(''),
-    _useState12 = _slicedToArray(_useState11, 2);
-    _useState12[0];
-    var setAppToken = _useState12[1];
-  var _useState13 = React.useState(uuid.v4()),
-    _useState14 = _slicedToArray(_useState13, 2),
-    sessionId = _useState14[0];
-    _useState14[1];
-  function authorizeApp(_x, _x2) {
-    return _authorizeApp.apply(this, arguments);
-  }
-  function _authorizeApp() {
-    _authorizeApp = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(data_source_id, data_source_secret) {
-      var requestOptions, response;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            requestOptions = {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json'
-              },
-              body: JSON.stringify({
-                data_source_id: data_source_id,
-                data_source_secret: data_source_secret
-              })
-            };
-            response = fetch("http://api.coreoutline.com/data-source/authorize", requestOptions).then(function (response) {
-              return response.json();
-            }).then(function (data) {
-              setAppToken(data.app_token);
-              return data;
-            })["catch"](function (error) {
-              console.error('Error:', error);
-              return error;
-            });
-            return _context2.abrupt("return", response);
-          case 3:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }));
-    return _authorizeApp.apply(this, arguments);
-  }
-  var offLoadFunctionality = function offLoadFunctionality() {
-    var formattedEvents = events;
-    var rawEvents = replayEvents;
-    var data = JSON.stringify({
-      data_source_id: data_source_id,
-      sessionId: sessionId,
-      formatted_events: formattedEvents,
-      raw_events: rawEvents
-    });
-    socket.send({
-      topic: 'session-data',
-      data_source_id: data_source_id,
-      session_id: localStorage.getItem('coreOutlineSessionId'),
-      start_date: new Date().toLocaleString(),
-      latitude: location.latitude,
-      longitude: location.longitude,
-      browser: browser,
-      event_id: 'SESSION_END'
-    });
-    if (navigator.sendBeacon) {
-      navigator.sendBeacon("http://data.coreoutline.com/upload-events", data);
-    } else {
-      fetch("http://data.coreoutline.com/upload-events", {
-        method: 'POST',
-        body: data,
-        keepalive: true,
-        headers: {
-          'Content-Type': 'application/json'
-        }
-      })["catch"](function (err) {
-        return console.error('Upload failed:', err);
-      });
-    }
-  };
-  React.useEffect(function () {}, [events, replayEvents]);
-  React.useEffect(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-    var handleBeforeUnload, handleVisibilityChange;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          handleBeforeUnload = function handleBeforeUnload() {
-            offLoadFunctionality();
-          };
-          handleVisibilityChange = function handleVisibilityChange() {
-            if (document.visibilityState === 'hidden') {
-              offLoadFunctionality();
-            }
-          };
-          window.addEventListener('beforeunload', handleBeforeUnload);
-          document.addEventListener('visibilitychange', handleVisibilityChange);
-          _context.next = 6;
-          return authorizeApp(data_source_id, data_source_secret);
-        case 6:
-          localStorage.setItem('coreOutlineSessionId', sessionId);
-          localStorage.setItem('coreOutlineDataSourceIdId', data_source_id);
-          console.log('Session', sessionId);
-          socket.send({
-            topic: 'session-data',
-            data_source_id: data_source_id,
-            session_id: localStorage.getItem('coreOutlineSessionId'),
-            start_date: new Date().toLocaleString(),
-            latitude: location.latitude,
-            longitude: location.longitude,
-            browser: browser,
-            event_id: 'SESSION_START'
-          });
-          return _context.abrupt("return", function () {
-            offLoadFunctionality();
-            window.removeEventListener('beforeunload', handleBeforeUnload);
-            document.removeEventListener('visibilitychange', handleVisibilityChange);
-            socket.send({
-              topic: 'session-data',
-              data_source_id: data_source_id,
-              session_id: localStorage.getItem('coreOutlineSessionId'),
-              start_date: new Date().toLocaleString(),
-              latitude: location.latitude,
-              longitude: location.longitude,
-              browser: browser,
-              event_id: 'SESSION_END'
-            });
-          });
-        case 11:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  })), []);
+  var _useState3 = React.useState(window.location.href),
+    _useState4 = _slicedToArray(_useState3, 2),
+    currentPage = _useState4[0],
+    setCurrentPage = _useState4[1];
+  var pageviewCountRef = React.useRef(0);
+  var eventCountRef = React.useRef(0);
+  var sessionStartRef = React.useRef(Date.now());
+  var sessionId = getSessionId();
+  var anonymousId = getAnonymousId();
   React.useEffect(function () {
-    var navigationEvent = {
-      type: 4,
-      data: {
-        href: window.location.href,
-        width: 1536,
-        height: 730
-      },
-      timestamp: Date.now()
+    var utmParams = getUtmParams();
+    var deviceType = detectDeviceType();
+    var os = detectOS();
+    var browser = getBrowserName();
+    var referrer = document.referrer || 'direct';
+    var basePayload = _objectSpread2({
+      session_id: sessionId,
+      anonymous_id: anonymousId,
+      account_id: data_source_id,
+      platform: 'web',
+      device_type: deviceType,
+      os: os,
+      browser: browser,
+      referrer: referrer,
+      page_url: window.location.href,
+      page_path: getPagePath()
+    }, utmParams);
+    var initialized = false;
+    var init = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return initIngest(warehouse_id, data_source_id, data_source_secret);
+            case 2:
+              initialized = _context.sent;
+              if (initialized) {
+                _context.next = 5;
+                break;
+              }
+              return _context.abrupt("return");
+            case 5:
+              pageviewCountRef.current += 1;
+              trackEvent('pageview', _objectSpread2(_objectSpread2({}, basePayload), {}, {
+                event_name: 'pageview',
+                event_category: 'navigation'
+              }));
+              trackEvent('session_start', _objectSpread2(_objectSpread2({}, basePayload), {}, {
+                event_name: 'session_start',
+                event_category: 'session',
+                session_start_ts: new Date().toISOString()
+              }));
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function init() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    init();
+    var handleSessionEnd = function handleSessionEnd() {
+      if (!initialized) return;
+      var durationMs = Date.now() - sessionStartRef.current;
+      trackEvent('session_end', _objectSpread2(_objectSpread2({}, basePayload), {}, {
+        event_name: 'session_end',
+        event_category: 'session',
+        session_end_ts: new Date().toISOString(),
+        pageviews: pageviewCountRef.current,
+        events_count: eventCountRef.current,
+        duration_ms: durationMs
+      }));
+      flush();
+      stopFlushInterval();
+      sendRrwebBatch(replayEvents, sessionId);
     };
-    var startTime = performance.now();
-    var observer = new MutationObserver(function () {
-      var endTime = performance.now();
-      var loadTime = endTime - startTime;
-      navigationEvent.data.loadTime = loadTime;
-      var hours = Math.floor(loadTime / 3600000);
-      var minutes = Math.floor(loadTime % 3600000 / 60000);
-      var seconds = Math.floor(loadTime % 60000 / 1000);
-      navigationEvent.data.loadTimeFormatted = "".concat(hours, " hours ").concat(minutes, " minutes ").concat(seconds, " seconds");
-      observer.disconnect();
-    });
-    observer.observe(document, {
-      childList: true,
-      subtree: true
-    });
-    setEvents(function (prevEvents) {
-      return [].concat(_toConsumableArray(prevEvents), [navigationEvent]);
-    });
-    localStorage.setItem('coreoutlineFormattedEvents', JSON.stringify(function (prevEvents) {
-      return [].concat(_toConsumableArray(prevEvents), [navigationEvent]);
-    }));
+    var handleVisibilityChange = function handleVisibilityChange() {
+      if (document.visibilityState === 'hidden') handleSessionEnd();
+    };
+    window.addEventListener('beforeunload', handleSessionEnd);
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    return function () {
+      handleSessionEnd();
+      window.removeEventListener('beforeunload', handleSessionEnd);
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  }, []);
+  React.useEffect(function () {
+    var utmParams = getUtmParams();
     var handleNavigation = function handleNavigation() {
       setCurrentPage(window.location.href);
-      socket.send({
-        topic: 'session-data',
-        data_source_id: data_source_id,
-        session_id: localStorage.getItem('coreOutlineSessionId'),
-        start_date: new Date().toLocaleString(),
-        latitude: location.latitude,
-        longitude: location.longitude,
-        browser: browser,
-        page_name: window.location.href,
-        event_id: 'PAGE_NAVIGATION'
-      });
+      pageviewCountRef.current += 1;
+      trackEvent('pageview', _objectSpread2({
+        session_id: sessionId,
+        anonymous_id: anonymousId,
+        account_id: data_source_id,
+        platform: 'web',
+        page_url: window.location.href,
+        page_path: getPagePath(),
+        referrer: document.referrer || 'direct',
+        event_name: 'pageview',
+        event_category: 'navigation'
+      }, utmParams));
     };
     window.addEventListener('popstate', handleNavigation);
     var originalPushState = window.history.pushState;
@@ -6576,61 +4702,14 @@ var CoreOutline = function CoreOutline(_ref) {
       window.history.pushState = originalPushState;
     };
   }, [currentPage]);
-  React.useEffect(function () {
-    console.log('Location', location);
-    getLocation();
-  }, []);
   React.useEffect(function () {
     var stopFn;
     if (!recorderActive.current) {
       stopFn = record({
         emit: function emit(event) {
-          setReplayEvents(function (prevEvents) {
-            return [].concat(_toConsumableArray(prevEvents), [event]);
+          setReplayEvents(function (prev) {
+            return [].concat(_toConsumableArray(prev), [event]);
           });
-          localStorage.setItem('coreoutlineRawEvents', JSON.stringify(function (prevEvents) {
-            return [].concat(_toConsumableArray(replayEvents), [event]);
-          }));
-        },
-        maskAllInputs: false,
-        maskTextSelector: null
-      });
-      recorderActive.current = true;
-    }
-    return function () {
-      if (stopFn) {
-        stopFn();
-        recorderActive.current = false;
-      }
-    };
-  }, []);
-  React.useEffect(function () {
-    var stopFn;
-    if (!recorderActive.current) {
-      stopFn = record({
-        emit: function emit(event) {
-          console.log('Event:', event);
-          if (event.type == 3 && event.data.type == 2) {
-            return;
-          }
-          if (event.type == 4) {
-            return;
-          }
-          if (event.type == 3 && event.data.source == 0) {
-            return;
-          }
-          if (event.type == 3 && event.data.source == 1) {
-            return;
-          }
-          if (event.type == 3 && event.data.type == 3) {
-            console.log('Contextmenu Event:', event);
-          }
-          setEvents(function (prevEvents) {
-            return [].concat(_toConsumableArray(prevEvents), [event]);
-          });
-          localStorage.setItem('coreoutlineFormattedEvents', JSON.stringify(function (prevEvents) {
-            return [].concat(_toConsumableArray(prevEvents), [event]);
-          }));
         },
         maskAllInputs: false,
         maskTextSelector: null
@@ -6646,122 +4725,45 @@ var CoreOutline = function CoreOutline(_ref) {
   }, []);
   React.useEffect(function () {
     var handleClick = function handleClick(event) {
-      console.log('Inner text:', event.target.innerText);
-      var clickEvent = {
-        type: EventType.IncrementalSnapshot,
-        data: {
-          source: IncrementalSource.MouseInteraction,
-          type: MouseInteractions.Click,
-          id: event.target.id,
-          x: event.clientX,
-          y: event.clientY
-        },
-        timestamp: Date.now()
-      };
-      var clickedElement = document.elementFromPoint(clickEvent.data.x, clickEvent.data.y);
-      if (clickedElement) {
-        clickEvent.data.metadata = {
-          label: clickedElement.getAttribute('data-label') || clickedElement.innerText || null,
-          value: clickedElement.getAttribute('value') || clickedElement.innerText || null,
-          id: clickedElement.getAttribute('id') || clickedElement.innerText || null,
-          name: clickedElement.getAttribute('name') || clickedElement.innerText || null,
-          "class": clickedElement.getAttribute('class') || clickedElement.innerText || null,
-          tag: clickedElement.tagName,
-          html: String(clickedElement.getHTML()),
-          innerText: event.target.innerText
-        };
-      }
-      setEvents(function (prevEvents) {
-        return [].concat(_toConsumableArray(prevEvents), [clickEvent]);
-      });
-      localStorage.setItem('coreoutlineFormattedEvents', JSON.stringify(function (prevEvents) {
-        return [].concat(_toConsumableArray(prevEvents), [clickEvent]);
-      }));
-      socket.send({
-        topic: 'session-data',
-        data_source_id: data_source_id,
-        session_id: localStorage.getItem('coreOutlineSessionId'),
-        start_date: new Date().toLocaleString(),
-        latitude: location.latitude,
-        longitude: location.longitude,
-        browser: browser,
-        event_id: 'ITEM_CLICKED'
-        // item_clicked: event.target,
+      var clickedElement = document.elementFromPoint(event.clientX, event.clientY);
+      var metadata = clickedElement ? {
+        label: clickedElement.getAttribute('data-label') || clickedElement.innerText || null,
+        value: clickedElement.getAttribute('value') || clickedElement.innerText || null,
+        id: clickedElement.getAttribute('id') || null,
+        name: clickedElement.getAttribute('name') || null,
+        "class": clickedElement.getAttribute('class') || null,
+        tag: clickedElement.tagName,
+        inner_text: event.target.innerText || null
+      } : {};
+      eventCountRef.current += 1;
+      trackEvent('item_clicked', {
+        session_id: sessionId,
+        anonymous_id: anonymousId,
+        account_id: data_source_id,
+        platform: 'web',
+        page_url: window.location.href,
+        page_path: getPagePath(),
+        event_name: 'item_clicked',
+        event_category: 'interaction',
+        properties_json: JSON.stringify(metadata)
       });
     };
     document.addEventListener('click', handleClick);
     return function () {
-      document.removeEventListener('click', handleClick);
+      return document.removeEventListener('click', handleClick);
     };
   }, []);
-  function saveEventsLocally() {
-    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'formatted' ;
-    var blob = '';
-    if (type === 'formatted') {
-      blob = new Blob([JSON.stringify(events, null, 2)], {
-        type: 'application/json'
-      });
-    } else if (type === 'raw') {
-      blob = new Blob([JSON.stringify(replayEvents, null, 2)], {
-        type: 'application/json'
-      });
-    }
-    var url = URL.createObjectURL(blob);
-    var a = document.createElement('a');
-    a.href = url;
-    a.download = "".concat(type, "_events.json");
-    a.click();
-    URL.revokeObjectURL(url);
-  }
-  function getBrowserInfo() {
-    var userAgent = navigator.userAgent;
-    var browserName = 'Unknown';
-    if (userAgent.indexOf('Firefox') > -1) {
-      browserName = 'Firefox';
-    } else if (userAgent.indexOf('Opera') > -1 || userAgent.indexOf('OPR') > -1) {
-      browserName = 'Opera';
-    } else if (userAgent.indexOf('Chrome') > -1) {
-      browserName = 'Chrome';
-    } else if (userAgent.indexOf('Safari') > -1) {
-      browserName = 'Safari';
-    } else if (userAgent.indexOf('MSIE') > -1 || userAgent.indexOf('Trident/') > -1) {
-      browserName = 'Internet Explorer';
-    }
-    return browserName;
-  }
-  function getLocation() {
-    if (navigator.geolocation) {
-      navigator.geolocation.getCurrentPosition(function (position) {
-        setLocation({
-          latitude: position.coords.latitude,
-          longitude: position.coords.longitude
-        });
-      }, function (error) {
-        console.error('Error getting location:', error);
-      });
-    } else {
-      console.error('Geolocation is not supported by this browser.');
-    }
-  }
-  return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("button", {
-    onClick: function onClick() {
-      saveEventsLocally('formatted');
-      saveEventsLocally('raw');
-    }
-  }, "Save Events Locally"), children);
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, children);
 };
 var flag_item_clicked = function flag_item_clicked(item_id) {
-  var sessionId = localStorage.getItem('coreOutlineSessionId');
-  var dataSourceId = localStorage.getItem('coreOutlineDataSourceIdId');
-  console.log('Session', sessionId);
-  console.log('Data Source', dataSourceId);
-  socket.send({
-    topic: 'session-data',
-    data_source_id: dataSourceId,
-    session_id: localStorage.getItem('coreOutlineSessionId'),
-    start_date: new Date().toLocaleString(),
-    event_id: 'PRODUCT_CLICKED',
-    item_clicked: item_id
+  var sessionId = sessionStorage.getItem('co_session_id') || '';
+  var anonymousId = localStorage.getItem('co_anon_id') || '';
+  trackEvent('product_clicked', {
+    session_id: sessionId,
+    anonymous_id: anonymousId,
+    event_name: 'product_clicked',
+    event_category: 'commerce',
+    feature_key: item_id
   });
   return {
     status: 'success',
@@ -6769,17 +4771,16 @@ var flag_item_clicked = function flag_item_clicked(item_id) {
   };
 };
 var flag_item_purchased = function flag_item_purchased(item_id) {
-  var sessionId = localStorage.getItem('coreOutlineSessionId');
-  var dataSourceId = localStorage.getItem('coreOutlineDataSourceIdId');
-  console.log('Session', sessionId);
-  console.log('Data Source', dataSourceId);
-  socket.send({
-    topic: 'session-data',
-    data_source_id: dataSourceId,
-    session_id: localStorage.getItem('coreOutlineSessionId'),
-    start_date: new Date().toLocaleString(),
-    event_id: 'PRODUCT_PURCHASED',
-    item_clicked: item_id
+  var price = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var sessionId = sessionStorage.getItem('co_session_id') || '';
+  var anonymousId = localStorage.getItem('co_anon_id') || '';
+  trackEvent('product_purchased', {
+    session_id: sessionId,
+    anonymous_id: anonymousId,
+    event_name: 'product_purchased',
+    event_category: 'commerce',
+    feature_key: item_id,
+    value_num: price != null ? Number(price) : null
   });
   return {
     status: 'success',