clarity-js 0.6.27 → 0.6.31

package/build/clarity.module.js

@@ -1,9 +1,48 @@
 var upload$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get track () { return track; },
-    get start () { return start$9; },
+    get track () { return track$1; },
+    get start () { return start$c; },
     get queue () { return queue; },
-    get stop () { return stop$8; }
+    get stop () { return stop$b; }
+});
+var limit = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$4; },
+    get start () { return start$b; },
+    get check () { return check$2; },
+    get trigger () { return trigger; },
+    get compute () { return compute$3; },
+    get stop () { return stop$a; }
+});
+var dimension = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$3; },
+    get updates () { return updates; },
+    get start () { return start$a; },
+    get stop () { return stop$9; },
+    get log () { return log; },
+    get compute () { return compute$2; },
+    get reset () { return reset$3; }
+});
+var metadata$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$2; },
+    get callback () { return callback; },
+    get start () { return start$9; },
+    get userAgentData () { return userAgentData; },
+    get stop () { return stop$8; },
+    get metadata () { return metadata; },
+    get id () { return id; },
+    get consent () { return consent; },
+    get clear () { return clear; },
+    get save () { return save; }
+});
+var envelope$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$1; },
+    get start () { return start$8; },
+    get stop () { return stop$7; },
+    get envelope () { return envelope; }
 });
 
 var config$1 = {
@@ -37,6 +76,28 @@ function stop$B() {
     startTime = 0;
 }
 
+var version$1 = "0.6.31";
+
+// tslint:disable: no-bitwise
+function hash (input) {
+    // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
+    var hash = 0;
+    var hashOne = 5381;
+    var hashTwo = hashOne;
+    for (var i = 0; i < input.length; i += 2) {
+        var charOne = input.charCodeAt(i);
+        hashOne = ((hashOne << 5) + hashOne) ^ charOne;
+        if (i + 1 < input.length) {
+            var charTwo = input.charCodeAt(i + 1);
+            hashTwo = ((hashTwo << 5) + hashTwo) ^ charTwo;
+        }
+    }
+    // Replace the magic number from C# implementation (1566083941) with a smaller prime number (11579)
+    // This ensures we don't hit integer overflow and prevent collisions
+    hash = Math.abs(hashOne + (hashTwo * 11579));
+    return hash.toString(36);
+}
+
 var state$9 = null;
 var buffer = null;
 var update$1 = false;
@@ -141,29 +202,187 @@ function event(key, value) {
     }
 }
 
-// tslint:disable: no-bitwise
-function hash (input) {
-    // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
-    var hash = 0;
-    var hashOne = 5381;
-    var hashTwo = hashOne;
-    for (var i = 0; i < input.length; i += 2) {
-        var charOne = input.charCodeAt(i);
-        hashOne = ((hashOne << 5) + hashOne) ^ charOne;
-        if (i + 1 < input.length) {
-            var charTwo = input.charCodeAt(i + 1);
-            hashTwo = ((hashTwo << 5) + hashTwo) ^ charTwo;
+var data$h = null;
+var updates$3 = null;
+function start$C() {
+    data$h = {};
+    updates$3 = {};
+    count$1(5 /* InvokeCount */);
+}
+function stop$z() {
+    data$h = {};
+    updates$3 = {};
+}
+function count$1(metric, increment) {
+    if (increment === void 0) { increment = 1; }
+    if (!(metric in data$h)) {
+        data$h[metric] = 0;
+    }
+    if (!(metric in updates$3)) {
+        updates$3[metric] = 0;
+    }
+    data$h[metric] += increment;
+    updates$3[metric] += increment;
+}
+function sum(metric, value) {
+    if (value !== null) {
+        if (!(metric in data$h)) {
+            data$h[metric] = 0;
+        }
+        if (!(metric in updates$3)) {
+            updates$3[metric] = 0;
         }
+        data$h[metric] += value;
+        updates$3[metric] += value;
     }
-    // Replace the magic number from C# implementation (1566083941) with a smaller prime number (11579)
-    // This ensures we don't hit integer overflow and prevent collisions
-    hash = Math.abs(hashOne + (hashTwo * 11579));
-    return hash.toString(36);
+}
+function max(metric, value) {
+    // Ensure that we do not process null or NaN values
+    if (value !== null && isNaN(value) === false) {
+        if (!(metric in data$h)) {
+            data$h[metric] = 0;
+        }
+        if (value > data$h[metric] || data$h[metric] === 0) {
+            updates$3[metric] = value;
+            data$h[metric] = value;
+        }
+    }
+}
+function compute$b() {
+    encode$1(0 /* Metric */);
+}
+function reset$n() {
+    updates$3 = {};
 }
 
-var data$h = null;
-function start$C() {
-    reset$n();
+function setTimeout(handler, timeout, event) {
+    return window.setTimeout(measure(handler), timeout, event);
+}
+function clearTimeout(handle) {
+    return window.clearTimeout(handle);
+}
+
+var data$g;
+var last = 0;
+var interval = 0;
+var timeout$6 = null;
+function start$B() {
+    interval = 60000 /* PingInterval */;
+    last = 0;
+}
+function reset$m() {
+    if (timeout$6) {
+        clearTimeout(timeout$6);
+    }
+    timeout$6 = setTimeout(ping, interval);
+    last = time();
+}
+function ping() {
+    var now = time();
+    data$g = { gap: now - last };
+    encode$1(25 /* Ping */);
+    if (data$g.gap < 300000 /* PingTimeout */) {
+        timeout$6 = setTimeout(ping, interval);
+    }
+    else {
+        suspend();
+    }
+}
+function stop$y() {
+    clearTimeout(timeout$6);
+    last = 0;
+    interval = 0;
+}
+
+var ping$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$g; },
+    start: start$B,
+    reset: reset$m,
+    stop: stop$y
+});
+
+var data$f = null;
+function start$A() {
+    data$f = {};
+}
+function stop$x() {
+    data$f = {};
+}
+function track$6(event, time) {
+    if (!(event in data$f)) {
+        data$f[event] = [[time, 0]];
+    }
+    else {
+        var e = data$f[event];
+        var last = e[e.length - 1];
+        // Add a new entry only if the new event occurs after configured interval
+        // Otherwise, extend the duration of the previous entry
+        if (time - last[0] > 100 /* SummaryInterval */) {
+            data$f[event].push([time, 0]);
+        }
+        else {
+            last[1] = time - last[0];
+        }
+    }
+}
+function compute$a() {
+    encode$1(36 /* Summary */);
+}
+function reset$l() {
+    data$f = {};
+}
+
+var summary = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$f; },
+    start: start$A,
+    stop: stop$x,
+    track: track$6,
+    compute: compute$a,
+    reset: reset$l
+});
+
+var data$e = null;
+function start$z() {
+    if (!config$1.lean && config$1.upgrade) {
+        config$1.upgrade("Config" /* Config */);
+    }
+    data$e = null;
+}
+// Following call will upgrade the session from lean mode into the full mode retroactively from the start of the page.
+// As part of the lean mode, we do not send back any layout information - including discovery of DOM and mutations.
+// However, if there's a need for full fidelity playback, calling this function will disable lean mode
+// and send all backed up layout events to the server.
+function upgrade(key) {
+    // Upgrade only if Clarity was successfully activated on the page
+    if (active() && config$1.lean) {
+        config$1.lean = false;
+        data$e = { key: key };
+        // Update metadata to track we have upgraded this session
+        save();
+        // Callback upgrade handler, if configured
+        if (config$1.upgrade) {
+            config$1.upgrade(key);
+        }
+        encode$1(3 /* Upgrade */);
+    }
+}
+function stop$w() {
+    data$e = null;
+}
+
+var upgrade$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$e; },
+    start: start$z,
+    upgrade: upgrade,
+    stop: stop$w
+});
+
+var data$d = null;
+function start$y() {
+    reset$k();
 }
 function set(variable, value) {
     var values = typeof value === "string" /* String */ ? [value] : value;
@@ -182,1505 +401,978 @@ function log$2(variable, value) {
         value &&
         typeof variable === "string" /* String */ &&
         variable.length < 255) {
-        var validValues = variable in data$h ? data$h[variable] : [];
+        var validValues = variable in data$d ? data$d[variable] : [];
         for (var i = 0; i < value.length; i++) {
             if (typeof value[i] === "string" /* String */ && value[i].length < 255) {
                 validValues.push(value[i]);
             }
         }
-        data$h[variable] = validValues;
+        data$d[variable] = validValues;
     }
 }
-function compute$b() {
+function compute$9() {
     encode$1(34 /* Variable */);
 }
-function reset$n() {
-    data$h = {};
+function reset$k() {
+    data$d = {};
 }
-function stop$z() {
-    reset$n();
+function stop$v() {
+    reset$k();
 }
 
 var variable = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get data () { return data$h; },
-    start: start$C,
+    get data () { return data$d; },
+    start: start$y,
     set: set,
     identify: identify,
-    compute: compute$b,
-    reset: reset$n,
-    stop: stop$z
+    compute: compute$9,
+    reset: reset$k,
+    stop: stop$v
 });
 
-var data$g = null;
-var callback = null;
-var rootDomain = null;
-function start$B() {
-    callback = null;
-    rootDomain = null;
-    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Empty */;
-    var title = document && document.title ? document.title : "" /* Empty */;
-    // Populate ids for this page
-    var s = session();
-    var u = user();
-    data$g = {
-        projectId: config$1.projectId || hash(location.host),
-        userId: u.id,
-        sessionId: s.session,
-        pageNum: s.count
-    };
-    // Override configuration based on what's in the session storage, unless it is blank (e.g. using upload callback, like in devtools)
-    config$1.lean = config$1.track && s.upgrade !== null ? s.upgrade === 0 /* False */ : config$1.lean;
-    config$1.upload = config$1.track && typeof config$1.upload === "string" /* String */ && s.upload && s.upload.length > "https://" /* HTTPS */.length ? s.upload : config$1.upload;
-    // Log dimensions
-    log$1(0 /* UserAgent */, ua);
-    log$1(3 /* PageTitle */, title);
-    log$1(1 /* Url */, location.href);
-    log$1(2 /* Referrer */, document.referrer);
-    log$1(15 /* TabId */, tab());
-    log$1(16 /* PageLanguage */, document.documentElement.lang);
-    log$1(17 /* DocumentDirection */, document.dir);
-    if (navigator) {
-        log$1(9 /* Language */, navigator.userLanguage || navigator.language);
-        max(26 /* Automation */, navigator.webdriver ? 1 /* True */ : 0 /* False */);
-    }
-    // Metrics
-    max(0 /* ClientTimestamp */, s.ts);
-    max(1 /* Playback */, 0 /* False */);
-    if (screen) {
-        max(14 /* ScreenWidth */, Math.round(screen.width));
-        max(15 /* ScreenHeight */, Math.round(screen.height));
-        max(16 /* ColorDepth */, Math.round(screen.colorDepth));
-    }
-    // Read cookies specified in configuration
-    for (var _i = 0, _a = config$1.cookies; _i < _a.length; _i++) {
-        var key = _a[_i];
-        var value = getCookie(key);
-        if (value) {
-            set(key, value);
-        }
-    }
-    // Track ids using a cookie if configuration allows it
-    track$6(u);
-}
-function stop$y() {
-    callback = null;
-    rootDomain = null;
-}
-function metadata$1(cb) {
-    callback = cb;
-}
-function id() {
-    return data$g ? [data$g.userId, data$g.sessionId, data$g.pageNum].join("." /* Dot */) : "" /* Empty */;
-}
-function consent() {
-    if (active()) {
-        config$1.track = true;
-        track$6(user(), 1 /* True */);
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
+}
+
+var supported$1 = "CompressionStream" /* CompressionStream */ in window;
+function compress (input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stream, _a;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 3, , 4]);
+                    if (!supported$1) return [3 /*break*/, 2];
+                    stream = new ReadableStream({ start: function (controller) {
+                            return __awaiter(this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    controller.enqueue(input);
+                                    controller.close();
+                                    return [2 /*return*/];
+                                });
+                            });
+                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* CompressionStream */]("gzip"));
+                    _a = Uint8Array.bind;
+                    return [4 /*yield*/, read(stream)];
+                case 1: return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _c.sent()]))()];
+                case 2: return [3 /*break*/, 4];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, null];
+            }
+        });
+    });
 }
-function clear() {
-    // Clear any stored information in the cookie that tracks session information so we can restart fresh the next time
-    setCookie("_clsk" /* SessionKey */, "" /* Empty */, 0);
+function read(stream) {
+    return __awaiter(this, void 0, void 0, function () {
+        var reader, chunks, done, value;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = stream.getReader();
+                    chunks = [];
+                    done = false;
+                    value = [];
+                    _b.label = 1;
+                case 1:
+                    if (!!done) return [3 /*break*/, 3];
+                    return [4 /*yield*/, reader.read()];
+                case 2:
+                    (_a = _b.sent(), done = _a.done, value = _a.value);
+                    if (done) {
+                        return [2 /*return*/, chunks];
+                    }
+                    chunks.push.apply(chunks, value);
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, chunks];
+            }
+        });
+    });
+}
+
+var modules$1 = [baseline, dimension, variable, limit, summary, metadata$1, envelope$1, upload$1, ping$1, upgrade$1];
+function start$x() {
+    // Metric needs to be initialized before we can start measuring. so metric is not wrapped in measure
+    start$C();
+    modules$1.forEach(function (x) { return measure(x.start)(); });
 }
-function tab() {
-    var id = shortid();
-    if (config$1.track && supported$1(window, "sessionStorage" /* SessionStorage */)) {
-        var value = sessionStorage.getItem("_cltk" /* TabKey */);
-        id = value ? value : id;
-        sessionStorage.setItem("_cltk" /* TabKey */, id);
-    }
-    return id;
+function stop$u() {
+    // Stop modules in the reverse order of their initialization
+    // The ordering below should respect inter-module dependency.
+    // E.g. if upgrade depends on upload, then upgrade needs to end before upload.
+    // Similarly, if upload depends on metadata, upload needs to end before metadata.
+    modules$1.slice().reverse().forEach(function (x) { return measure(x.stop)(); });
+    stop$z();
 }
-function save() {
-    var ts = Math.round(Date.now());
-    var upgrade = config$1.lean ? 0 /* False */ : 1 /* True */;
-    var upload = config$1.upload && typeof config$1.upload === "string" /* String */ ? config$1.upload.replace("https://" /* HTTPS */, "" /* Empty */) : "" /* Empty */;
-    if (upgrade && callback) {
-        callback(data$g, !config$1.lean);
+function compute$8() {
+    compute$9();
+    compute$c();
+    compute$2();
+    compute$b();
+    compute$a();
+    compute$3();
+}
+
+function scrub (value, hint, privacy, mangle) {
+    if (mangle === void 0) { mangle = false; }
+    if (value) {
+        switch (privacy) {
+            case 0 /* None */:
+                return value;
+            case 1 /* Sensitive */:
+                switch (hint) {
+                    case "*T" /* TextTag */:
+                    case "value":
+                    case "placeholder":
+                        return redact(value);
+                    case "input":
+                        return mangleToken(value);
+                }
+                return value;
+            case 2 /* Text */:
+            case 3 /* TextImage */:
+                switch (hint) {
+                    case "*T" /* TextTag */:
+                        return mangle ? mangleText(value) : mask(value);
+                    case "src":
+                    case "srcset":
+                    case "title":
+                    case "alt":
+                        return privacy === 3 /* TextImage */ ? "" /* Empty */ : value;
+                    case "value":
+                    case "click":
+                    case "input":
+                        return mangleToken(value);
+                    case "placeholder":
+                        return mask(value);
+                }
+                break;
+        }
     }
-    setCookie("_clsk" /* SessionKey */, [data$g.sessionId, ts, data$g.pageNum, upgrade, upload].join("|" /* Pipe */), 1 /* SessionExpire */);
+    return value;
 }
-function supported$1(target, api) {
-    try {
-        return !!target[api];
-    }
-    catch (_a) {
-        return false;
+function mangleText(value) {
+    var trimmed = value.trim();
+    if (trimmed.length > 0) {
+        var first = trimmed[0];
+        var index = value.indexOf(first);
+        var prefix = value.substr(0, index);
+        var suffix = value.substr(index + trimmed.length);
+        return "" + prefix + trimmed.length.toString(36) + suffix;
     }
+    return value;
 }
-function track$6(u, consent) {
-    if (consent === void 0) { consent = null; }
-    // If consent is not explicitly specified, infer it from the user object
-    consent = consent === null ? u.consent : consent;
-    // Convert time precision into days to reduce number of bytes we have to write in a cookie
-    // E.g. Math.ceil(1628735962643 / (24*60*60*1000)) => 18852 (days) => ejo in base36 (13 bytes => 3 bytes)
-    var end = Math.ceil((Date.now() + (365 /* Expire */ * 86400000 /* Day */)) / 86400000 /* Day */);
-    // To avoid cookie churn, write user id cookie only once every day
-    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* CookieInterval */ || u.consent !== consent) {
-        setCookie("_clck" /* CookieKey */, [data$g.userId, 1 /* CookieVersion */, end.toString(36), consent].join("|" /* Pipe */), 365 /* Expire */);
-    }
+function mask(value) {
+    return value.replace(/\S/gi, "\u2022" /* Mask */);
 }
-function shortid() {
-    var id = Math.floor(Math.random() * Math.pow(2, 32));
-    if (window && window.crypto && window.crypto.getRandomValues && Uint32Array) {
-        id = window.crypto.getRandomValues(new Uint32Array(1))[0];
+function mangleToken(value) {
+    var length = ((Math.floor(value.length / 5 /* WordLength */) + 1) * 5 /* WordLength */);
+    var output = "" /* Empty */;
+    for (var i = 0; i < length; i++) {
+        output += i > 0 && i % 5 /* WordLength */ === 0 ? " " /* Space */ : "\u2022" /* Mask */;
     }
-    return id.toString(36);
+    return output;
 }
-function session() {
-    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Empty */ };
-    var value = getCookie("_clsk" /* SessionKey */);
-    if (value) {
-        var parts = value.split("|" /* Pipe */);
-        // Making it backward & forward compatible by using greater than comparison (v0.6.21)
-        // In future version, we can reduce the parts length to be 5 where the last part contains the full upload URL
-        if (parts.length >= 5 && output.ts - num$2(parts[1]) < 1800000 /* SessionTimeout */) {
-            output.session = parts[0];
-            output.count = num$2(parts[2]) + 1;
-            output.upgrade = num$2(parts[3]);
-            output.upload = parts.length >= 6 ? "" + "https://" /* HTTPS */ + parts[5] + "/" + parts[4] : "" + "https://" /* HTTPS */ + parts[4];
+function redact(value) {
+    var spaceIndex = -1;
+    var hasDigit = false;
+    var hasEmail = false;
+    var hasWhitespace = false;
+    var array = null;
+    for (var i = 0; i < value.length; i++) {
+        var c = value.charCodeAt(i);
+        hasDigit = hasDigit || (c >= 48 /* Zero */ && c <= 57 /* Nine */); // Check for digits in the current word
+        hasEmail = hasEmail || c === 64 /* At */; // Check for @ sign anywhere within the current word
+        hasWhitespace = c === 9 /* Tab */ || c === 10 /* NewLine */ || c === 13 /* Return */ || c === 32 /* Blank */;
+        // Process each word as an individual token to redact any sensitive information
+        if (i === 0 || i === value.length - 1 || hasWhitespace) {
+            // Performance optimization: Lazy load string -> array conversion only when required
+            if (hasDigit || hasEmail) {
+                if (array === null) {
+                    array = value.split("" /* Empty */);
+                }
+                mutate(array, spaceIndex, hasWhitespace ? i : i + 1);
+            }
+            // Reset digit and email flags after every word boundary, except the beginning of string
+            if (hasWhitespace) {
+                hasDigit = false;
+                hasEmail = false;
+                spaceIndex = i;
+            }
         }
     }
-    return output;
-}
-function num$2(string, base) {
-    if (base === void 0) { base = 10; }
-    return parseInt(string, base);
+    return array ? array.join("" /* Empty */) : value;
 }
-function user() {
-    var output = { id: shortid(), expiry: null, consent: 0 /* False */ };
-    var cookie = getCookie("_clck" /* CookieKey */);
-    if (cookie && cookie.length > 0) {
-        // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
-        var parts = cookie.split("|" /* Pipe */);
-        // For backward compatibility introduced in v0.6.18; following code can be removed with future iterations
-        // Count number of times Clarity's user cookie crumb appears in document.cookie (could be on different sub-domains e.g. www.domain.com and .domain.com)
-        var count = 0;
-        for (var _i = 0, _a = document.cookie.split(";" /* Semicolon */); _i < _a.length; _i++) {
-            var c = _a[_i];
-            count += c.split("=" /* Equals */)[0].trim() === "_clck" /* CookieKey */ ? 1 : 0;
-        }
-        // Check if we either got version-less cookie value or saw multiple copies of the user cookie crumbs
-        // In both these cases, we go ahead and delete the existing cookie set on current domain
-        if (parts.length === 1 || count > 1) {
-            var deleted = "" + ";" /* Semicolon */ + "expires=" /* Expires */ + (new Date(0)).toUTCString() + ";path=/" /* Path */;
-            // First, delete current user cookie which might be set on current sub-domain vs. root domain
-            document.cookie = "_clck" /* CookieKey */ + "=" + deleted;
-            // Second, same thing for current session cookie so it can be re-written later with the root domain
-            document.cookie = "_clsk" /* SessionKey */ + "=" + deleted;
-        }
-        // End code for backward compatibility
-        // Read version information and timestamp from cookie, if available
-        if (parts.length > 2) {
-            output.expiry = num$2(parts[2], 36);
-        }
-        // Check if we have explicit consent to track this user
-        if (parts.length > 3 && num$2(parts[3]) === 1) {
-            output.consent = 1 /* True */;
-        }
-        // Set track configuration to true for this user if we have explicit consent, regardless of project setting
-        config$1.track = config$1.track || output.consent === 1 /* True */;
-        // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
-        output.id = config$1.track ? parts[0] : output.id;
+function mutate(array, start, end) {
+    for (var i = start + 1; i < end; i++) {
+        array[i] = "\u2022" /* Mask */;
+    }
+}
+
+// Track the start time to be able to compute duration at the end of the task
+var idleTimeout = 5000;
+var tracker = {};
+var queuedTasks = [];
+var activeTask = null;
+var pauseTask = null;
+var resumeResolve = null;
+function pause$1() {
+    if (pauseTask === null) {
+        pauseTask = new Promise(function (resolve) {
+            resumeResolve = resolve;
+        });
     }
-    return output;
 }
-function getCookie(key) {
-    if (supported$1(document, "cookie" /* Cookie */)) {
-        var cookies = document.cookie.split(";" /* Semicolon */);
-        if (cookies) {
-            for (var i = 0; i < cookies.length; i++) {
-                var pair = cookies[i].split("=" /* Equals */);
-                if (pair.length > 1 && pair[0] && pair[0].trim() === key) {
-                    return pair[1];
-                }
-            }
+function resume$1() {
+    if (pauseTask) {
+        resumeResolve();
+        pauseTask = null;
+        if (activeTask === null) {
+            run();
         }
     }
-    return null;
 }
-function setCookie(key, value, time) {
-    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported$1(document, "cookie" /* Cookie */))) {
-        var expiry = new Date();
-        expiry.setDate(expiry.getDate() + time);
-        var expires = expiry ? "expires=" /* Expires */ + expiry.toUTCString() : "" /* Empty */;
-        var cookie = key + "=" + value + ";" /* Semicolon */ + expires + ";path=/" /* Path */;
-        try {
-            // Attempt to get the root domain only once and fall back to writing cookie on the current domain.
-            if (rootDomain === null) {
-                var hostname = location.hostname ? location.hostname.split("." /* Dot */) : [];
-                // Walk backwards on a domain and attempt to set a cookie, until successful
-                for (var i = hostname.length - 1; i >= 0; i--) {
-                    rootDomain = "." + hostname[i] + (rootDomain ? rootDomain : "" /* Empty */);
-                    // We do not wish to attempt writing a cookie on the absolute last part of the domain, e.g. .com or .net.
-                    // So we start attempting after second-last part, e.g. .domain.com (PASS) or .co.uk (FAIL)
-                    if (i < hostname.length - 1) {
-                        // Write the cookie on the current computed top level domain
-                        document.cookie = "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain;
-                        // Once written, check if the cookie exists and its value matches exactly with what we intended to set
-                        // Checking for exact value match helps us eliminate a corner case where the cookie may already be present with a different value
-                        // If the check is successful, no more action is required and we can return from the function since rootDomain cookie is already set
-                        // If the check fails, continue with the for loop until we can successfully set and verify the cookie
-                        if (getCookie(key) === value) {
-                            return;
-                        }
-                    }
+function reset$j() {
+    tracker = {};
+    queuedTasks = [];
+    activeTask = null;
+    pauseTask = null;
+}
+function schedule$1(task, priority) {
+    if (priority === void 0) { priority = 0 /* Normal */; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _i, queuedTasks_1, q, promise;
+        return __generator(this, function (_a) {
+            // If this task is already scheduled, skip it
+            for (_i = 0, queuedTasks_1 = queuedTasks; _i < queuedTasks_1.length; _i++) {
+                q = queuedTasks_1[_i];
+                if (q.task === task) {
+                    return [2 /*return*/];
                 }
-                // Finally, if we were not successful and gone through all the options, play it safe and reset rootDomain to be empty
-                // This forces our code to fall back to always writing cookie to the current domain
-                rootDomain = "" /* Empty */;
             }
-        }
-        catch (_a) {
-            rootDomain = "" /* Empty */;
-        }
-        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
-    }
-}
-
-var metadata$2 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$g; },
-    get callback () { return callback; },
-    start: start$B,
-    stop: stop$y,
-    metadata: metadata$1,
-    id: id,
-    consent: consent,
-    clear: clear,
-    save: save
-});
-
-var history$4;
-function reset$m() {
-    history$4 = [];
+            promise = new Promise(function (resolve) {
+                var insert = priority === 1 /* High */ ? "unshift" : "push";
+                // Queue this task for asynchronous execution later
+                // We also store a unique page identifier (id) along with the task to ensure
+                // ensure that we do not accidentally execute this task in context of a different page
+                queuedTasks[insert]({ task: task, resolve: resolve, id: id() });
+            });
+            // If there is no active task running, and Clarity is not in pause state,
+            // invoke the first task in the queue synchronously. This ensures that we don't yield the thread during unload event
+            if (activeTask === null && pauseTask === null) {
+                run();
+            }
+            return [2 /*return*/, promise];
+        });
+    });
 }
-function report(check, message) {
-    if (message === void 0) { message = null; }
-    // Do not report the same message twice for the same page
-    if (history$4 && history$4.indexOf(message) === -1) {
-        var url = config$1.report;
-        if (url && url.length > 0) {
-            var payload = { c: check, p: data$g.projectId, u: data$g.userId, s: data$g.sessionId, n: data$g.pageNum };
-            if (message)
-                payload.m = message;
-            // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
-            // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
-            var xhr = new XMLHttpRequest();
-            xhr.open("POST", url);
-            xhr.send(JSON.stringify(payload));
-            history$4.push(message);
-        }
+function run() {
+    var entry = queuedTasks.shift();
+    if (entry) {
+        activeTask = entry;
+        entry.task().then(function () {
+            // Bail out if the context in which this task was operating is different from the current page
+            // An example scenario where task could span across pages is Single Page Applications (SPA)
+            // A task that started on page #1, but completes on page #2
+            if (entry.id !== id()) {
+                return;
+            }
+            entry.resolve();
+            activeTask = null; // Reset active task back to null now that the promise is resolved
+            run();
+        }).catch(function (error) {
+            // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
+            if (entry.id !== id()) {
+                return;
+            }
+            if (error) {
+                log$1(0 /* RunTask */, 1 /* Warning */, error.name, error.message, error.stack);
+            }
+            activeTask = null;
+            run();
+        });
     }
-}
-
-var version$1 = "0.6.27";
-
-var data$f = null;
-function start$A() {
-    var m = data$g;
-    data$f = {
-        version: version$1,
-        sequence: 0,
-        start: 0,
-        duration: 0,
-        projectId: m.projectId,
-        userId: m.userId,
-        sessionId: m.sessionId,
-        pageNum: m.pageNum,
-        upload: 0 /* Async */,
-        end: 0 /* False */
-    };
-}
-function stop$x() {
-    data$f = null;
 }
-function envelope(last) {
-    data$f.start = data$f.start + data$f.duration;
-    data$f.duration = time() - data$f.start;
-    data$f.sequence++;
-    data$f.upload = last && "sendBeacon" in navigator ? 1 /* Beacon */ : 0 /* Async */;
-    data$f.end = last ? 1 /* True */ : 0 /* False */;
-    return [
-        data$f.version,
-        data$f.sequence,
-        data$f.start,
-        data$f.duration,
-        data$f.projectId,
-        data$f.userId,
-        data$f.sessionId,
-        data$f.pageNum,
-        data$f.upload,
-        data$f.end
-    ];
-}
-
-var envelope$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$f; },
-    start: start$A,
-    stop: stop$x,
-    envelope: envelope
-});
-
-var data$e;
-function start$z() {
-    data$e = { check: 0 /* None */ };
-}
-function check$3(bytes) {
-    if (data$e.check === 0 /* None */) {
-        var reason = data$e.check;
-        reason = data$f.sequence >= 128 /* PayloadLimit */ ? 1 /* Payload */ : reason;
-        reason = time() > 7200000 /* ShutdownLimit */ ? 2 /* Shutdown */ : reason;
-        reason = bytes > 10485760 /* PlaybackBytesLimit */ ? 2 /* Shutdown */ : reason;
-        if (reason !== data$e.check) {
-            trigger$1(reason);
-        }
+function state$8(timer) {
+    var id = key(timer);
+    if (id in tracker) {
+        var elapsed = performance.now() - tracker[id].start;
+        return (elapsed > tracker[id].yield) ? 0 /* Wait */ : 1 /* Run */;
     }
+    // If this task is no longer being tracked, send stop message to the caller
+    return 2 /* Stop */;
 }
-function trigger$1(reason) {
-    report(reason);
-    data$e.check = reason;
-    clear();
-    stop();
+function start$w(timer) {
+    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
 }
-function compute$a() {
-    if (data$e.check !== 0 /* None */) {
-        encode$1(35 /* Limit */);
+function restart$1(timer) {
+    var id = key(timer);
+    if (tracker && tracker[id]) {
+        var c = tracker[id].calls;
+        var y = tracker[id].yield;
+        start$w(timer);
+        tracker[id].calls = c + 1;
+        tracker[id].yield = y;
     }
 }
-function stop$w() {
-    data$e = null;
-}
-
-var limit = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$e; },
-    start: start$z,
-    check: check$3,
-    trigger: trigger$1,
-    compute: compute$a,
-    stop: stop$w
-});
-
-var data$d = null;
-var updates$3 = null;
-function start$y() {
-    data$d = {};
-    updates$3 = {};
+function stop$t(timer) {
+    var end = performance.now();
+    var id = key(timer);
+    var duration = end - tracker[id].start;
+    sum(timer.cost, duration);
+    count$1(5 /* InvokeCount */);
+    // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
+    // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
+    if (tracker[id].calls > 0) {
+        sum(4 /* TotalCost */, duration);
+    }
 }
-function stop$v() {
-    data$d = {};
-    updates$3 = {};
-}
-function log$1(dimension, value) {
-    // Check valid value before moving ahead
-    if (value) {
-        // Ensure received value is casted into a string if it wasn't a string to begin with
-        value = "" + value;
-        if (!(dimension in data$d)) {
-            data$d[dimension] = [];
-        }
-        if (data$d[dimension].indexOf(value) < 0) {
-            data$d[dimension].push(value);
-            // If this is a new value, track it as part of updates object
-            // This allows us to only send back new values in subsequent payloads
-            if (!(dimension in updates$3)) {
-                updates$3[dimension] = [];
-            }
-            updates$3[dimension].push(value);
-            // Limit check to ensure we have a cap on number of dimensions we can collect
-            if (data$d[dimension].length > 128 /* CollectionLimit */) {
-                trigger$1(5 /* Collection */);
+function suspend$1(timer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    id = key(timer);
+                    if (!(id in tracker)) return [3 /*break*/, 2];
+                    stop$t(timer);
+                    _a = tracker[id];
+                    return [4 /*yield*/, wait()];
+                case 1:
+                    _a.yield = (_b.sent()).timeRemaining();
+                    restart$1(timer);
+                    _b.label = 2;
+                case 2: 
+                // After we are done with suspending task, ensure that we are still operating in the right context
+                // If the task is still being tracked, continue running the task, otherwise ask caller to stop execution
+                return [2 /*return*/, id in tracker ? 1 /* Run */ : 2 /* Stop */];
             }
-        }
-    }
-}
-function compute$9() {
-    encode$1(1 /* Dimension */);
-}
-function reset$l() {
-    updates$3 = {};
-}
-
-var dimension = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$d; },
-    get updates () { return updates$3; },
-    start: start$y,
-    stop: stop$v,
-    log: log$1,
-    compute: compute$9,
-    reset: reset$l
-});
-
-function setTimeout(handler, timeout, event) {
-    return window.setTimeout(measure(handler), timeout, event);
+        });
+    });
 }
-function clearTimeout(handle) {
-    return window.clearTimeout(handle);
-}
-
-var data$c;
-var last = 0;
-var interval = 0;
-var timeout$6 = null;
-function start$x() {
-    interval = 60000 /* PingInterval */;
-    last = 0;
+function key(timer) {
+    return timer.id + "." + timer.cost;
 }
-function reset$k() {
-    if (timeout$6) {
-        clearTimeout(timeout$6);
-    }
-    timeout$6 = setTimeout(ping, interval);
-    last = time();
+function wait() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!pauseTask) return [3 /*break*/, 2];
+                    return [4 /*yield*/, pauseTask];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, new Promise(function (resolve) {
+                        requestIdleCallback(resolve, { timeout: idleTimeout });
+                    })];
+            }
+        });
+    });
 }
-function ping() {
-    var now = time();
-    data$c = { gap: now - last };
-    encode$1(25 /* Ping */);
-    if (data$c.gap < 300000 /* PingTimeout */) {
-        timeout$6 = setTimeout(ping, interval);
-    }
-    else {
-        suspend();
-    }
+// Use native implementation of requestIdleCallback if it exists.
+// Otherwise, fall back to a custom implementation using requestAnimationFrame & MessageChannel.
+// While it's not possible to build a perfect polyfill given the nature of this API, the following code attempts to get close.
+// Background context: requestAnimationFrame invokes the js code right before: style, layout and paint computation within the frame.
+// This means, that any code that runs as part of requestAnimationFrame will by default be blocking in nature. Not what we want.
+// For non-blocking behavior, We need to know when browser has finished painiting. This can be accomplished in two different ways (hacks):
+//   (1) Use MessageChannel to pass the message, and browser will receive the message right after pain event has occured.
+//   (2) Use setTimeout call within requestAnimationFrame. This also works, but there's a risk that browser may throttle setTimeout calls.
+// Given this information, we are currently using (1) from above. More information on (2) as well as some additional context is below:
+// https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Performance_best_practices_for_Firefox_fe_engineers
+function requestIdleCallbackPolyfill(callback, options) {
+    var startTime = performance.now();
+    var channel = new MessageChannel();
+    var incoming = channel.port1;
+    var outgoing = channel.port2;
+    incoming.onmessage = function (event) {
+        var currentTime = performance.now();
+        var elapsed = currentTime - startTime;
+        var duration = currentTime - event.data;
+        if (duration > 30 /* LongTask */ && elapsed < options.timeout) {
+            requestAnimationFrame(function () { outgoing.postMessage(currentTime); });
+        }
+        else {
+            var didTimeout_1 = elapsed > options.timeout;
+            callback({
+                didTimeout: didTimeout_1,
+                timeRemaining: function () { return didTimeout_1 ? 30 /* LongTask */ : Math.max(0, 30 /* LongTask */ - duration); }
+            });
+        }
+    };
+    requestAnimationFrame(function () { outgoing.postMessage(performance.now()); });
 }
-function stop$u() {
-    clearTimeout(timeout$6);
-    last = 0;
-    interval = 0;
-}
-
-var ping$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$c; },
-    start: start$x,
-    reset: reset$k,
-    stop: stop$u
-});
+var requestIdleCallback = window["requestIdleCallback"] || requestIdleCallbackPolyfill;
 
-var data$b = null;
-function start$w() {
-    data$b = {};
-}
-function stop$t() {
-    data$b = {};
-}
-function track$5(event, time) {
-    if (!(event in data$b)) {
-        data$b[event] = [[time, 0]];
-    }
-    else {
-        var e = data$b[event];
-        var last = e[e.length - 1];
-        // Add a new entry only if the new event occurs after configured interval
-        // Otherwise, extend the duration of the previous entry
-        if (time - last[0] > 100 /* SummaryInterval */) {
-            data$b[event].push([time, 0]);
+// Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
+// The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
+// If so, it replaces the token with its reference (index). This helps us save bytes by not repeating the same value twice.
+// E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
+// Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
+// Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
+function tokenize (tokens) {
+    var output = [];
+    var lookup = {};
+    var pointer = 0;
+    var reference = null;
+    for (var i = 0; i < tokens.length; i++) {
+        // Only optimize for string values
+        if (typeof tokens[i] === "string" /* String */) {
+            var token = tokens[i];
+            var index = lookup[token] || -1;
+            if (index >= 0) {
+                if (reference) {
+                    reference.push(index);
+                }
+                else {
+                    reference = [index];
+                    output.push(reference);
+                    pointer++;
+                }
+            }
+            else {
+                reference = null;
+                output.push(token);
+                lookup[token] = pointer++;
+            }
         }
         else {
-            last[1] = time - last[0];
+            // If the value is anything other than string, append it as it is to the output array
+            // And, also increment the pointer to stay in sync with output array
+            reference = null;
+            output.push(tokens[i]);
+            pointer++;
         }
     }
-}
-function compute$8() {
-    encode$1(36 /* Summary */);
-}
-function reset$j() {
-    data$b = {};
+    return output;
 }
 
-var summary = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$b; },
-    start: start$w,
-    stop: stop$t,
-    track: track$5,
-    compute: compute$8,
-    reset: reset$j
-});
-
-var data$a = null;
+var data$c;
+function reset$i() {
+    data$c = null;
+}
 function start$v() {
-    if (!config$1.lean && config$1.upgrade) {
-        config$1.upgrade("Config" /* Config */);
-    }
-    data$a = null;
+    reset$i();
+    compute$7();
 }
-// Following call will upgrade the session from lean mode into the full mode retroactively from the start of the page.
-// As part of the lean mode, we do not send back any layout information - including discovery of DOM and mutations.
-// However, if there's a need for full fidelity playback, calling this function will disable lean mode
-// and send all backed up layout events to the server.
-function upgrade(key) {
-    // Upgrade only if Clarity was successfully activated on the page
-    if (active() && config$1.lean) {
-        config$1.lean = false;
-        data$a = { key: key };
-        // Update metadata to track we have upgraded this session
-        save();
-        // Callback upgrade handler, if configured
-        if (config$1.upgrade) {
-            config$1.upgrade(key);
-        }
-        encode$1(3 /* Upgrade */);
+function compute$7() {
+    var body = document.body;
+    var d = document.documentElement;
+    var bodyClientWidth = body ? body.clientWidth : null;
+    var bodyScrollWidth = body ? body.scrollWidth : null;
+    var bodyOffsetWidth = body ? body.offsetWidth : null;
+    var documentClientWidth = d ? d.clientWidth : null;
+    var documentScrollWidth = d ? d.scrollWidth : null;
+    var documentOffsetWidth = d ? d.offsetWidth : null;
+    var width = Math.max(bodyClientWidth, bodyScrollWidth, bodyOffsetWidth, documentClientWidth, documentScrollWidth, documentOffsetWidth);
+    var bodyClientHeight = body ? body.clientHeight : null;
+    var bodyScrollHeight = body ? body.scrollHeight : null;
+    var bodyOffsetHeight = body ? body.offsetHeight : null;
+    var documentClientHeight = d ? d.clientHeight : null;
+    var documentScrollHeight = d ? d.scrollHeight : null;
+    var documentOffsetHeight = d ? d.offsetHeight : null;
+    var height = Math.max(bodyClientHeight, bodyScrollHeight, bodyOffsetHeight, documentClientHeight, documentScrollHeight, documentOffsetHeight);
+    // Check that width or height has changed from before, and also that width & height are not null values
+    if ((data$c === null || width !== data$c.width || height !== data$c.height) && width !== null && height !== null) {
+        data$c = { width: width, height: height };
+        encode$4(8 /* Document */);
     }
 }
-function stop$s() {
-    data$a = null;
+function end() {
+    reset$i();
 }
 
-var upgrade$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get data () { return data$a; },
-    start: start$v,
-    upgrade: upgrade,
-    stop: stop$s
-});
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-var supported = "CompressionStream" /* CompressionStream */ in window;
-function compress (input) {
-    return __awaiter(this, void 0, void 0, function () {
-        var stream, _a;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _c.trys.push([0, 3, , 4]);
-                    if (!supported) return [3 /*break*/, 2];
-                    stream = new ReadableStream({ start: function (controller) {
-                            return __awaiter(this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    controller.enqueue(input);
-                                    controller.close();
-                                    return [2 /*return*/];
-                                });
-                            });
-                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* CompressionStream */]("gzip"));
-                    _a = Uint8Array.bind;
-                    return [4 /*yield*/, read(stream)];
-                case 1: return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _c.sent()]))()];
-                case 2: return [3 /*break*/, 4];
-                case 3:
-                    _c.sent();
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, null];
-            }
-        });
-    });
-}
-function read(stream) {
+function encode$4 (type, timer, ts) {
+    if (timer === void 0) { timer = null; }
+    if (ts === void 0) { ts = null; }
     return __awaiter(this, void 0, void 0, function () {
-        var reader, chunks, done, value;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var eventTime, tokens, _a, d, _i, _b, r, b, _c, b_1, entry, values, _d, values_1, value, state, data, active, suspend, privacy, mangle, keys, _e, keys_1, key, size, factor, attr;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
-                    reader = stream.getReader();
-                    chunks = [];
-                    done = false;
-                    value = [];
-                    _b.label = 1;
+                    eventTime = ts || time();
+                    tokens = [eventTime, type];
+                    _a = type;
+                    switch (_a) {
+                        case 8 /* Document */: return [3 /*break*/, 1];
+                        case 7 /* Region */: return [3 /*break*/, 2];
+                        case 37 /* Box */: return [3 /*break*/, 3];
+                        case 5 /* Discover */: return [3 /*break*/, 4];
+                        case 6 /* Mutation */: return [3 /*break*/, 4];
+                    }
+                    return [3 /*break*/, 11];
                 case 1:
-                    if (!!done) return [3 /*break*/, 3];
-                    return [4 /*yield*/, reader.read()];
+                    d = data$c;
+                    tokens.push(d.width);
+                    tokens.push(d.height);
+                    track$7(type, d.width, d.height);
+                    queue(tokens);
+                    return [3 /*break*/, 11];
                 case 2:
-                    (_a = _b.sent(), done = _a.done, value = _a.value);
-                    if (done) {
-                        return [2 /*return*/, chunks];
+                    for (_i = 0, _b = state$7; _i < _b.length; _i++) {
+                        r = _b[_i];
+                        tokens = [r.time, 7 /* Region */];
+                        tokens.push(r.data.id);
+                        tokens.push(r.data.interaction);
+                        tokens.push(r.data.visibility);
+                        tokens.push(r.data.name);
+                        queue(tokens);
                     }
-                    chunks.push.apply(chunks, value);
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/, chunks];
+                    reset$f();
+                    return [3 /*break*/, 11];
+                case 3:
+                    b = data$b;
+                    for (_c = 0, b_1 = b; _c < b_1.length; _c++) {
+                        entry = b_1[_c];
+                        tokens.push(entry.id);
+                        tokens.push(entry.width);
+                        tokens.push(entry.height);
+                    }
+                    reset$h();
+                    queue(tokens);
+                    return [3 /*break*/, 11];
+                case 4:
+                    // Check if we are operating within the context of the current page
+                    if (state$8(timer) === 2 /* Stop */) {
+                        return [3 /*break*/, 11];
+                    }
+                    values = updates$2();
+                    if (!(values.length > 0)) return [3 /*break*/, 10];
+                    _d = 0, values_1 = values;
+                    _f.label = 5;
+                case 5:
+                    if (!(_d < values_1.length)) return [3 /*break*/, 9];
+                    value = values_1[_d];
+                    state = state$8(timer);
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, suspend$1(timer)];
+                case 6:
+                    state = _f.sent();
+                    _f.label = 7;
+                case 7:
+                    if (state === 2 /* Stop */) {
+                        return [3 /*break*/, 9];
+                    }
+                    data = value.data;
+                    active = value.metadata.active;
+                    suspend = value.metadata.suspend;
+                    privacy = value.metadata.privacy;
+                    mangle = shouldMangle(value);
+                    keys = active ? ["tag", "attributes", "value"] : ["tag"];
+                    compute$6(value.id);
+                    for (_e = 0, keys_1 = keys; _e < keys_1.length; _e++) {
+                        key = keys_1[_e];
+                        if (data[key]) {
+                            switch (key) {
+                                case "tag":
+                                    size = value.metadata.size;
+                                    factor = mangle ? -1 : 1;
+                                    tokens.push(value.id * factor);
+                                    if (value.parent && active) {
+                                        tokens.push(value.parent);
+                                    }
+                                    if (value.previous && active) {
+                                        tokens.push(value.previous);
+                                    }
+                                    tokens.push(suspend ? "*M" /* SuspendMutationTag */ : data[key]);
+                                    if (size && size.length === 2) {
+                                        tokens.push("" + "#" /* Box */ + str$1(size[0]) + "." + str$1(size[1]));
+                                    }
+                                    break;
+                                case "attributes":
+                                    for (attr in data[key]) {
+                                        if (data[key][attr] !== undefined) {
+                                            tokens.push(attribute(attr, data[key][attr], privacy));
+                                        }
+                                    }
+                                    break;
+                                case "value":
+                                    tokens.push(scrub(data[key], data.tag, privacy, mangle));
+                                    break;
+                            }
+                        }
+                    }
+                    _f.label = 8;
+                case 8:
+                    _d++;
+                    return [3 /*break*/, 5];
+                case 9:
+                    if (type === 6 /* Mutation */) {
+                        activity(eventTime);
+                    }
+                    queue(tokenize(tokens), !config$1.lean);
+                    _f.label = 10;
+                case 10: return [3 /*break*/, 11];
+                case 11: return [2 /*return*/];
             }
         });
     });
+}
+function shouldMangle(value) {
+    var privacy = value.metadata.privacy;
+    return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
+}
+function str$1(input) {
+    return input.toString(36);
+}
+function attribute(key, value, privacy) {
+    return key + "=" + scrub(value, key, privacy);
 }
 
-var modules$1 = [baseline, dimension, variable, limit, summary, metadata$2, envelope$1, upload$1, ping$1, upgrade$1];
+var data$b = [];
+var enabled = false;
+var observer$2 = null;
 function start$u() {
-    // Metric needs to be initialized before we can start measuring. so metric is not wrapped in measure
-    start$8();
-    modules$1.forEach(function (x) { return measure(x.start)(); });
+    reset$h();
+    observer$2 = null;
+    enabled = window["ResizeObserver"] ? true : false;
 }
-function stop$r() {
-    // Stop modules in the reverse order of their initialization
-    // The ordering below should respect inter-module dependency.
-    // E.g. if upgrade depends on upload, then upgrade needs to end before upload.
-    // Similarly, if upload depends on metadata, upload needs to end before metadata.
-    modules$1.slice().reverse().forEach(function (x) { return measure(x.stop)(); });
-    stop$7();
+function compute$6(id) {
+    if (enabled === false) {
+        return;
+    }
+    observer$2 = observer$2 === null ? new ResizeObserver(handler$4) : observer$2;
+    if (observer$2) {
+        var value = getValue(id);
+        // If this is the first time computing size for this node, go ahead and wire up ResizeObserver
+        // In all other cases, value.metadata.size will be null or an array with two elements [width, height]
+        // And, in those cases, we will skip through the following section and not attach the observer
+        if (value && value.metadata.size !== null && value.metadata.size.length === 0) {
+            var node = getNode(id);
+            if (node && node.nodeType === Node.ELEMENT_NODE) {
+                var e = node;
+                var r = e.getBoundingClientRect();
+                value.metadata.size = [Math.floor(r.width * 100 /* BoxPrecision */), Math.floor(r.height * 100 /* BoxPrecision */)];
+                observer$2.observe(e);
+            }
+        }
+    }
 }
-function compute$7() {
-    compute$b();
-    compute$c();
-    compute$9();
-    compute$2();
-    compute$8();
-    compute$a();
-}
-
-function scrub (value, hint, privacy, mangle) {
-    if (mangle === void 0) { mangle = false; }
-    if (value) {
-        switch (privacy) {
-            case 0 /* None */:
-                return value;
-            case 1 /* Sensitive */:
-                switch (hint) {
-                    case "*T" /* TextTag */:
-                    case "value":
-                    case "placeholder":
-                        return redact(value);
-                    case "input":
-                        return mangleToken(value);
+function handler$4(entries) {
+    window.requestAnimationFrame(function () {
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var entry = entries_1[_i];
+            var target = entry.target;
+            var id = target ? getId(target) : null;
+            if (id) {
+                var v = getValue(id);
+                var s = v.metadata.size;
+                var b = entry.borderBoxSize;
+                var w = null;
+                var h = null;
+                // Check if browser supports borderBoxSize property on ResizeObserverEntry object
+                // Otherwise, fall back to using getBoundingClientRect() to be cross browser compatible
+                // Reference: https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry/borderBoxSize
+                if (b && b.length > 0) {
+                    w = Math.floor(b[0].inlineSize * 100 /* BoxPrecision */);
+                    h = Math.floor(b[0].blockSize * 100 /* BoxPrecision */);
                 }
-                return value;
-            case 2 /* Text */:
-            case 3 /* TextImage */:
-                switch (hint) {
-                    case "*T" /* TextTag */:
-                        return mangle ? mangleText(value) : mask(value);
-                    case "src":
-                    case "srcset":
-                    case "title":
-                    case "alt":
-                        return privacy === 3 /* TextImage */ ? "" /* Empty */ : value;
-                    case "value":
-                    case "click":
-                    case "input":
-                        return mangleToken(value);
-                    case "placeholder":
-                        return mask(value);
+                else {
+                    var r = target.getBoundingClientRect();
+                    w = Math.floor(r.width * 100 /* BoxPrecision */);
+                    h = Math.floor(r.height * 100 /* BoxPrecision */);
                 }
-                break;
-        }
-    }
-    return value;
-}
-function mangleText(value) {
-    var trimmed = value.trim();
-    if (trimmed.length > 0) {
-        var first = trimmed[0];
-        var index = value.indexOf(first);
-        var prefix = value.substr(0, index);
-        var suffix = value.substr(index + trimmed.length);
-        return "" + prefix + trimmed.length.toString(36) + suffix;
-    }
-    return value;
-}
-function mask(value) {
-    return value.replace(/\S/gi, "\u2022" /* Mask */);
-}
-function mangleToken(value) {
-    var length = ((Math.floor(value.length / 5 /* WordLength */) + 1) * 5 /* WordLength */);
-    var output = "" /* Empty */;
-    for (var i = 0; i < length; i++) {
-        output += i > 0 && i % 5 /* WordLength */ === 0 ? " " /* Space */ : "\u2022" /* Mask */;
-    }
-    return output;
-}
-function redact(value) {
-    var spaceIndex = -1;
-    var hasDigit = false;
-    var hasEmail = false;
-    var hasWhitespace = false;
-    var array = null;
-    for (var i = 0; i < value.length; i++) {
-        var c = value.charCodeAt(i);
-        hasDigit = hasDigit || (c >= 48 /* Zero */ && c <= 57 /* Nine */); // Check for digits in the current word
-        hasEmail = hasEmail || c === 64 /* At */; // Check for @ sign anywhere within the current word
-        hasWhitespace = c === 9 /* Tab */ || c === 10 /* NewLine */ || c === 13 /* Return */ || c === 32 /* Blank */;
-        // Process each word as an individual token to redact any sensitive information
-        if (i === 0 || i === value.length - 1 || hasWhitespace) {
-            // Performance optimization: Lazy load string -> array conversion only when required
-            if (hasDigit || hasEmail) {
-                if (array === null) {
-                    array = value.split("" /* Empty */);
+                // Capture new width & height only if they are different from what we have in in-memory cache
+                if (w !== s[0] && h !== s[1]) {
+                    s = [w, h];
+                    data$b.push({ id: id, width: w, height: h });
                 }
-                mutate(array, spaceIndex, hasWhitespace ? i : i + 1);
-            }
-            // Reset digit and email flags after every word boundary, except the beginning of string
-            if (hasWhitespace) {
-                hasDigit = false;
-                hasEmail = false;
-                spaceIndex = i;
             }
         }
-    }
-    return array ? array.join("" /* Empty */) : value;
+        // Schedule encode only when we have at least one valid data entry
+        if (data$b.length > 0) {
+            encode$4(37 /* Box */);
+        }
+    });
 }
-function mutate(array, start, end) {
-    for (var i = start + 1; i < end; i++) {
-        array[i] = "\u2022" /* Mask */;
+function reset$h() {
+    data$b = [];
+}
+function stop$s() {
+    reset$h();
+    if (observer$2) {
+        observer$2.disconnect();
+        observer$2 = null;
     }
+    enabled = false;
 }
 
-// Track the start time to be able to compute duration at the end of the task
-var idleTimeout = 5000;
-var tracker = {};
-var queuedTasks = [];
-var activeTask = null;
-var pauseTask = null;
-var resumeResolve = null;
-function pause$1() {
-    if (pauseTask === null) {
-        pauseTask = new Promise(function (resolve) {
-            resumeResolve = resolve;
-        });
-    }
+var history$4 = {};
+var data$a;
+function start$t() {
+    bind(window, "error", handler$3);
+    history$4 = {};
 }
-function resume$1() {
-    if (pauseTask) {
-        resumeResolve();
-        pauseTask = null;
-        if (activeTask === null) {
-            run();
+function handler$3(error) {
+    var e = error["error"] || error;
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure first few times and not spam logs with redundant information.
+    if (!(e.message in history$4)) {
+        history$4[e.message] = 0;
+    }
+    if (history$4[e.message]++ >= 5 /* ScriptErrorLimit */) {
+        return true;
+    }
+    // Send back information only if the handled error has valid information
+    if (e && e.message) {
+        data$a = {
+            message: e.message,
+            line: error["lineno"],
+            column: error["colno"],
+            stack: e.stack,
+            source: error["filename"]
+        };
+        // In certain cases, ResizeObserver could lead to flood of benign errors - especially when video element is involved.
+        // Reference Chromium issue: https://bugs.chromium.org/p/chromium/issues/detail?id=809574
+        // Even though it doesn't impact user experience, or show up in console, it can still flood error reporting through on error
+        // To mitigate that, we turn off Clarity's ResizeObserver on getting the first instance of this error
+        if (e.message.indexOf("ResizeObserver" /* ResizeObserver */) >= 0) {
+            stop$s();
+            return false;
         }
+        encode$3(31 /* ScriptError */);
     }
-}
-function reset$i() {
-    tracker = {};
-    queuedTasks = [];
-    activeTask = null;
-    pauseTask = null;
-}
-function schedule$1(task, priority) {
-    if (priority === void 0) { priority = 0 /* Normal */; }
+    return true;
+}
+
+function encode$3 (type) {
     return __awaiter(this, void 0, void 0, function () {
-        var _i, queuedTasks_1, q, promise;
+        var tokens;
         return __generator(this, function (_a) {
-            // If this task is already scheduled, skip it
-            for (_i = 0, queuedTasks_1 = queuedTasks; _i < queuedTasks_1.length; _i++) {
-                q = queuedTasks_1[_i];
-                if (q.task === task) {
-                    return [2 /*return*/];
-                }
-            }
-            promise = new Promise(function (resolve) {
-                var insert = priority === 1 /* High */ ? "unshift" : "push";
-                // Queue this task for asynchronous execution later
-                // We also store a unique page identifier (id) along with the task to ensure
-                // ensure that we do not accidentally execute this task in context of a different page
-                queuedTasks[insert]({ task: task, resolve: resolve, id: id() });
-            });
-            // If there is no active task running, and Clarity is not in pause state,
-            // invoke the first task in the queue synchronously. This ensures that we don't yield the thread during unload event
-            if (activeTask === null && pauseTask === null) {
-                run();
+            tokens = [time(), type];
+            switch (type) {
+                case 31 /* ScriptError */:
+                    tokens.push(data$a.message);
+                    tokens.push(data$a.line);
+                    tokens.push(data$a.column);
+                    tokens.push(data$a.stack);
+                    tokens.push(data$a.source);
+                    queue(tokens);
+                    break;
+                case 33 /* Log */:
+                    if (data$9) {
+                        tokens.push(data$9.code);
+                        tokens.push(data$9.name);
+                        tokens.push(data$9.message);
+                        tokens.push(data$9.stack);
+                        tokens.push(data$9.severity);
+                        queue(tokens, false);
+                    }
+                    break;
             }
-            return [2 /*return*/, promise];
+            return [2 /*return*/];
         });
     });
+}
+
+var history$3 = {};
+var data$9;
+function start$s() {
+    history$3 = {};
+    bind(document, "securitypolicyviolation", csp);
 }
-function run() {
-    var entry = queuedTasks.shift();
-    if (entry) {
-        activeTask = entry;
-        entry.task().then(function () {
-            // Bail out if the context in which this task was operating is different from the current page
-            // An example scenario where task could span across pages is Single Page Applications (SPA)
-            // A task that started on page #1, but completes on page #2
-            if (entry.id !== id()) {
-                return;
-            }
-            entry.resolve();
-            activeTask = null; // Reset active task back to null now that the promise is resolved
-            run();
-        }).catch(function (error) {
-            // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
-            if (entry.id !== id()) {
-                return;
-            }
-            if (error) {
-                log(0 /* RunTask */, 1 /* Warning */, error.name, error.message, error.stack);
-            }
-            activeTask = null;
-            run();
-        });
+function log$1(code, severity, name, message, stack) {
+    if (name === void 0) { name = null; }
+    if (message === void 0) { message = null; }
+    if (stack === void 0) { stack = null; }
+    var key = name ? name + "|" + message : "";
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure once and not spam logs with redundant information.
+    if (code in history$3 && history$3[code].indexOf(key) >= 0) {
+        return;
+    }
+    data$9 = { code: code, name: name, message: message, stack: stack, severity: severity };
+    // Maintain history of errors in memory to avoid sending redundant information
+    if (code in history$3) {
+        history$3[code].push(key);
     }
+    else {
+        history$3[code] = [key];
+    }
+    encode$3(33 /* Log */);
 }
-function state$8(timer) {
-    var id = key(timer);
-    if (id in tracker) {
-        var elapsed = performance.now() - tracker[id].start;
-        return (elapsed > tracker[id].yield) ? 0 /* Wait */ : 1 /* Run */;
+function csp(e) {
+    var upload = config$1.upload;
+    // Look for first "/" starting after initial "https://" string
+    var parts = upload && typeof upload === "string" /* String */ ? upload.substr(0, upload.indexOf("/", "https://" /* HTTPS */.length)).split("." /* Dot */) : [];
+    var domain = parts.length >= 2 ? parts.splice(-2).join("." /* Dot */) : null;
+    // Capture content security policy violation only if disposition value is not explicitly set to "report"
+    if (domain && e.blockedURI && e.blockedURI.indexOf(domain) >= 0 && e["disposition"] !== "report" /* Report */) {
+        log$1(7 /* ContentSecurityPolicy */, 1 /* Warning */, e.blockedURI);
     }
-    // If this task is no longer being tracked, send stop message to the caller
-    return 2 /* Stop */;
 }
-function start$t(timer) {
-    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
-}
-function restart$1(timer) {
-    var id = key(timer);
-    if (tracker && tracker[id]) {
-        var c = tracker[id].calls;
-        var y = tracker[id].yield;
-        start$t(timer);
-        tracker[id].calls = c + 1;
-        tracker[id].yield = y;
-    }
-}
-function stop$q(timer) {
-    var end = performance.now();
-    var id = key(timer);
-    var duration = end - tracker[id].start;
-    sum(timer.cost, duration);
-    count$1(5 /* InvokeCount */);
-    // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
-    // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
-    if (tracker[id].calls > 0) {
-        sum(4 /* TotalCost */, duration);
+function stop$r() {
+    history$3 = {};
+}
+
+var formatRegex = /1/g;
+var digitsRegex$1 = /[^0-9\.]/g;
+var digitsWithCommaRegex = /[^0-9\.,]/g;
+var regexCache = {};
+function regions$1(root, value) {
+    var _loop_1 = function (v) {
+        var regionId = v[0], selector = v[1], filter = v[2], match = v[3];
+        var valid = true;
+        switch (filter) {
+            case 0 /* Url */:
+                valid = match && !!top.location.href.match(regex(match));
+                break;
+            case 1 /* Javascript */:
+                valid = match && !!evaluate(match);
+                break;
+        }
+        if (valid) {
+            root.querySelectorAll(selector).forEach(function (e) { return observe$b(e, regionId.toString()); });
+        }
+    };
+    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+        var v = value_1[_i];
+        _loop_1(v);
     }
 }
-function suspend$1(timer) {
-    return __awaiter(this, void 0, void 0, function () {
-        var id, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    id = key(timer);
-                    if (!(id in tracker)) return [3 /*break*/, 2];
-                    stop$q(timer);
-                    _a = tracker[id];
-                    return [4 /*yield*/, wait()];
-                case 1:
-                    _a.yield = (_b.sent()).timeRemaining();
-                    restart$1(timer);
-                    _b.label = 2;
-                case 2: 
-                // After we are done with suspending task, ensure that we are still operating in the right context
-                // If the task is still being tracked, continue running the task, otherwise ask caller to stop execution
-                return [2 /*return*/, id in tracker ? 1 /* Run */ : 2 /* Stop */];
-            }
-        });
-    });
-}
-function key(timer) {
-    return timer.id + "." + timer.cost;
-}
-function wait() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!pauseTask) return [3 /*break*/, 2];
-                    return [4 /*yield*/, pauseTask];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [2 /*return*/, new Promise(function (resolve) {
-                        requestIdleCallback(resolve, { timeout: idleTimeout });
-                    })];
+function metrics(root, value) {
+    var _loop_2 = function (v) {
+        var metricId = v[0], source = v[1], match = v[2], scale = v[3];
+        if (match) {
+            switch (source) {
+                case 0 /* Text */:
+                    root.querySelectorAll(match).forEach(function (e) { max(metricId, num$2(e.innerText, scale)); });
+                    break;
+                case 2 /* Attribute */:
+                    root.querySelectorAll("[" + match + "]").forEach(function (e) { max(metricId, num$2(e.getAttribute(match), scale, false)); });
+                    break;
+                case 1 /* Javascript */:
+                    max(metricId, evaluate(match, "number" /* Number */));
+                    break;
             }
-        });
-    });
-}
-// Use native implementation of requestIdleCallback if it exists.
-// Otherwise, fall back to a custom implementation using requestAnimationFrame & MessageChannel.
-// While it's not possible to build a perfect polyfill given the nature of this API, the following code attempts to get close.
-// Background context: requestAnimationFrame invokes the js code right before: style, layout and paint computation within the frame.
-// This means, that any code that runs as part of requestAnimationFrame will by default be blocking in nature. Not what we want.
-// For non-blocking behavior, We need to know when browser has finished painiting. This can be accomplished in two different ways (hacks):
-//   (1) Use MessageChannel to pass the message, and browser will receive the message right after pain event has occured.
-//   (2) Use setTimeout call within requestAnimationFrame. This also works, but there's a risk that browser may throttle setTimeout calls.
-// Given this information, we are currently using (1) from above. More information on (2) as well as some additional context is below:
-// https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Performance_best_practices_for_Firefox_fe_engineers
-function requestIdleCallbackPolyfill(callback, options) {
-    var startTime = performance.now();
-    var channel = new MessageChannel();
-    var incoming = channel.port1;
-    var outgoing = channel.port2;
-    incoming.onmessage = function (event) {
-        var currentTime = performance.now();
-        var elapsed = currentTime - startTime;
-        var duration = currentTime - event.data;
-        if (duration > 30 /* LongTask */ && elapsed < options.timeout) {
-            requestAnimationFrame(function () { outgoing.postMessage(currentTime); });
-        }
-        else {
-            var didTimeout_1 = elapsed > options.timeout;
-            callback({
-                didTimeout: didTimeout_1,
-                timeRemaining: function () { return didTimeout_1 ? 30 /* LongTask */ : Math.max(0, 30 /* LongTask */ - duration); }
-            });
         }
     };
-    requestAnimationFrame(function () { outgoing.postMessage(performance.now()); });
+    for (var _i = 0, value_2 = value; _i < value_2.length; _i++) {
+        var v = value_2[_i];
+        _loop_2(v);
+    }
 }
-var requestIdleCallback = window["requestIdleCallback"] || requestIdleCallbackPolyfill;
-
-// Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
-// The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
-// If so, it replaces the token with its reference (index). This helps us save bytes by not repeating the same value twice.
-// E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
-// Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
-// Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
-function tokenize (tokens) {
-    var output = [];
-    var lookup = {};
-    var pointer = 0;
-    var reference = null;
-    for (var i = 0; i < tokens.length; i++) {
-        // Only optimize for string values
-        if (typeof tokens[i] === "string" /* String */) {
-            var token = tokens[i];
-            var index = lookup[token] || -1;
-            if (index >= 0) {
-                if (reference) {
-                    reference.push(index);
-                }
-                else {
-                    reference = [index];
-                    output.push(reference);
-                    pointer++;
-                }
-            }
-            else {
-                reference = null;
-                output.push(token);
-                lookup[token] = pointer++;
+function dimensions(root, value) {
+    var _loop_3 = function (v) {
+        var dimensionId = v[0], source = v[1], match = v[2];
+        if (match) {
+            switch (source) {
+                case 0 /* Text */:
+                    root.querySelectorAll(match).forEach(function (e) { log(dimensionId, str(e.innerText)); });
+                    break;
+                case 2 /* Attribute */:
+                    root.querySelectorAll("[" + match + "]").forEach(function (e) { log(dimensionId, str(e.getAttribute(match))); });
+                    break;
+                case 1 /* Javascript */:
+                    log(dimensionId, str(evaluate(match, "string" /* String */)));
+                    break;
             }
         }
-        else {
-            // If the value is anything other than string, append it as it is to the output array
-            // And, also increment the pointer to stay in sync with output array
-            reference = null;
-            output.push(tokens[i]);
-            pointer++;
-        }
+    };
+    for (var _i = 0, value_3 = value; _i < value_3.length; _i++) {
+        var v = value_3[_i];
+        _loop_3(v);
     }
-    return output;
-}
-
-var data$9;
-function reset$h() {
-    data$9 = null;
 }
-function start$s() {
-    reset$h();
-    compute$6();
+function regex(match) {
+    regexCache[match] = match in regexCache ? regexCache[match] : new RegExp(match);
+    return regexCache[match];
 }
-function compute$6() {
-    var body = document.body;
-    var d = document.documentElement;
-    var bodyClientWidth = body ? body.clientWidth : null;
-    var bodyScrollWidth = body ? body.scrollWidth : null;
-    var bodyOffsetWidth = body ? body.offsetWidth : null;
-    var documentClientWidth = d ? d.clientWidth : null;
-    var documentScrollWidth = d ? d.scrollWidth : null;
-    var documentOffsetWidth = d ? d.offsetWidth : null;
-    var width = Math.max(bodyClientWidth, bodyScrollWidth, bodyOffsetWidth, documentClientWidth, documentScrollWidth, documentOffsetWidth);
-    var bodyClientHeight = body ? body.clientHeight : null;
-    var bodyScrollHeight = body ? body.scrollHeight : null;
-    var bodyOffsetHeight = body ? body.offsetHeight : null;
-    var documentClientHeight = d ? d.clientHeight : null;
-    var documentScrollHeight = d ? d.scrollHeight : null;
-    var documentOffsetHeight = d ? d.offsetHeight : null;
-    var height = Math.max(bodyClientHeight, bodyScrollHeight, bodyOffsetHeight, documentClientHeight, documentScrollHeight, documentOffsetHeight);
-    // Check that width or height has changed from before, and also that width & height are not null values
-    if ((data$9 === null || width !== data$9.width || height !== data$9.height) && width !== null && height !== null) {
-        data$9 = { width: width, height: height };
-        encode$4(8 /* Document */);
+// The function below takes in a variable name in following format: "a.b.c" and safely evaluates its value in javascript context
+// For instance, for a.b.c, it will first check window["a"]. If it exists, it will recursively look at: window["a"]["b"] and finally,
+// return the value for window["a"]["b"]["c"].
+function evaluate(variable, type, base) {
+    if (type === void 0) { type = null; }
+    if (base === void 0) { base = window; }
+    var parts = variable.split("." /* Dot */);
+    var first = parts.shift();
+    if (base && base[first]) {
+        if (parts.length > 0) {
+            return evaluate(parts.join("." /* Dot */), type, base[first]);
+        }
+        var output = type === null || type === typeof base[first] ? base[first] : null;
+        return output;
     }
+    return null;
 }
-function end() {
-    reset$h();
-}
-
-function encode$4 (type, timer, ts) {
-    if (timer === void 0) { timer = null; }
-    if (ts === void 0) { ts = null; }
-    return __awaiter(this, void 0, void 0, function () {
-        var eventTime, tokens, _a, d, _i, _b, r, b, _c, b_1, entry, values, _d, values_1, value, state, data, active, suspend, privacy, mangle, keys, _e, keys_1, key, size, factor, attr;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    eventTime = ts || time();
-                    tokens = [eventTime, type];
-                    _a = type;
-                    switch (_a) {
-                        case 8 /* Document */: return [3 /*break*/, 1];
-                        case 7 /* Region */: return [3 /*break*/, 2];
-                        case 37 /* Box */: return [3 /*break*/, 3];
-                        case 5 /* Discover */: return [3 /*break*/, 4];
-                        case 6 /* Mutation */: return [3 /*break*/, 4];
-                    }
-                    return [3 /*break*/, 11];
-                case 1:
-                    d = data$9;
-                    tokens.push(d.width);
-                    tokens.push(d.height);
-                    track$7(type, d.width, d.height);
-                    queue(tokens);
-                    return [3 /*break*/, 11];
-                case 2:
-                    for (_i = 0, _b = state$7; _i < _b.length; _i++) {
-                        r = _b[_i];
-                        tokens = [r.time, 7 /* Region */];
-                        tokens.push(r.data.id);
-                        tokens.push(r.data.interaction);
-                        tokens.push(r.data.visibility);
-                        tokens.push(r.data.name);
-                        queue(tokens);
-                    }
-                    reset$e();
-                    return [3 /*break*/, 11];
-                case 3:
-                    b = data$8;
-                    for (_c = 0, b_1 = b; _c < b_1.length; _c++) {
-                        entry = b_1[_c];
-                        tokens.push(entry.id);
-                        tokens.push(entry.width);
-                        tokens.push(entry.height);
-                    }
-                    reset$g();
-                    queue(tokens);
-                    return [3 /*break*/, 11];
-                case 4:
-                    // Check if we are operating within the context of the current page
-                    if (state$8(timer) === 2 /* Stop */) {
-                        return [3 /*break*/, 11];
-                    }
-                    values = updates$2();
-                    if (!(values.length > 0)) return [3 /*break*/, 10];
-                    _d = 0, values_1 = values;
-                    _f.label = 5;
-                case 5:
-                    if (!(_d < values_1.length)) return [3 /*break*/, 9];
-                    value = values_1[_d];
-                    state = state$8(timer);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 7];
-                    return [4 /*yield*/, suspend$1(timer)];
-                case 6:
-                    state = _f.sent();
-                    _f.label = 7;
-                case 7:
-                    if (state === 2 /* Stop */) {
-                        return [3 /*break*/, 9];
-                    }
-                    data = value.data;
-                    active = value.metadata.active;
-                    suspend = value.metadata.suspend;
-                    privacy = value.metadata.privacy;
-                    mangle = shouldMangle(value);
-                    keys = active ? ["tag", "attributes", "value"] : ["tag"];
-                    compute$5(value.id);
-                    for (_e = 0, keys_1 = keys; _e < keys_1.length; _e++) {
-                        key = keys_1[_e];
-                        if (data[key]) {
-                            switch (key) {
-                                case "tag":
-                                    size = value.metadata.size;
-                                    factor = mangle ? -1 : 1;
-                                    tokens.push(value.id * factor);
-                                    if (value.parent && active) {
-                                        tokens.push(value.parent);
-                                    }
-                                    if (value.previous && active) {
-                                        tokens.push(value.previous);
-                                    }
-                                    tokens.push(suspend ? "*M" /* SuspendMutationTag */ : data[key]);
-                                    if (size && size.length === 2) {
-                                        tokens.push("" + "#" /* Box */ + str$1(size[0]) + "." + str$1(size[1]));
-                                    }
-                                    break;
-                                case "attributes":
-                                    for (attr in data[key]) {
-                                        if (data[key][attr] !== undefined) {
-                                            tokens.push(attribute(attr, data[key][attr], privacy));
-                                        }
-                                    }
-                                    break;
-                                case "value":
-                                    tokens.push(scrub(data[key], data.tag, privacy, mangle));
-                                    break;
-                            }
-                        }
-                    }
-                    _f.label = 8;
-                case 8:
-                    _d++;
-                    return [3 /*break*/, 5];
-                case 9:
-                    if (type === 6 /* Mutation */) {
-                        activity(eventTime);
-                    }
-                    queue(tokenize(tokens), !config$1.lean);
-                    _f.label = 10;
-                case 10: return [3 /*break*/, 11];
-                case 11: return [2 /*return*/];
-            }
-        });
-    });
-}
-function shouldMangle(value) {
-    var privacy = value.metadata.privacy;
-    return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
-}
-function str$1(input) {
-    return input.toString(36);
-}
-function attribute(key, value, privacy) {
-    return key + "=" + scrub(value, key, privacy);
-}
-
-var data$8 = [];
-var enabled = false;
-var observer$2 = null;
-function start$r() {
-    reset$g();
-    observer$2 = null;
-    enabled = window["ResizeObserver"] ? true : false;
-}
-function compute$5(id) {
-    if (enabled === false) {
-        return;
-    }
-    observer$2 = observer$2 === null ? new ResizeObserver(handler$4) : observer$2;
-    if (observer$2) {
-        var value = getValue(id);
-        // If this is the first time computing size for this node, go ahead and wire up ResizeObserver
-        // In all other cases, value.metadata.size will be null or an array with two elements [width, height]
-        // And, in those cases, we will skip through the following section and not attach the observer
-        if (value && value.metadata.size !== null && value.metadata.size.length === 0) {
-            var node = getNode(id);
-            if (node && node.nodeType === Node.ELEMENT_NODE) {
-                var e = node;
-                var r = e.getBoundingClientRect();
-                value.metadata.size = [Math.floor(r.width * 100 /* BoxPrecision */), Math.floor(r.height * 100 /* BoxPrecision */)];
-                observer$2.observe(e);
-            }
-        }
-    }
-}
-function handler$4(entries) {
-    window.requestAnimationFrame(function () {
-        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-            var entry = entries_1[_i];
-            var target = entry.target;
-            var id = target ? getId(target) : null;
-            if (id) {
-                var v = getValue(id);
-                var s = v.metadata.size;
-                var b = entry.borderBoxSize;
-                var w = null;
-                var h = null;
-                // Check if browser supports borderBoxSize property on ResizeObserverEntry object
-                // Otherwise, fall back to using getBoundingClientRect() to be cross browser compatible
-                // Reference: https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry/borderBoxSize
-                if (b && b.length > 0) {
-                    w = Math.floor(b[0].inlineSize * 100 /* BoxPrecision */);
-                    h = Math.floor(b[0].blockSize * 100 /* BoxPrecision */);
-                }
-                else {
-                    var r = target.getBoundingClientRect();
-                    w = Math.floor(r.width * 100 /* BoxPrecision */);
-                    h = Math.floor(r.height * 100 /* BoxPrecision */);
-                }
-                // Capture new width & height only if they are different from what we have in in-memory cache
-                if (w !== s[0] && h !== s[1]) {
-                    s = [w, h];
-                    data$8.push({ id: id, width: w, height: h });
-                }
-            }
-        }
-        // Schedule encode only when we have at least one valid data entry
-        if (data$8.length > 0) {
-            encode$4(37 /* Box */);
-        }
-    });
-}
-function reset$g() {
-    data$8 = [];
-}
-function stop$p() {
-    reset$g();
-    if (observer$2) {
-        observer$2.disconnect();
-        observer$2 = null;
-    }
-    enabled = false;
-}
-
-var history$3 = {};
-var data$7;
-function start$q() {
-    bind(window, "error", handler$3);
-    history$3 = {};
-}
-function handler$3(error) {
-    var e = error["error"] || error;
-    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
-    // In those cases, we only want to log the failure first few times and not spam logs with redundant information.
-    if (!(e.message in history$3)) {
-        history$3[e.message] = 0;
-    }
-    if (history$3[e.message]++ >= 5 /* ScriptErrorLimit */) {
-        return true;
-    }
-    // Send back information only if the handled error has valid information
-    if (e && e.message) {
-        data$7 = {
-            message: e.message,
-            line: error["lineno"],
-            column: error["colno"],
-            stack: e.stack,
-            source: error["filename"]
-        };
-        // In certain cases, ResizeObserver could lead to flood of benign errors - especially when video element is involved.
-        // Reference Chromium issue: https://bugs.chromium.org/p/chromium/issues/detail?id=809574
-        // Even though it doesn't impact user experience, or show up in console, it can still flood error reporting through on error
-        // To mitigate that, we turn off Clarity's ResizeObserver on getting the first instance of this error
-        if (e.message.indexOf("ResizeObserver" /* ResizeObserver */) >= 0) {
-            stop$p();
-            return false;
-        }
-        encode$3(31 /* ScriptError */);
-    }
-    return true;
-}
-
-function encode$3 (type) {
-    return __awaiter(this, void 0, void 0, function () {
-        var tokens;
-        return __generator(this, function (_a) {
-            tokens = [time(), type];
-            switch (type) {
-                case 31 /* ScriptError */:
-                    tokens.push(data$7.message);
-                    tokens.push(data$7.line);
-                    tokens.push(data$7.column);
-                    tokens.push(data$7.stack);
-                    tokens.push(data$7.source);
-                    queue(tokens);
-                    break;
-                case 33 /* Log */:
-                    if (data$6) {
-                        tokens.push(data$6.code);
-                        tokens.push(data$6.name);
-                        tokens.push(data$6.message);
-                        tokens.push(data$6.stack);
-                        tokens.push(data$6.severity);
-                        queue(tokens, false);
-                    }
-                    break;
-            }
-            return [2 /*return*/];
-        });
-    });
-}
-
-var history$2 = {};
-var data$6;
-function start$p() {
-    history$2 = {};
-    bind(document, "securitypolicyviolation", csp);
-}
-function log(code, severity, name, message, stack) {
-    if (name === void 0) { name = null; }
-    if (message === void 0) { message = null; }
-    if (stack === void 0) { stack = null; }
-    var key = name ? name + "|" + message : "";
-    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
-    // In those cases, we only want to log the failure once and not spam logs with redundant information.
-    if (code in history$2 && history$2[code].indexOf(key) >= 0) {
-        return;
-    }
-    data$6 = { code: code, name: name, message: message, stack: stack, severity: severity };
-    // Maintain history of errors in memory to avoid sending redundant information
-    if (code in history$2) {
-        history$2[code].push(key);
-    }
-    else {
-        history$2[code] = [key];
-    }
-    encode$3(33 /* Log */);
-}
-function csp(e) {
-    var upload = config$1.upload;
-    var parts = upload ? upload.substr(0, upload.indexOf("/", "https://" /* HTTPS */.length)).split("." /* Dot */) : []; // Look for first "/" starting after initial "https://" string
-    var domain = parts.length >= 2 ? parts.splice(-2).join("." /* Dot */) : null;
-    // Capture content security policy violation only if disposition value is not explicitly set to "report"
-    if (domain && e.blockedURI && e.blockedURI.indexOf(domain) >= 0 && e["disposition"] !== "report" /* Report */) {
-        log(7 /* ContentSecurityPolicy */, 1 /* Warning */, e.blockedURI);
-    }
-}
-function stop$o() {
-    history$2 = {};
-}
-
-var formatRegex = /1/g;
-var digitsRegex$1 = /[^0-9\.]/g;
-var digitsWithCommaRegex = /[^0-9\.,]/g;
-var regexCache = {};
-function regions$1(root, value) {
-    var _loop_1 = function (v) {
-        var regionId = v[0], selector = v[1], filter = v[2], match = v[3];
-        var valid = true;
-        switch (filter) {
-            case 0 /* Url */:
-                valid = match && !!top.location.href.match(regex(match));
-                break;
-            case 1 /* Javascript */:
-                valid = match && !!evaluate(match);
-                break;
-        }
-        if (valid) {
-            root.querySelectorAll(selector).forEach(function (e) { return observe$b(e, regionId.toString()); });
-        }
-    };
-    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
-        var v = value_1[_i];
-        _loop_1(v);
-    }
-}
-function metrics(root, value) {
-    var _loop_2 = function (v) {
-        var metricId = v[0], source = v[1], match = v[2], scale = v[3];
-        if (match) {
-            switch (source) {
-                case 0 /* Text */:
-                    root.querySelectorAll(match).forEach(function (e) { max(metricId, num$1(e.innerText, scale)); });
-                    break;
-                case 2 /* Attribute */:
-                    root.querySelectorAll("[" + match + "]").forEach(function (e) { max(metricId, num$1(e.getAttribute(match), scale, false)); });
-                    break;
-                case 1 /* Javascript */:
-                    max(metricId, evaluate(match, "number" /* Number */));
-                    break;
-            }
-        }
-    };
-    for (var _i = 0, value_2 = value; _i < value_2.length; _i++) {
-        var v = value_2[_i];
-        _loop_2(v);
-    }
-}
-function dimensions(root, value) {
-    var _loop_3 = function (v) {
-        var dimensionId = v[0], source = v[1], match = v[2];
-        if (match) {
-            switch (source) {
-                case 0 /* Text */:
-                    root.querySelectorAll(match).forEach(function (e) { log$1(dimensionId, str(e.innerText)); });
-                    break;
-                case 2 /* Attribute */:
-                    root.querySelectorAll("[" + match + "]").forEach(function (e) { log$1(dimensionId, str(e.getAttribute(match))); });
-                    break;
-                case 1 /* Javascript */:
-                    log$1(dimensionId, str(evaluate(match, "string" /* String */)));
-                    break;
-            }
-        }
-    };
-    for (var _i = 0, value_3 = value; _i < value_3.length; _i++) {
-        var v = value_3[_i];
-        _loop_3(v);
-    }
-}
-function regex(match) {
-    regexCache[match] = match in regexCache ? regexCache[match] : new RegExp(match);
-    return regexCache[match];
-}
-// The function below takes in a variable name in following format: "a.b.c" and safely evaluates its value in javascript context
-// For instance, for a.b.c, it will first check window["a"]. If it exists, it will recursively look at: window["a"]["b"] and finally,
-// return the value for window["a"]["b"]["c"].
-function evaluate(variable, type, base) {
-    if (type === void 0) { type = null; }
-    if (base === void 0) { base = window; }
-    var parts = variable.split("." /* Dot */);
-    var first = parts.shift();
-    if (base && base[first]) {
-        if (parts.length > 0) {
-            return evaluate(parts.join("." /* Dot */), type, base[first]);
-        }
-        var output = type === null || type === typeof base[first] ? base[first] : null;
-        return output;
-    }
-    return null;
-}
-function str(input) {
-    // Automatically trim string to max of Setting.DimensionLimit to avoid fetching long strings
-    return input ? input.substr(0, 256 /* DimensionLimit */) : input;
-}
-function num$1(text, scale, localize) {
-    if (localize === void 0) { localize = true; }
-    try {
-        scale = scale || 1;
-        // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
-        var lang = document.documentElement.lang;
-        if (Intl && Intl.NumberFormat && lang && localize) {
-            text = text.replace(digitsWithCommaRegex, "" /* Empty */);
-            // Infer current group and decimal separator from current locale
-            var group = Intl.NumberFormat(lang).format(11111).replace(formatRegex, "" /* Empty */);
-            var decimal = Intl.NumberFormat(lang).format(1.1).replace(formatRegex, "" /* Empty */);
-            // Parse number using inferred group and decimal separators
-            return Math.round(parseFloat(text
-                .replace(new RegExp('\\' + group, 'g'), "" /* Empty */)
-                .replace(new RegExp('\\' + decimal), "." /* Dot */)) * scale);
-        }
-        // Fallback to en locale
-        return Math.round(parseFloat(text.replace(digitsRegex$1, "" /* Empty */)) * scale);
-    }
-    catch (_a) {
-        return null;
-    }
+function str(input) {
+    // Automatically trim string to max of Setting.DimensionLimit to avoid fetching long strings
+    return input ? input.substr(0, 256 /* DimensionLimit */) : input;
+}
+function num$2(text, scale, localize) {
+    if (localize === void 0) { localize = true; }
+    try {
+        scale = scale || 1;
+        // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+        var lang = document.documentElement.lang;
+        if (Intl && Intl.NumberFormat && lang && localize) {
+            text = text.replace(digitsWithCommaRegex, "" /* Empty */);
+            // Infer current group and decimal separator from current locale
+            var group = Intl.NumberFormat(lang).format(11111).replace(formatRegex, "" /* Empty */);
+            var decimal = Intl.NumberFormat(lang).format(1.1).replace(formatRegex, "" /* Empty */);
+            // Parse number using inferred group and decimal separators
+            return Math.round(parseFloat(text
+                .replace(new RegExp('\\' + group, 'g'), "" /* Empty */)
+                .replace(new RegExp('\\' + decimal), "." /* Dot */)) * scale);
+        }
+        // Fallback to en locale
+        return Math.round(parseFloat(text.replace(digitsRegex$1, "" /* Empty */)) * scale);
+    }
+    catch (_a) {
+        return null;
+    }
 }
 
 var TAGS = ["DIV", "TR", "P", "LI", "UL", "A", "BUTTON"];
@@ -1708,12 +1400,13 @@ function selector (input, beta) {
             var selector = "" + prefix + input.tag + suffix;
             var classes = "class" /* Class */ in a && a["class" /* Class */].length > 0 ? a["class" /* Class */].trim().split(/\s+/) : null;
             if (beta) {
-                // In beta mode, update selector to use "id" field when available
-                // The only exception is if "id" appears to be an auto generated string token, e.g. guid or a random id
+                // In beta mode, update selector to use "id" field when available. There are two exceptions:
+                // (1) if "id" appears to be an auto generated string token, e.g. guid or a random id containing digits
+                // (2) if "id" appears inside a shadow DOM, in which case we continue to prefix up to shadow DOM to prevent conflicts
                 var id = "id" /* Id */ in a && a["id" /* Id */].length > 0 ? a["id" /* Id */] : null;
                 classes = input.tag !== "BODY" /* BodyTag */ && classes ? classes.filter(function (c) { return !hasDigits(c); }) : [];
                 selector = classes.length > 0 ? "" + prefix + input.tag + "." + classes.join(".") + suffix : selector;
-                selector = id && hasDigits(id) === false ? "#" + id : selector;
+                selector = id && hasDigits(id) === false ? getDomPrefix(prefix) + "#" + id : selector;
             }
             else {
                 // Otherwise, fallback to stable mode, where we include class names as part of the selector
@@ -1722,11 +1415,23 @@ function selector (input, beta) {
             return selector;
     }
 }
+function getDomPrefix(prefix) {
+    var shadowDomStart = prefix.lastIndexOf("*S" /* ShadowDomTag */);
+    var iframeDomStart = prefix.lastIndexOf("" + "iframe:" /* IFramePrefix */ + "HTML" /* HTML */);
+    var domStart = Math.max(shadowDomStart, iframeDomStart);
+    if (domStart < 0) {
+        return "";
+    }
+    var domEnd = prefix.indexOf(">", domStart) + 1;
+    return prefix.substr(0, domEnd);
+}
 // Check if the given input string has digits or not
 function hasDigits(value) {
     for (var i = 0; i < value.length; i++) {
         var c = value.charCodeAt(i);
-        return c >= 48 /* Zero */ && c <= 57 /* Nine */;
+        if (c >= 48 /* Zero */ && c <= 57 /* Nine */) {
+            return true;
+        }
     }
     return false;
 }
@@ -1734,39 +1439,48 @@ function hasDigits(value) {
 var index = 1;
 // Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input#%3Cinput%3E_types
 var DISALLOWED_TYPES = ["password", "hidden", "email", "tel"];
-var DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass"];
+var DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass", "card", "account", "cvv", "ccv"];
 var DISALLOWED_MATCH = ["address", "password", "contact"];
 var nodes = [];
 var values = [];
 var updateMap = [];
 var hashMap = {};
+var override = [];
+var unmask = [];
 // The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced
 var idMap = null; // Maps node => id.
 var iframeMap = null; // Maps iframe's contentDocument => parent iframe element
 var privacyMap = null; // Maps node => Privacy (enum)
-function start$o() {
-    reset$f();
-    parse(document);
+function start$r() {
+    reset$g();
+    parse(document, true);
 }
-function stop$n() {
-    reset$f();
+function stop$q() {
+    reset$g();
 }
-function reset$f() {
+function reset$g() {
     index = 1;
     nodes = [];
     values = [];
     updateMap = [];
     hashMap = {};
+    override = [];
+    unmask = [];
     idMap = new WeakMap();
     iframeMap = new WeakMap();
     privacyMap = new WeakMap();
 }
 // We parse new root nodes for any regions or masked nodes in the beginning (document) and
 // later whenever there are new additions or modifications to DOM (mutations)
-function parse(root) {
+function parse(root, init) {
+    if (init === void 0) { init = false; }
     // Wrap selectors in a try / catch block.
     // It's possible for script to receive invalid selectors, e.g. "'#id'" with extra quotes, and cause the code below to fail
     try {
+        // Parse unmask configuration into separate query selectors and override tokens as part of initialization
+        if (init) {
+            config$1.unmask.forEach(function (x) { return x.indexOf("!" /* Bang */) < 0 ? unmask.push(x) : override.push(x.substr(1)); });
+        }
         // Since mutations may happen on leaf nodes too, e.g. text nodes, which may not support all selector APIs.
         // We ensure that the root note supports querySelectorAll API before executing the code below to identify new regions.
         if ("querySelectorAll" in root) {
@@ -1774,11 +1488,11 @@ function parse(root) {
             metrics(root, config$1.metrics);
             dimensions(root, config$1.dimensions);
             config$1.mask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 3 /* TextImage */); }); }); // Masked Elements
-            config$1.unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* None */); }); }); // Unmasked Elements
+            unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* None */); }); }); // Unmasked Elements
         }
     }
     catch (e) {
-        log(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
+        log$1(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
     }
 }
 function getId(node, autogen) {
@@ -1799,17 +1513,15 @@ function add(node, parent, data, source) {
     var previousId = getPreviousId(node);
     var privacy = config$1.content ? 1 /* Sensitive */ : 2 /* Text */;
     var parentValue = null;
-    var parentTag = "" /* Empty */;
     var regionId = exists(node) ? id : null;
     if (parentId >= 0 && values[parentId]) {
         parentValue = values[parentId];
-        parentTag = parentValue.data.tag;
         parentValue.children.push(id);
         regionId = regionId === null ? parentValue.region : regionId;
         privacy = parentValue.metadata.privacy;
     }
     // Check to see if this particular node should be masked or not
-    privacy = getPrivacy(node, data, parentTag, privacy);
+    privacy = getPrivacy(node, data, parentValue, privacy);
     // If there's an explicit region attribute set on the element, use it to mark a region on the page
     if (data.attributes && "data-clarity-region" /* RegionData */ in data.attributes) {
         observe$b(node, data.attributes["data-clarity-region" /* RegionData */]);
@@ -1829,7 +1541,7 @@ function add(node, parent, data, source) {
     };
     updateSelector(values[id]);
     size(values[id], parentValue);
-    track$4(id, source);
+    track$5(id, source);
 }
 function update(node, parent, data, source) {
     var id = getId(node);
@@ -1879,7 +1591,7 @@ function update(node, parent, data, source) {
         }
         // Update selector
         updateSelector(value);
-        track$4(id, source, changed, parentChanged);
+        track$5(id, source, changed, parentChanged);
     }
 }
 function sameorigin(node) {
@@ -1904,21 +1616,35 @@ function iframe(node) {
     var doc = node.nodeType === Node.DOCUMENT_NODE ? node : null;
     return doc && iframeMap.has(doc) ? iframeMap.get(doc) : null;
 }
-function getPrivacy(node, data, parentTag, privacy) {
+function getPrivacy(node, data, parent, privacy) {
     var attributes = data.attributes;
     var tag = data.tag.toUpperCase();
     // If this node was explicitly configured to contain sensitive content, use that information and return the value
     if (privacyMap.has(node)) {
         return privacyMap.get(node);
     }
+    // If it's a text node belonging to a STYLE or TITLE tag; 
+    // Or, the text node belongs to one of SCRUB_EXCEPTIONS
+    // then reset the privacy setting to ensure we capture the content
+    if (tag === "*T" /* TextTag */ && parent && parent.data) {
+        var path = parent.selector ? parent.selector[0 /* Stable */] : "" /* Empty */;
+        privacy = parent.data.tag === "STYLE" /* StyleTag */ || parent.data.tag === "TITLE" /* TitleTag */ ? 0 /* None */ : privacy;
+        for (var _i = 0, override_1 = override; _i < override_1.length; _i++) {
+            var entry = override_1[_i];
+            if (path.indexOf(entry) >= 0) {
+                privacy = 0 /* None */;
+                break;
+            }
+        }
+    }
     // Do not proceed if attributes are missing for the node
     if (attributes === null || attributes === undefined) {
         return privacy;
     }
     // Look up for sensitive fields
     if ("class" /* Class */ in attributes && privacy === 1 /* Sensitive */) {
-        for (var _i = 0, DISALLOWED_MATCH_1 = DISALLOWED_MATCH; _i < DISALLOWED_MATCH_1.length; _i++) {
-            var match = DISALLOWED_MATCH_1[_i];
+        for (var _a = 0, DISALLOWED_MATCH_1 = DISALLOWED_MATCH; _a < DISALLOWED_MATCH_1.length; _a++) {
+            var match = DISALLOWED_MATCH_1[_a];
             if (attributes["class" /* Class */].indexOf(match) >= 0) {
                 privacy = 2 /* Text */;
                 break;
@@ -1930,12 +1656,12 @@ function getPrivacy(node, data, parentTag, privacy) {
         if (privacy === 0 /* None */) {
             var field = "" /* Empty */;
             // Be aggressive in looking up any attribute (id, class, name, etc.) for disallowed names
-            for (var _a = 0, _b = Object.keys(attributes); _a < _b.length; _a++) {
-                var attribute = _b[_a];
+            for (var _b = 0, _c = Object.keys(attributes); _b < _c.length; _b++) {
+                var attribute = _c[_b];
                 field += attributes[attribute].toLowerCase();
             }
-            for (var _c = 0, DISALLOWED_NAMES_1 = DISALLOWED_NAMES; _c < DISALLOWED_NAMES_1.length; _c++) {
-                var name_1 = DISALLOWED_NAMES_1[_c];
+            for (var _d = 0, DISALLOWED_NAMES_1 = DISALLOWED_NAMES; _d < DISALLOWED_NAMES_1.length; _d++) {
+                var name_1 = DISALLOWED_NAMES_1[_d];
                 if (field.indexOf(name_1) >= 0) {
                     privacy = 2 /* Text */;
                     break;
@@ -1958,11 +1684,6 @@ function getPrivacy(node, data, parentTag, privacy) {
     if ("data-clarity-unmask" /* UnmaskData */ in attributes) {
         privacy = 0 /* None */;
     }
-    // If it's a text node belonging to a STYLE or TITLE tag; then reset the privacy setting to ensure we capture the content
-    var cTag = tag === "*T" /* TextTag */ ? parentTag : tag;
-    if (cTag === "STYLE" /* StyleTag */ || cTag === "TITLE" /* TitleTag */) {
-        privacy = 0 /* None */;
-    }
     return privacy;
 }
 function diff(a, b, field) {
@@ -2041,7 +1762,7 @@ function remove(id, source) {
         var value = values[id];
         value.metadata.active = false;
         value.parent = null;
-        track$4(id, source);
+        track$5(id, source);
     }
 }
 function size(value, parent) {
@@ -2068,7 +1789,7 @@ function getPreviousId(node) {
     }
     return id;
 }
-function track$4(id, source, changed, parentChanged) {
+function track$5(id, source, changed, parentChanged) {
     if (changed === void 0) { changed = true; }
     if (parentChanged === void 0) { parentChanged = false; }
     // Keep track of the order in which mutations happened, they may not be sequential
@@ -2086,8 +1807,8 @@ function track$4(id, source, changed, parentChanged) {
 
 var dom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    start: start$o,
-    stop: stop$n,
+    start: start$r,
+    stop: stop$q,
     parse: parse,
     getId: getId,
     add: add,
@@ -2108,8 +1829,8 @@ var regions = {};
 var queue$2 = [];
 var watch = false;
 var observer$1 = null;
-function start$n() {
-    reset$e();
+function start$q() {
+    reset$f();
     observer$1 = null;
     regionMap = new WeakMap();
     regions = {};
@@ -2137,7 +1858,7 @@ function exists(node) {
     // and still attempt to call exists on a late coming DOM mutation (or addition), effectively causing a script error
     return regionMap && regionMap.has(node);
 }
-function track$3(id, event) {
+function track$4(id, event) {
     var node = getNode(id);
     var data = id in regions ? regions[id] : { id: id, visibility: 0 /* Rendered */, interaction: 16 /* None */, name: regionMap.get(node) };
     // Determine the interaction state based on incoming event
@@ -2153,7 +1874,7 @@ function track$3(id, event) {
     // Process updates to this region, if applicable
     process$6(node, data, interaction, data.visibility);
 }
-function compute$4() {
+function compute$5() {
     // Process any regions where we couldn't resolve an "id" for at the time of last intersection observer event
     // This could happen in cases where elements are not yet processed by Clarity's virtual DOM but browser reports a change, regardless.
     // For those cases we add them to the queue and re-process them below
@@ -2234,11 +1955,11 @@ function process$6(n, d, s, v) {
 function clone(r) {
     return { time: time(), data: { id: r.id, interaction: r.interaction, visibility: r.visibility, name: r.name } };
 }
-function reset$e() {
+function reset$f() {
     state$7 = [];
 }
-function stop$m() {
-    reset$e();
+function stop$p() {
+    reset$f();
     regionMap = null;
     regions = {};
     queue$2 = [];
@@ -2267,8 +1988,8 @@ function offset (element) {
 
 var UserInputTags = ["input", "textarea", "radio", "button", "canvas"];
 var state$6 = [];
-function start$m() {
-    reset$d();
+function start$p() {
+    reset$e();
 }
 function observe$a(root) {
     bind(root, "click", handler$1.bind(this, 9 /* Click */, root), true);
@@ -2375,16 +2096,16 @@ function context(a) {
     }
     return 0 /* Self */;
 }
-function reset$d() {
+function reset$e() {
     state$6 = [];
 }
-function stop$l() {
-    reset$d();
+function stop$o() {
+    reset$e();
 }
 
 var state$5 = [];
-function start$l() {
-    reset$c();
+function start$o() {
+    reset$d();
 }
 function observe$9(root) {
     bind(root, "cut", recompute$7.bind(this, 0 /* Cut */), true);
@@ -2395,17 +2116,17 @@ function recompute$7(action, evt) {
     state$5.push({ time: time(), event: 38 /* Clipboard */, data: { target: target(evt), action: action } });
     schedule$1(encode$2.bind(this, 38 /* Clipboard */));
 }
-function reset$c() {
+function reset$d() {
     state$5 = [];
 }
-function stop$k() {
-    reset$c();
+function stop$n() {
+    reset$d();
 }
 
 var timeout$5 = null;
 var state$4 = [];
-function start$k() {
-    reset$b();
+function start$n() {
+    reset$c();
 }
 function observe$8(root) {
     bind(root, "input", recompute$6, true);
@@ -2440,18 +2161,18 @@ function recompute$6(evt) {
 function process$5(event) {
     schedule$1(encode$2.bind(this, event));
 }
-function reset$b() {
+function reset$c() {
     state$4 = [];
 }
-function stop$j() {
+function stop$m() {
     clearTimeout(timeout$5);
-    reset$b();
+    reset$c();
 }
 
 var state$3 = [];
 var timeout$4 = null;
-function start$j() {
-    reset$a();
+function start$m() {
+    reset$b();
 }
 function observe$7(root) {
     bind(root, "mousedown", mouse.bind(this, 13 /* MouseDown */, root), true);
@@ -2522,7 +2243,7 @@ function handler(current) {
 function process$4(event) {
     schedule$1(encode$2.bind(this, event));
 }
-function reset$a() {
+function reset$b() {
     state$3 = [];
 }
 function similar$1(last, current) {
@@ -2533,7 +2254,7 @@ function similar$1(last, current) {
     var match = current.data.target === last.data.target;
     return current.event === last.event && match && distance < 20 /* Distance */ && gap < 25 /* Interval */;
 }
-function stop$i() {
+function stop$l() {
     clearTimeout(timeout$4);
     // Send out any pending pointer events in the pipeline
     if (state$3.length > 0) {
@@ -2541,8 +2262,8 @@ function stop$i() {
     }
 }
 
-var data$5;
-function start$i() {
+var data$8;
+function start$l() {
     bind(window, "resize", recompute$5);
     recompute$5();
 }
@@ -2550,22 +2271,22 @@ function recompute$5() {
     var de = document.documentElement;
     // window.innerWidth includes width of the scrollbar and is not a true representation of the viewport width.
     // Therefore, when possible, use documentElement's clientWidth property.
-    data$5 = {
+    data$8 = {
         width: de && "clientWidth" in de ? Math.min(de.clientWidth, window.innerWidth) : window.innerWidth,
         height: de && "clientHeight" in de ? Math.min(de.clientHeight, window.innerHeight) : window.innerHeight,
     };
     encode$2(11 /* Resize */);
 }
-function reset$9() {
-    data$5 = null;
+function reset$a() {
+    data$8 = null;
 }
-function stop$h() {
-    reset$9();
+function stop$k() {
+    reset$a();
 }
 
 var state$2 = [];
 var timeout$3 = null;
-function start$h() {
+function start$k() {
     state$2 = [];
     recompute$4();
 }
@@ -2604,7 +2325,7 @@ function recompute$4(event) {
     clearTimeout(timeout$3);
     timeout$3 = setTimeout(process$3, 500 /* LookAhead */, 10 /* Scroll */);
 }
-function reset$8() {
+function reset$9() {
     state$2 = [];
 }
 function process$3(event) {
@@ -2615,16 +2336,16 @@ function similar(last, current) {
     var dy = last.data.y - current.data.y;
     return (dx * dx + dy * dy < 20 /* Distance */ * 20 /* Distance */) && (current.time - last.time < 25 /* Interval */);
 }
-function stop$g() {
+function stop$j() {
     clearTimeout(timeout$3);
     state$2 = [];
 }
 
-var data$4 = null;
+var data$7 = null;
 var previous = null;
 var timeout$2 = null;
-function start$g() {
-    reset$7();
+function start$j() {
+    reset$8();
 }
 function observe$5(root) {
     bind(root, "selectstart", recompute$3.bind(this, root), true);
@@ -2645,12 +2366,12 @@ function recompute$3(root) {
         (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)) {
         return;
     }
-    var startNode = data$4.start ? data$4.start : null;
-    if (previous !== null && data$4.start !== null && startNode !== current.anchorNode) {
+    var startNode = data$7.start ? data$7.start : null;
+    if (previous !== null && data$7.start !== null && startNode !== current.anchorNode) {
         clearTimeout(timeout$2);
         process$2(21 /* Selection */);
     }
-    data$4 = {
+    data$7 = {
         start: current.anchorNode,
         startOffset: current.anchorOffset,
         end: current.focusNode,
@@ -2663,18 +2384,18 @@ function recompute$3(root) {
 function process$2(event) {
     schedule$1(encode$2.bind(this, event));
 }
-function reset$7() {
+function reset$8() {
     previous = null;
-    data$4 = { start: 0, startOffset: 0, end: 0, endOffset: 0 };
+    data$7 = { start: 0, startOffset: 0, end: 0, endOffset: 0 };
 }
-function stop$f() {
-    reset$7();
+function stop$i() {
+    reset$8();
     clearTimeout(timeout$2);
 }
 
 var state$1 = [];
-function start$f() {
-    reset$6();
+function start$i() {
+    reset$7();
 }
 function observe$4(root) {
     bind(root, "submit", recompute$2, true);
@@ -2683,70 +2404,70 @@ function recompute$2(evt) {
     state$1.push({ time: time(), event: 39 /* Submit */, data: { target: target(evt) } });
     schedule$1(encode$2.bind(this, 39 /* Submit */));
 }
-function reset$6() {
+function reset$7() {
     state$1 = [];
 }
-function stop$e() {
-    reset$6();
+function stop$h() {
+    reset$7();
 }
 
-var data$3;
-function start$e() {
+var data$6;
+function start$h() {
     bind(window, "pagehide", recompute$1);
 }
 function recompute$1(evt) {
-    data$3 = { name: evt.type };
+    data$6 = { name: evt.type };
     encode$2(26 /* Unload */);
     stop();
 }
-function reset$5() {
-    data$3 = null;
+function reset$6() {
+    data$6 = null;
 }
-function stop$d() {
-    reset$5();
+function stop$g() {
+    reset$6();
 }
 
-var data$2;
-function start$d() {
+var data$5;
+function start$g() {
     bind(document, "visibilitychange", recompute);
     recompute();
 }
 function recompute() {
-    data$2 = { visible: "visibilityState" in document ? document.visibilityState : "default" };
+    data$5 = { visible: "visibilityState" in document ? document.visibilityState : "default" };
     encode$2(28 /* Visibility */);
 }
-function reset$4() {
-    data$2 = null;
+function reset$5() {
+    data$5 = null;
 }
-function stop$c() {
-    reset$4();
+function stop$f() {
+    reset$5();
 }
 
-function start$c() {
-    start$a();
+function start$f() {
+    start$d();
+    start$p();
+    start$o();
     start$m();
+    start$n();
     start$l();
-    start$j();
+    start$g();
     start$k();
+    start$j();
     start$i();
-    start$d();
     start$h();
-    start$g();
-    start$f();
-    start$e();
 }
-function stop$b() {
-    stop$9();
+function stop$e() {
+    stop$c();
+    stop$o();
+    stop$n();
     stop$l();
+    stop$m();
     stop$k();
-    stop$i();
+    stop$f();
     stop$j();
+    stop$i();
     stop$h();
-    stop$c();
     stop$g();
-    stop$f();
-    stop$e();
-    stop$d();
 }
 function observe$3(root) {
     observe$6(root);
@@ -2764,8 +2485,8 @@ function observe$3(root) {
 
 var interaction = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    start: start$c,
-    stop: stop$b,
+    start: start$f,
+    stop: stop$e,
     observe: observe$3
 });
 
@@ -2782,39 +2503,39 @@ function ld(json) {
             switch (value) {
                 case "article" /* Article */:
                 case "recipe" /* Recipe */:
-                    log$1(5 /* SchemaType */, json[key]);
-                    log$1(8 /* AuthorName */, json["creator" /* Creator */]);
-                    log$1(18 /* Headline */, json["headline" /* Headline */]);
+                    log(5 /* SchemaType */, json[key]);
+                    log(8 /* AuthorName */, json["creator" /* Creator */]);
+                    log(18 /* Headline */, json["headline" /* Headline */]);
                     break;
                 case "product" /* Product */:
-                    log$1(5 /* SchemaType */, json[key]);
-                    log$1(10 /* ProductName */, json["name" /* Name */]);
-                    log$1(12 /* ProductSku */, json["sku" /* Sku */]);
+                    log(5 /* SchemaType */, json[key]);
+                    log(10 /* ProductName */, json["name" /* Name */]);
+                    log(12 /* ProductSku */, json["sku" /* Sku */]);
                     if (json["brand" /* Brand */]) {
-                        log$1(6 /* ProductBrand */, json["brand" /* Brand */]["name" /* Name */]);
+                        log(6 /* ProductBrand */, json["brand" /* Brand */]["name" /* Name */]);
                     }
                     break;
                 case "aggregaterating" /* AggregateRating */:
                     if (json["ratingValue" /* RatingValue */]) {
-                        max(11 /* RatingValue */, num(json["ratingValue" /* RatingValue */], 100 /* RatingScale */));
-                        max(18 /* BestRating */, num(json["bestRating" /* BestRating */]));
-                        max(19 /* WorstRating */, num(json["worstRating" /* WorstRating */]));
+                        max(11 /* RatingValue */, num$1(json["ratingValue" /* RatingValue */], 100 /* RatingScale */));
+                        max(18 /* BestRating */, num$1(json["bestRating" /* BestRating */]));
+                        max(19 /* WorstRating */, num$1(json["worstRating" /* WorstRating */]));
                     }
-                    max(12 /* RatingCount */, num(json["ratingCount" /* RatingCount */]));
-                    max(17 /* ReviewCount */, num(json["reviewCount" /* ReviewCount */]));
+                    max(12 /* RatingCount */, num$1(json["ratingCount" /* RatingCount */]));
+                    max(17 /* ReviewCount */, num$1(json["reviewCount" /* ReviewCount */]));
                     break;
                 case "person" /* Author */:
-                    log$1(8 /* AuthorName */, json["name" /* Name */]);
+                    log(8 /* AuthorName */, json["name" /* Name */]);
                     break;
                 case "offer" /* Offer */:
-                    log$1(7 /* ProductAvailability */, json["availability" /* Availability */]);
-                    log$1(14 /* ProductCondition */, json["itemCondition" /* ItemCondition */]);
-                    log$1(13 /* ProductCurrency */, json["priceCurrency" /* PriceCurrency */]);
-                    log$1(12 /* ProductSku */, json["sku" /* Sku */]);
-                    max(13 /* ProductPrice */, num(json["price" /* Price */]));
+                    log(7 /* ProductAvailability */, json["availability" /* Availability */]);
+                    log(14 /* ProductCondition */, json["itemCondition" /* ItemCondition */]);
+                    log(13 /* ProductCurrency */, json["priceCurrency" /* PriceCurrency */]);
+                    log(12 /* ProductSku */, json["sku" /* Sku */]);
+                    max(13 /* ProductPrice */, num$1(json["price" /* Price */]));
                     break;
                 case "brand" /* Brand */:
-                    log$1(6 /* ProductBrand */, json["name" /* Name */]);
+                    log(6 /* ProductBrand */, json["name" /* Name */]);
                     break;
             }
         }
@@ -2824,7 +2545,7 @@ function ld(json) {
         }
     }
 }
-function num(input, scale) {
+function num$1(input, scale) {
     if (scale === void 0) { scale = 1; }
     if (input !== null) {
         switch (typeof input) {
@@ -2873,6 +2594,7 @@ function processNode (node, source) {
         case Node.DOCUMENT_FRAGMENT_NODE:
             var shadowRoot = node;
             if (shadowRoot.host) {
+                parse(shadowRoot);
                 var type = typeof (shadowRoot.constructor);
                 if (type === "function" /* Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* NativeCode */) >= 0) {
                     observe$2(shadowRoot);
@@ -2946,13 +2668,13 @@ function processNode (node, source) {
                         var content = attributes["content" /* Content */];
                         switch (attributes[key]) {
                             case "og:title" /* ogTitle */:
-                                log$1(20 /* MetaTitle */, content);
+                                log(20 /* MetaTitle */, content);
                                 break;
                             case "og:type" /* ogType */:
-                                log$1(19 /* MetaType */, content);
+                                log(19 /* MetaType */, content);
                                 break;
                             case "generator" /* Generator */:
-                                log$1(21 /* Generator */, content);
+                                log(21 /* Generator */, content);
                                 break;
                         }
                     }
@@ -3017,7 +2739,7 @@ function getCssRules(sheet) {
         cssRules = sheet ? sheet.cssRules : [];
     }
     catch (e) {
-        log(1 /* CssRules */, 1 /* Warning */, e ? e.name : null);
+        log$1(1 /* CssRules */, 1 /* Warning */, e ? e.name : null);
         if (e && e.name !== "SecurityError") {
             throw e;
         }
@@ -3092,13 +2814,13 @@ var attachShadow = null;
 var queue$1 = [];
 var timeout$1 = null;
 var activePeriod = null;
-var history$1 = {};
-function start$b() {
+var history$2 = {};
+function start$e() {
     observers = [];
     queue$1 = [];
     timeout$1 = null;
     activePeriod = 0;
-    history$1 = {};
+    history$2 = {};
     if (insertRule === null) {
         insertRule = CSSStyleSheet.prototype.insertRule;
     }
@@ -3106,7 +2828,7 @@ function start$b() {
         deleteRule = CSSStyleSheet.prototype.deleteRule;
     }
     if (attachShadow === null) {
-        attachShadow = HTMLElement.prototype.attachShadow;
+        attachShadow = Element.prototype.attachShadow;
     }
     // Some popular open source libraries, like styled-components, optimize performance
     // by injecting CSS using insertRule API vs. appending text node. A side effect of
@@ -3124,7 +2846,7 @@ function start$b() {
     // In case we are unable to add a hook and browser throws an exception,
     // reset attachShadow variable and resume processing like before
     try {
-        HTMLElement.prototype.attachShadow = function () {
+        Element.prototype.attachShadow = function () {
             return schedule(attachShadow.apply(this, arguments));
         };
     }
@@ -3149,7 +2871,7 @@ function observe$1(node) {
         }
     }
     catch (e) {
-        log(2 /* MutationObserver */, 0 /* Info */, e ? e.name : null);
+        log$1(2 /* MutationObserver */, 0 /* Info */, e ? e.name : null);
     }
 }
 function monitor(frame) {
@@ -3160,7 +2882,7 @@ function monitor(frame) {
         bind(frame, "load" /* LoadEvent */, generate.bind(this, frame, "childList" /* ChildList */), true);
     }
 }
-function stop$a() {
+function stop$d() {
     for (var _i = 0, observers_1 = observers; _i < observers_1.length; _i++) {
         var observer = observers_1[_i];
         if (observer) {
@@ -3180,10 +2902,10 @@ function stop$a() {
     }
     // Restoring original attachShadow
     if (attachShadow != null) {
-        HTMLElement.prototype.attachShadow = attachShadow;
+        Element.prototype.attachShadow = attachShadow;
         attachShadow = null;
     }
-    history$1 = {};
+    history$2 = {};
     mutations = [];
     queue$1 = [];
     activePeriod = 0;
@@ -3195,11 +2917,11 @@ function active$2() {
 function handle$1(m) {
     // Queue up mutation records for asynchronous processing
     var now = time();
-    track$5(6 /* Mutation */, now);
+    track$6(6 /* Mutation */, now);
     mutations.push({ time: now, mutations: m });
     schedule$1(process$1, 1 /* High */).then(function () {
-        measure(compute$6)();
-        measure(compute$4)();
+        measure(compute$7)();
+        measure(compute$5)();
     });
 }
 function process$1() {
@@ -3209,7 +2931,7 @@ function process$1() {
             switch (_b.label) {
                 case 0:
                     timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$t(timer);
+                    start$w(timer);
                     _b.label = 1;
                 case 1:
                     if (!(mutations.length > 0)) return [3 /*break*/, 8];
@@ -3230,10 +2952,13 @@ function process$1() {
                         return [3 /*break*/, 6];
                     }
                     target = mutation.target;
-                    type = track$2(mutation, timer);
+                    type = track$3(mutation, timer);
                     if (type && target && target.ownerDocument) {
                         parse(target.ownerDocument);
                     }
+                    if (type && target && target.nodeType == Node.DOCUMENT_FRAGMENT_NODE && target.host) {
+                        parse(target);
+                    }
                     switch (type) {
                         case "attributes" /* Attributes */:
                             processNode(target, 3 /* Attributes */);
@@ -3261,13 +2986,13 @@ function process$1() {
                     _b.sent();
                     return [3 /*break*/, 1];
                 case 8:
-                    stop$q(timer);
+                    stop$t(timer);
                     return [2 /*return*/];
             }
         });
     });
 }
-function track$2(m, timer) {
+function track$3(m, timer) {
     var value = m.target ? get(m.target.parentNode) : null;
     // Check if the parent is already discovered and that the parent is not the document root
     if (value && value.data.tag !== "HTML" /* HTML */) {
@@ -3280,8 +3005,8 @@ function track$2(m, timer) {
         // In those cases, IDs will change however the selector (which is relative to DOM xPath) remains the same
         var key = [parent_1, element, m.attributeName, names(m.addedNodes), names(m.removedNodes)].join();
         // Initialize an entry if it doesn't already exist
-        history$1[key] = key in history$1 ? history$1[key] : [0];
-        var h = history$1[key];
+        history$2[key] = key in history$2 ? history$2[key] : [0];
+        var h = history$2[key];
         // Lookup any pending nodes queued up for removal, and process them now if we suspended a mutation before
         if (inactive === false && h[0] >= 10 /* MutationSuspendThreshold */) {
             processNodeList(h[1], 2 /* ChildListRemove */, timer);
@@ -3354,10 +3079,10 @@ function schedule(node) {
     if (timeout$1) {
         clearTimeout(timeout$1);
     }
-    timeout$1 = setTimeout(trigger, 33 /* LookAhead */);
+    timeout$1 = setTimeout(trigger$1, 33 /* LookAhead */);
     return node;
 }
-function trigger() {
+function trigger$1() {
     for (var _i = 0, queue_1 = queue$1; _i < queue_1.length; _i++) {
         var node = queue_1[_i];
         var shadowRoot = node && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
@@ -3401,7 +3126,7 @@ function link(node) {
     }
     return null;
 }
-function metadata(node, event) {
+function metadata$2(node, event) {
     // If the node is null, we return a reserved value for id: 0. Valid assignment of id begins from 1+.
     var output = { id: 0, hash: null, privacy: 2 /* Text */, node: node };
     if (node) {
@@ -3411,7 +3136,7 @@ function metadata(node, event) {
             output.hash = value.hash;
             output.privacy = value.metadata.privacy;
             if (value.region) {
-                track$3(value.region, event);
+                track$4(value.region, event);
             }
         }
     }
@@ -3436,7 +3161,7 @@ function encode$2 (type) {
                 case 20 /* TouchCancel */:
                     for (_i = 0, _a = state$3; _i < _a.length; _i++) {
                         entry = _a[_i];
-                        pTarget = metadata(entry.data.target, entry.event);
+                        pTarget = metadata$2(entry.data.target, entry.event);
                         if (pTarget.id > 0) {
                             tokens = [entry.time, entry.event];
                             tokens.push(pTarget.id);
@@ -3446,12 +3171,12 @@ function encode$2 (type) {
                             track$7(entry.event, entry.data.x, entry.data.y);
                         }
                     }
-                    reset$a();
+                    reset$b();
                     break;
                 case 9 /* Click */:
                     for (_b = 0, _c = state$6; _b < _c.length; _b++) {
                         entry = _c[_b];
-                        cTarget = metadata(entry.data.target, entry.event);
+                        cTarget = metadata$2(entry.data.target, entry.event);
                         tokens = [entry.time, entry.event];
                         cHash = cTarget.hash.join("." /* Dot */);
                         tokens.push(cTarget.id);
@@ -3466,65 +3191,65 @@ function encode$2 (type) {
                         tokens.push(entry.data.link);
                         tokens.push(cHash);
                         queue(tokens);
-                        track$1(entry.time, entry.event, cHash, entry.data.x, entry.data.y, entry.data.reaction, entry.data.context);
+                        track$2(entry.time, entry.event, cHash, entry.data.x, entry.data.y, entry.data.reaction, entry.data.context);
                     }
-                    reset$d();
+                    reset$e();
                     break;
                 case 38 /* Clipboard */:
                     for (_d = 0, _e = state$5; _d < _e.length; _d++) {
                         entry = _e[_d];
                         tokens = [entry.time, entry.event];
-                        target = metadata(entry.data.target, entry.event);
+                        target = metadata$2(entry.data.target, entry.event);
                         if (target.id > 0) {
                             tokens.push(target.id);
                             tokens.push(entry.data.action);
                             queue(tokens);
                         }
                     }
-                    reset$c();
+                    reset$d();
                     break;
                 case 11 /* Resize */:
-                    r = data$5;
+                    r = data$8;
                     tokens.push(r.width);
                     tokens.push(r.height);
                     track$7(type, r.width, r.height);
-                    reset$9();
+                    reset$a();
                     queue(tokens);
                     break;
                 case 26 /* Unload */:
-                    u = data$3;
+                    u = data$6;
                     tokens.push(u.name);
-                    reset$5();
+                    reset$6();
                     queue(tokens);
                     break;
                 case 27 /* Input */:
                     for (_f = 0, _g = state$4; _f < _g.length; _f++) {
                         entry = _g[_f];
-                        iTarget = metadata(entry.data.target, entry.event);
+                        iTarget = metadata$2(entry.data.target, entry.event);
                         tokens = [entry.time, entry.event];
                         tokens.push(iTarget.id);
                         tokens.push(entry.data.value);
                         queue(tokens);
                     }
-                    reset$b();
+                    reset$c();
                     break;
                 case 21 /* Selection */:
-                    s = data$4;
+                    s = data$7;
                     if (s) {
-                        startTarget = metadata(s.start, type);
-                        endTarget = metadata(s.end, type);
+                        startTarget = metadata$2(s.start, type);
+                        endTarget = metadata$2(s.end, type);
                         tokens.push(startTarget.id);
                         tokens.push(s.startOffset);
                         tokens.push(endTarget.id);
                         tokens.push(s.endOffset);
-                        reset$7();
+                        reset$8();
                         queue(tokens);
                     }
                     break;
                 case 10 /* Scroll */:
                     for (_h = 0, _j = state$2; _h < _j.length; _h++) {
                         entry = _j[_h];
-                        sTarget = metadata(entry.data.target, entry.event);
+                        sTarget = metadata$2(entry.data.target, entry.event);
                         if (sTarget.id > 0) {
                             tokens = [entry.time, entry.event];
                             tokens.push(sTarget.id);
@@ -3534,19 +3259,19 @@ function encode$2 (type) {
                             track$7(entry.event, entry.data.x, entry.data.y);
                         }
                     }
-                    reset$8();
+                    reset$9();
                     break;
                 case 39 /* Submit */:
                     for (_k = 0, _l = state$1; _k < _l.length; _k++) {
                         entry = _l[_k];
                         tokens = [entry.time, entry.event];
-                        target = metadata(entry.data.target, entry.event);
+                        target = metadata$2(entry.data.target, entry.event);
                         if (target.id > 0) {
                             tokens.push(target.id);
                             queue(tokens);
                         }
                     }
-                    reset$6();
+                    reset$7();
                     break;
                 case 22 /* Timeline */:
                     for (_m = 0, _o = updates$1; _m < _o.length; _m++) {
@@ -3560,14 +3285,14 @@ function encode$2 (type) {
                         tokens.push(entry.data.context);
                         queue(tokens, false);
                     }
-                    reset$3();
+                    reset$4();
                     break;
                 case 28 /* Visibility */:
-                    v = data$2;
+                    v = data$5;
                     tokens.push(v.visible);
                     queue(tokens);
                     visibility(t, v.visible);
-                    reset$4();
+                    reset$5();
                     break;
             }
             return [2 /*return*/];
@@ -3577,14 +3302,14 @@ function encode$2 (type) {
 
 var state = [];
 var updates$1 = [];
-function start$a() {
+function start$d() {
     state = [];
-    reset$3();
+    reset$4();
 }
-function reset$3() {
+function reset$4() {
     updates$1 = [];
 }
-function track$1(time, event, hash, x, y, reaction, context) {
+function track$2(time, event, hash, x, y, reaction, context) {
     if (reaction === void 0) { reaction = 1 /* True */; }
     if (context === void 0) { context = 0 /* Self */; }
     state.push({
@@ -3604,10 +3329,10 @@ function track$1(time, event, hash, x, y, reaction, context) {
     // We would still need to capture the last scroll position as part of the baseline event, even when timeline will be empty.
     track$7(event, x, y);
 }
-function compute$3() {
+function compute$4() {
     var temp = [];
     updates$1 = [];
-    var max = data$f.start + data$f.duration;
+    var max = data$1.start + data$1.duration;
     var min = Math.max(max - 2000 /* TimelineSpan */, 0);
     for (var _i = 0, state_1 = state; _i < state_1.length; _i++) {
         var s = state_1[_i];
@@ -3621,9 +3346,9 @@ function compute$3() {
     state = temp; // Drop events less than the min time
     encode$2(22 /* Timeline */);
 }
-function stop$9() {
+function stop$c() {
     state = [];
-    reset$3();
+    reset$4();
 }
 
 var discoverBytes = 0;
@@ -3634,8 +3359,8 @@ var timeout = null;
 var transit;
 var active$1;
 var queuedTime = 0;
-var track;
-function start$9() {
+var track$1;
+function start$c() {
     active$1 = true;
     discoverBytes = 0;
     playbackBytes = 0;
@@ -3643,7 +3368,7 @@ function start$9() {
     playback = [];
     analysis = [];
     transit = {};
-    track = null;
+    track$1 = null;
 }
 function queue(tokens, transmit) {
     if (transmit === void 0) { transmit = true; }
@@ -3678,15 +3403,15 @@ function queue(tokens, transmit) {
         // We enrich the data going out with the existing upload. In these cases, call to upload comes with 'transmit' set to false.
         if (transmit && timeout === null) {
             if (type !== 25 /* Ping */) {
-                reset$k();
+                reset$m();
             }
             timeout = setTimeout(upload, gap);
             queuedTime = now;
-            check$3(playbackBytes);
+            check$2(playbackBytes);
         }
     }
 }
-function stop$8() {
+function stop$b() {
     clearTimeout(timeout);
     upload(true);
     discoverBytes = 0;
@@ -3695,7 +3420,7 @@ function stop$8() {
     playback = [];
     analysis = [];
     transit = {};
-    track = null;
+    track$1 = null;
     active$1 = false;
 }
 function upload(final) {
@@ -3706,15 +3431,15 @@ function upload(final) {
             switch (_b.label) {
                 case 0:
                     timeout = null;
-                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* MaxFirstPayloadBytes */ || data$f.sequence > 0);
+                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* MaxFirstPayloadBytes */ || data$1.sequence > 0);
                     if (sendPlaybackBytes) {
                         max(1 /* Playback */, 1 /* True */);
                     }
                     // CAUTION: Ensure "transmit" is set to false in the queue function for following events
                     // Otherwise you run a risk of infinite loop.
+                    compute$5();
                     compute$4();
-                    compute$3();
-                    compute$7();
+                    compute$8();
                     last = final === true;
                     e = JSON.stringify(envelope(last));
                     a = "[" + analysis.join() + "]";
@@ -3731,7 +3456,7 @@ function upload(final) {
                 case 3:
                     zipped = _a;
                     sum(2 /* TotalBytes */, zipped ? zipped.length : payload.length);
-                    send(payload, zipped, data$f.sequence, last);
+                    send(payload, zipped, data$1.sequence, last);
                     // Clear out events now that payload has been dispatched
                     analysis = [];
                     if (sendPlaybackBytes) {
@@ -3777,265 +3502,607 @@ function send(payload, zipped, sequence, beacon) {
             else {
                 transit[sequence] = { data: payload, attempts: 1 };
             }
-            var xhr_1 = new XMLHttpRequest();
-            xhr_1.open("POST", url);
-            if (sequence !== null) {
-                xhr_1.onreadystatechange = function () { measure(check$2)(xhr_1, sequence); };
+            var xhr_1 = new XMLHttpRequest();
+            xhr_1.open("POST", url);
+            if (sequence !== null) {
+                xhr_1.onreadystatechange = function () { measure(check$3)(xhr_1, sequence); };
+            }
+            xhr_1.withCredentials = true;
+            if (zipped) {
+                // If we do have valid compressed array, send it with appropriate HTTP headers so server can decode it appropriately
+                xhr_1.setRequestHeader("Accept" /* Accept */, "application/x-clarity-gzip" /* ClarityGzip */);
+                xhr_1.send(zipped);
+            }
+            else {
+                // In all other cases, continue sending string back to the server
+                xhr_1.send(payload);
+            }
+        }
+    }
+    else if (config$1.upload) {
+        var callback = config$1.upload;
+        callback(payload);
+        done(sequence);
+    }
+}
+function check$3(xhr, sequence) {
+    var transitData = transit[sequence];
+    if (xhr && xhr.readyState === 4 /* Done */ && transitData) {
+        // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
+        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* RetryLimit */) {
+            // We re-attempt in all cases except when server explicitly rejects our request with 4XX error 
+            if (xhr.status >= 400 && xhr.status < 500) {
+                // In case of a 4XX response from the server, we bail out instead of trying again
+                trigger(6 /* Server */);
+            }
+            else {
+                // Browser will send status = 0 when it refuses to put network request over the wire
+                // This could happen for several reasons, couple of known ones are:
+                //    1: Browsers block upload because of content security policy violation
+                //    2: Safari will terminate pending XHR requests with status code 0 if the user navigates away from the page
+                // In any case, we switch the upload URL to fallback configuration (if available) before re-trying one more time
+                if (xhr.status === 0) {
+                    config$1.upload = config$1.fallback ? config$1.fallback : config$1.upload;
+                }
+                // In all other cases, re-attempt sending the same data
+                // For retry we always fallback to string payload, even though we may have attempted
+                // sending zipped payload earlier
+                send(transitData.data, null, sequence);
+            }
+        }
+        else {
+            track$1 = { sequence: sequence, attempts: transitData.attempts, status: xhr.status };
+            // Send back an event only if we were not successful in our first attempt
+            if (transitData.attempts > 1) {
+                encode$1(2 /* Upload */);
+            }
+            // Handle response if it was a 200 response with a valid body
+            if (xhr.status === 200 && xhr.responseText) {
+                response(xhr.responseText);
+            }
+            // If we exhausted our retries then trigger Clarity's shutdown for this page since the data will be incomplete
+            if (xhr.status === 0) {
+                // And, right before we terminate the session, we will attempt one last time to see if we can use
+                // different transport option (sendBeacon vs. XHR) to get this data to the server for analysis purposes
+                send(transitData.data, null, sequence, true);
+                trigger(3 /* Retry */);
+            }
+            // Signal that this request completed successfully
+            if (xhr.status >= 200 && xhr.status <= 208) {
+                done(sequence);
+            }
+            // Stop tracking this payload now that it's all done
+            delete transit[sequence];
+        }
+    }
+}
+function done(sequence) {
+    // If we everything went successfully, and it is the first sequence, save this session for future reference
+    if (sequence === 1) {
+        save();
+    }
+}
+function delay() {
+    // Progressively increase delay as we continue to send more payloads from the client to the server
+    // If we are not uploading data to a server, and instead invoking UploadCallback, in that case keep returning configured value 
+    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* MinUploadDelay */ : data$1.sequence * config$1.delay;
+    return typeof config$1.upload === "string" /* String */ ? Math.max(Math.min(gap, 30000 /* MaxUploadDelay */), 100 /* MinUploadDelay */) : config$1.delay;
+}
+function response(payload) {
+    var key = payload && payload.length > 0 ? payload.split(" ")[0] : "" /* Empty */;
+    switch (key) {
+        case "END" /* End */:
+            // Clear out session storage and end the session so we can start fresh the next time
+            trigger(6 /* Server */);
+            break;
+        case "UPGRADE" /* Upgrade */:
+            // Upgrade current session to send back playback information
+            upgrade("Auto" /* Auto */);
+            break;
+    }
+}
+
+function encode$1 (event) {
+    var t = time();
+    var tokens = [t, event];
+    switch (event) {
+        case 4 /* Baseline */:
+            var b = state$9;
+            if (b) {
+                tokens = [b.time, b.event];
+                tokens.push(b.data.visible);
+                tokens.push(b.data.docWidth);
+                tokens.push(b.data.docHeight);
+                tokens.push(b.data.screenWidth);
+                tokens.push(b.data.screenHeight);
+                tokens.push(b.data.scrollX);
+                tokens.push(b.data.scrollY);
+                tokens.push(b.data.pointerX);
+                tokens.push(b.data.pointerY);
+                tokens.push(b.data.activityTime);
+                queue(tokens, false);
+            }
+            reset$o();
+            break;
+        case 25 /* Ping */:
+            tokens.push(data$g.gap);
+            queue(tokens);
+            break;
+        case 35 /* Limit */:
+            tokens.push(data$4.check);
+            queue(tokens, false);
+            break;
+        case 3 /* Upgrade */:
+            tokens.push(data$e.key);
+            queue(tokens);
+            break;
+        case 2 /* Upload */:
+            tokens.push(track$1.sequence);
+            tokens.push(track$1.attempts);
+            tokens.push(track$1.status);
+            queue(tokens, false);
+            break;
+        case 24 /* Custom */:
+            tokens.push(data$i.key);
+            tokens.push(data$i.value);
+            queue(tokens);
+            break;
+        case 34 /* Variable */:
+            var variableKeys = Object.keys(data$d);
+            if (variableKeys.length > 0) {
+                for (var _i = 0, variableKeys_1 = variableKeys; _i < variableKeys_1.length; _i++) {
+                    var v = variableKeys_1[_i];
+                    tokens.push(v);
+                    tokens.push(data$d[v]);
+                }
+                reset$k();
+                queue(tokens, false);
+            }
+            break;
+        case 0 /* Metric */:
+            var metricKeys = Object.keys(updates$3);
+            if (metricKeys.length > 0) {
+                for (var _a = 0, metricKeys_1 = metricKeys; _a < metricKeys_1.length; _a++) {
+                    var m = metricKeys_1[_a];
+                    var key = parseInt(m, 10);
+                    tokens.push(key);
+                    // For computation, we need microseconds precision that performance.now() API offers
+                    // However, for data over the wire, we round it off to milliseconds precision.
+                    tokens.push(Math.round(updates$3[m]));
+                }
+                reset$n();
+                queue(tokens, false);
             }
-            xhr_1.withCredentials = true;
-            if (zipped) {
-                // If we do have valid compressed array, send it with appropriate HTTP headers so server can decode it appropriately
-                xhr_1.setRequestHeader("Accept" /* Accept */, "application/x-clarity-gzip" /* ClarityGzip */);
-                xhr_1.send(zipped);
+            break;
+        case 1 /* Dimension */:
+            var dimensionKeys = Object.keys(updates);
+            if (dimensionKeys.length > 0) {
+                for (var _b = 0, dimensionKeys_1 = dimensionKeys; _b < dimensionKeys_1.length; _b++) {
+                    var d = dimensionKeys_1[_b];
+                    var key = parseInt(d, 10);
+                    tokens.push(key);
+                    tokens.push(updates[d]);
+                }
+                reset$3();
+                queue(tokens, false);
             }
-            else {
-                // In all other cases, continue sending string back to the server
-                xhr_1.send(payload);
+            break;
+        case 36 /* Summary */:
+            var eventKeys = Object.keys(data$f);
+            if (eventKeys.length > 0) {
+                for (var _c = 0, eventKeys_1 = eventKeys; _c < eventKeys_1.length; _c++) {
+                    var e = eventKeys_1[_c];
+                    var key = parseInt(e, 10);
+                    tokens.push(key);
+                    tokens.push([].concat.apply([], data$f[e]));
+                }
+                reset$l();
+                queue(tokens, false);
             }
+            break;
+    }
+}
+
+var data$4;
+function start$b() {
+    data$4 = { check: 0 /* None */ };
+}
+function check$2(bytes) {
+    if (data$4.check === 0 /* None */) {
+        var reason = data$4.check;
+        reason = data$1.sequence >= 128 /* PayloadLimit */ ? 1 /* Payload */ : reason;
+        reason = time() > 7200000 /* ShutdownLimit */ ? 2 /* Shutdown */ : reason;
+        reason = bytes > 10485760 /* PlaybackBytesLimit */ ? 2 /* Shutdown */ : reason;
+        if (reason !== data$4.check) {
+            trigger(reason);
         }
     }
-    else if (config$1.upload) {
-        var callback = config$1.upload;
-        callback(payload);
-        done(sequence);
+}
+function trigger(reason) {
+    data$4.check = reason;
+    clear();
+    stop();
+}
+function compute$3() {
+    if (data$4.check !== 0 /* None */) {
+        encode$1(35 /* Limit */);
     }
 }
-function check$2(xhr, sequence) {
-    var transitData = transit[sequence];
-    if (xhr && xhr.readyState === 4 /* Done */ && transitData) {
-        // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
-        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* RetryLimit */) {
-            // We re-attempt in all cases except when server explicitly rejects our request with 4XX error 
-            if (xhr.status >= 400 && xhr.status < 500) {
-                // In case of a 4XX response from the server, we bail out instead of trying again
-                trigger$1(6 /* Server */);
-            }
-            else {
-                // Browser will send status = 0 when it refuses to put network request over the wire
-                // This could happen for several reasons, couple of known ones are:
-                //    1: Browsers block upload because of content security policy violation
-                //    2: Safari will terminate pending XHR requests with status code 0 if the user navigates away from the page
-                // In any case, we switch the upload URL to fallback configuration (if available) before re-trying one more time
-                if (xhr.status === 0) {
-                    config$1.upload = config$1.fallback ? config$1.fallback : config$1.upload;
-                }
-                // In all other cases, re-attempt sending the same data
-                // For retry we always fallback to string payload, even though we may have attempted
-                // sending zipped payload earlier
-                send(transitData.data, null, sequence);
-            }
+function stop$a() {
+    data$4 = null;
+}
+
+var data$3 = null;
+var updates = null;
+function start$a() {
+    data$3 = {};
+    updates = {};
+}
+function stop$9() {
+    data$3 = {};
+    updates = {};
+}
+function log(dimension, value) {
+    // Check valid value before moving ahead
+    if (value) {
+        // Ensure received value is casted into a string if it wasn't a string to begin with
+        value = "" + value;
+        if (!(dimension in data$3)) {
+            data$3[dimension] = [];
         }
-        else {
-            track = { sequence: sequence, attempts: transitData.attempts, status: xhr.status };
-            // Send back an event only if we were not successful in our first attempt
-            if (transitData.attempts > 1) {
-                encode$1(2 /* Upload */);
-            }
-            // Handle response if it was a 200 response with a valid body
-            if (xhr.status === 200 && xhr.responseText) {
-                response(xhr.responseText);
-            }
-            // If we exhausted our retries then trigger Clarity's shutdown for this page since the data will be incomplete
-            if (xhr.status === 0) {
-                // And, right before we terminate the session, we will attempt one last time to see if we can use
-                // different transport option (sendBeacon vs. XHR) to get this data to the server for analysis purposes
-                send(transitData.data, null, sequence, true);
-                trigger$1(3 /* Retry */);
+        if (data$3[dimension].indexOf(value) < 0) {
+            data$3[dimension].push(value);
+            // If this is a new value, track it as part of updates object
+            // This allows us to only send back new values in subsequent payloads
+            if (!(dimension in updates)) {
+                updates[dimension] = [];
             }
-            // Signal that this request completed successfully
-            if (xhr.status >= 200 && xhr.status <= 208) {
-                done(sequence);
+            updates[dimension].push(value);
+            // Limit check to ensure we have a cap on number of dimensions we can collect
+            if (data$3[dimension].length > 128 /* CollectionLimit */) {
+                trigger(5 /* Collection */);
             }
-            // Stop tracking this payload now that it's all done
-            delete transit[sequence];
         }
     }
 }
-function done(sequence) {
-    // If we everything went successfully, and it is the first sequence, save this session for future reference
-    if (sequence === 1) {
-        save();
-    }
-}
-function delay() {
-    // Progressively increase delay as we continue to send more payloads from the client to the server
-    // If we are not uploading data to a server, and instead invoking UploadCallback, in that case keep returning configured value 
-    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* MinUploadDelay */ : data$f.sequence * config$1.delay;
-    return typeof config$1.upload === "string" /* String */ ? Math.max(Math.min(gap, 30000 /* MaxUploadDelay */), 100 /* MinUploadDelay */) : config$1.delay;
+function compute$2() {
+    encode$1(1 /* Dimension */);
+}
+function reset$3() {
+    updates = {};
+}
+
+var data$2 = null;
+var callback = null;
+var rootDomain = null;
+function start$9() {
+    callback = null;
+    rootDomain = null;
+    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Empty */;
+    var title = document && document.title ? document.title : "" /* Empty */;
+    // Populate ids for this page
+    var s = session();
+    var u = user();
+    data$2 = {
+        projectId: config$1.projectId || hash(location.host),
+        userId: u.id,
+        sessionId: s.session,
+        pageNum: s.count
+    };
+    // Override configuration based on what's in the session storage, unless it is blank (e.g. using upload callback, like in devtools)
+    config$1.lean = config$1.track && s.upgrade !== null ? s.upgrade === 0 /* False */ : config$1.lean;
+    config$1.upload = config$1.track && typeof config$1.upload === "string" /* String */ && s.upload && s.upload.length > "https://" /* HTTPS */.length ? s.upload : config$1.upload;
+    // Log dimensions
+    log(0 /* UserAgent */, ua);
+    log(3 /* PageTitle */, title);
+    log(1 /* Url */, location.href);
+    log(2 /* Referrer */, document.referrer);
+    log(15 /* TabId */, tab());
+    log(16 /* PageLanguage */, document.documentElement.lang);
+    log(17 /* DocumentDirection */, document.dir);
+    if (navigator) {
+        log(9 /* Language */, navigator.userLanguage || navigator.language);
+        max(26 /* Automation */, navigator.webdriver ? 1 /* True */ : 0 /* False */);
+        userAgentData();
+    }
+    // Metrics
+    max(0 /* ClientTimestamp */, s.ts);
+    max(1 /* Playback */, 0 /* False */);
+    if (screen) {
+        max(14 /* ScreenWidth */, Math.round(screen.width));
+        max(15 /* ScreenHeight */, Math.round(screen.height));
+        max(16 /* ColorDepth */, Math.round(screen.colorDepth));
+    }
+    // Read cookies specified in configuration
+    for (var _i = 0, _a = config$1.cookies; _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = getCookie(key);
+        if (value) {
+            set(key, value);
+        }
+    }
+    // Track ids using a cookie if configuration allows it
+    track(u);
+}
+function userAgentData() {
+    if (navigator["userAgentData"] && navigator["userAgentData"].getHighEntropyValues) {
+        navigator["userAgentData"].getHighEntropyValues(["model",
+            "platform",
+            "platformVersion",
+            "uaFullVersion"])
+            .then(function (ua) {
+            var _a;
+            log(22 /* Platform */, ua.platform);
+            log(23 /* PlatformVersion */, ua.platformVersion);
+            (_a = ua.brands) === null || _a === void 0 ? void 0 : _a.forEach(function (brand) {
+                log(24 /* Brand */, brand.name + "~" /* Tilde */ + brand.version);
+            });
+            log(25 /* Model */, ua.model);
+            max(27 /* Mobile */, ua.mobile ? 1 /* True */ : 0 /* False */);
+        });
+    }
+}
+function stop$8() {
+    callback = null;
+    rootDomain = null;
+    data$2 = null;
+}
+function metadata(cb, wait) {
+    if (wait === void 0) { wait = true; }
+    if (data$2 && wait === false) {
+        // Immediately invoke the callback if the caller explicitly doesn't want to wait for the upgrade confirmation
+        cb(data$2, !config$1.lean);
+    }
+    else {
+        // Save the callback for future reference; so we can inform the caller when page gets upgraded and we have a valid playback flag
+        callback = cb;
+    }
+}
+function id() {
+    return data$2 ? [data$2.userId, data$2.sessionId, data$2.pageNum].join("." /* Dot */) : "" /* Empty */;
+}
+function consent() {
+    if (active()) {
+        config$1.track = true;
+        track(user(), 1 /* True */);
+    }
+}
+function clear() {
+    // Clear any stored information in the cookie that tracks session information so we can restart fresh the next time
+    setCookie("_clsk" /* SessionKey */, "" /* Empty */, 0);
+}
+function tab() {
+    var id = shortid();
+    if (config$1.track && supported(window, "sessionStorage" /* SessionStorage */)) {
+        var value = sessionStorage.getItem("_cltk" /* TabKey */);
+        id = value ? value : id;
+        sessionStorage.setItem("_cltk" /* TabKey */, id);
+    }
+    return id;
+}
+function save() {
+    var ts = Math.round(Date.now());
+    var upgrade = config$1.lean ? 0 /* False */ : 1 /* True */;
+    var upload = config$1.upload && typeof config$1.upload === "string" /* String */ ? config$1.upload.replace("https://" /* HTTPS */, "" /* Empty */) : "" /* Empty */;
+    if (upgrade && callback) {
+        callback(data$2, !config$1.lean);
+    }
+    setCookie("_clsk" /* SessionKey */, [data$2.sessionId, ts, data$2.pageNum, upgrade, upload].join("|" /* Pipe */), 1 /* SessionExpire */);
+}
+function supported(target, api) {
+    try {
+        return !!target[api];
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function track(u, consent) {
+    if (consent === void 0) { consent = null; }
+    // If consent is not explicitly specified, infer it from the user object
+    consent = consent === null ? u.consent : consent;
+    // Convert time precision into days to reduce number of bytes we have to write in a cookie
+    // E.g. Math.ceil(1628735962643 / (24*60*60*1000)) => 18852 (days) => ejo in base36 (13 bytes => 3 bytes)
+    var end = Math.ceil((Date.now() + (365 /* Expire */ * 86400000 /* Day */)) / 86400000 /* Day */);
+    // To avoid cookie churn, write user id cookie only once every day
+    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* CookieInterval */ || u.consent !== consent) {
+        setCookie("_clck" /* CookieKey */, [data$2.userId, 1 /* CookieVersion */, end.toString(36), consent].join("|" /* Pipe */), 365 /* Expire */);
+    }
+}
+function shortid() {
+    var id = Math.floor(Math.random() * Math.pow(2, 32));
+    if (window && window.crypto && window.crypto.getRandomValues && Uint32Array) {
+        id = window.crypto.getRandomValues(new Uint32Array(1))[0];
+    }
+    return id.toString(36);
+}
+function session() {
+    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Empty */ };
+    var value = getCookie("_clsk" /* SessionKey */);
+    if (value) {
+        var parts = value.split("|" /* Pipe */);
+        // Making it backward & forward compatible by using greater than comparison (v0.6.21)
+        // In future version, we can reduce the parts length to be 5 where the last part contains the full upload URL
+        if (parts.length >= 5 && output.ts - num(parts[1]) < 1800000 /* SessionTimeout */) {
+            output.session = parts[0];
+            output.count = num(parts[2]) + 1;
+            output.upgrade = num(parts[3]);
+            output.upload = parts.length >= 6 ? "" + "https://" /* HTTPS */ + parts[5] + "/" + parts[4] : "" + "https://" /* HTTPS */ + parts[4];
+        }
+    }
+    return output;
+}
+function num(string, base) {
+    if (base === void 0) { base = 10; }
+    return parseInt(string, base);
 }
-function response(payload) {
-    var key = payload && payload.length > 0 ? payload.split(" ")[0] : "" /* Empty */;
-    switch (key) {
-        case "END" /* End */:
-            // Clear out session storage and end the session so we can start fresh the next time
-            trigger$1(6 /* Server */);
-            break;
-        case "UPGRADE" /* Upgrade */:
-            // Upgrade current session to send back playback information
-            upgrade("Auto" /* Auto */);
-            break;
+function user() {
+    var output = { id: shortid(), expiry: null, consent: 0 /* False */ };
+    var cookie = getCookie("_clck" /* CookieKey */);
+    if (cookie && cookie.length > 0) {
+        // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
+        var parts = cookie.split("|" /* Pipe */);
+        // For backward compatibility introduced in v0.6.18; following code can be removed with future iterations
+        // Count number of times Clarity's user cookie crumb appears in document.cookie (could be on different sub-domains e.g. www.domain.com and .domain.com)
+        var count = 0;
+        for (var _i = 0, _a = document.cookie.split(";" /* Semicolon */); _i < _a.length; _i++) {
+            var c = _a[_i];
+            count += c.split("=" /* Equals */)[0].trim() === "_clck" /* CookieKey */ ? 1 : 0;
+        }
+        // Check if we either got version-less cookie value or saw multiple copies of the user cookie crumbs
+        // In both these cases, we go ahead and delete the existing cookie set on current domain
+        if (parts.length === 1 || count > 1) {
+            var deleted = "" + ";" /* Semicolon */ + "expires=" /* Expires */ + (new Date(0)).toUTCString() + ";path=/" /* Path */;
+            // First, delete current user cookie which might be set on current sub-domain vs. root domain
+            document.cookie = "_clck" /* CookieKey */ + "=" + deleted;
+            // Second, same thing for current session cookie so it can be re-written later with the root domain
+            document.cookie = "_clsk" /* SessionKey */ + "=" + deleted;
+        }
+        // End code for backward compatibility
+        // Read version information and timestamp from cookie, if available
+        if (parts.length > 2) {
+            output.expiry = num(parts[2], 36);
+        }
+        // Check if we have explicit consent to track this user
+        if (parts.length > 3 && num(parts[3]) === 1) {
+            output.consent = 1 /* True */;
+        }
+        // Set track configuration to true for this user if we have explicit consent, regardless of project setting
+        config$1.track = config$1.track || output.consent === 1 /* True */;
+        // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
+        output.id = config$1.track ? parts[0] : output.id;
     }
-}
-
-function encode$1 (event) {
-    var t = time();
-    var tokens = [t, event];
-    switch (event) {
-        case 4 /* Baseline */:
-            var b = state$9;
-            if (b) {
-                tokens = [b.time, b.event];
-                tokens.push(b.data.visible);
-                tokens.push(b.data.docWidth);
-                tokens.push(b.data.docHeight);
-                tokens.push(b.data.screenWidth);
-                tokens.push(b.data.screenHeight);
-                tokens.push(b.data.scrollX);
-                tokens.push(b.data.scrollY);
-                tokens.push(b.data.pointerX);
-                tokens.push(b.data.pointerY);
-                tokens.push(b.data.activityTime);
-                queue(tokens, false);
-            }
-            reset$o();
-            break;
-        case 25 /* Ping */:
-            tokens.push(data$c.gap);
-            queue(tokens);
-            break;
-        case 35 /* Limit */:
-            tokens.push(data$e.check);
-            queue(tokens, false);
-            break;
-        case 3 /* Upgrade */:
-            tokens.push(data$a.key);
-            queue(tokens);
-            break;
-        case 2 /* Upload */:
-            tokens.push(track.sequence);
-            tokens.push(track.attempts);
-            tokens.push(track.status);
-            queue(tokens, false);
-            break;
-        case 24 /* Custom */:
-            tokens.push(data$i.key);
-            tokens.push(data$i.value);
-            queue(tokens);
-            break;
-        case 34 /* Variable */:
-            var variableKeys = Object.keys(data$h);
-            if (variableKeys.length > 0) {
-                for (var _i = 0, variableKeys_1 = variableKeys; _i < variableKeys_1.length; _i++) {
-                    var v = variableKeys_1[_i];
-                    tokens.push(v);
-                    tokens.push(data$h[v]);
-                }
-                reset$n();
-                queue(tokens, false);
-            }
-            break;
-        case 0 /* Metric */:
-            var metricKeys = Object.keys(updates);
-            if (metricKeys.length > 0) {
-                for (var _a = 0, metricKeys_1 = metricKeys; _a < metricKeys_1.length; _a++) {
-                    var m = metricKeys_1[_a];
-                    var key = parseInt(m, 10);
-                    tokens.push(key);
-                    // For computation, we need microseconds precision that performance.now() API offers
-                    // However, for data over the wire, we round it off to milliseconds precision.
-                    tokens.push(Math.round(updates[m]));
-                }
-                reset$2();
-                queue(tokens, false);
-            }
-            break;
-        case 1 /* Dimension */:
-            var dimensionKeys = Object.keys(updates$3);
-            if (dimensionKeys.length > 0) {
-                for (var _b = 0, dimensionKeys_1 = dimensionKeys; _b < dimensionKeys_1.length; _b++) {
-                    var d = dimensionKeys_1[_b];
-                    var key = parseInt(d, 10);
-                    tokens.push(key);
-                    tokens.push(updates$3[d]);
+    return output;
+}
+function getCookie(key) {
+    if (supported(document, "cookie" /* Cookie */)) {
+        var cookies = document.cookie.split(";" /* Semicolon */);
+        if (cookies) {
+            for (var i = 0; i < cookies.length; i++) {
+                var pair = cookies[i].split("=" /* Equals */);
+                if (pair.length > 1 && pair[0] && pair[0].trim() === key) {
+                    return pair[1];
                 }
-                reset$l();
-                queue(tokens, false);
             }
-            break;
-        case 36 /* Summary */:
-            var eventKeys = Object.keys(data$b);
-            if (eventKeys.length > 0) {
-                for (var _c = 0, eventKeys_1 = eventKeys; _c < eventKeys_1.length; _c++) {
-                    var e = eventKeys_1[_c];
-                    var key = parseInt(e, 10);
-                    tokens.push(key);
-                    tokens.push([].concat.apply([], data$b[e]));
+        }
+    }
+    return null;
+}
+function setCookie(key, value, time) {
+    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported(document, "cookie" /* Cookie */))) {
+        var expiry = new Date();
+        expiry.setDate(expiry.getDate() + time);
+        var expires = expiry ? "expires=" /* Expires */ + expiry.toUTCString() : "" /* Empty */;
+        var cookie = key + "=" + value + ";" /* Semicolon */ + expires + ";path=/" /* Path */;
+        try {
+            // Attempt to get the root domain only once and fall back to writing cookie on the current domain.
+            if (rootDomain === null) {
+                var hostname = location.hostname ? location.hostname.split("." /* Dot */) : [];
+                // Walk backwards on a domain and attempt to set a cookie, until successful
+                for (var i = hostname.length - 1; i >= 0; i--) {
+                    rootDomain = "." + hostname[i] + (rootDomain ? rootDomain : "" /* Empty */);
+                    // We do not wish to attempt writing a cookie on the absolute last part of the domain, e.g. .com or .net.
+                    // So we start attempting after second-last part, e.g. .domain.com (PASS) or .co.uk (FAIL)
+                    if (i < hostname.length - 1) {
+                        // Write the cookie on the current computed top level domain
+                        document.cookie = "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain;
+                        // Once written, check if the cookie exists and its value matches exactly with what we intended to set
+                        // Checking for exact value match helps us eliminate a corner case where the cookie may already be present with a different value
+                        // If the check is successful, no more action is required and we can return from the function since rootDomain cookie is already set
+                        // If the check fails, continue with the for loop until we can successfully set and verify the cookie
+                        if (getCookie(key) === value) {
+                            return;
+                        }
+                    }
                 }
-                reset$j();
-                queue(tokens, false);
+                // Finally, if we were not successful and gone through all the options, play it safe and reset rootDomain to be empty
+                // This forces our code to fall back to always writing cookie to the current domain
+                rootDomain = "" /* Empty */;
             }
-            break;
+        }
+        catch (_a) {
+            rootDomain = "" /* Empty */;
+        }
+        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
     }
 }
 
 var data$1 = null;
-var updates = null;
 function start$8() {
-    data$1 = {};
-    updates = {};
-    count$1(5 /* InvokeCount */);
+    var m = data$2;
+    data$1 = {
+        version: version$1,
+        sequence: 0,
+        start: 0,
+        duration: 0,
+        projectId: m.projectId,
+        userId: m.userId,
+        sessionId: m.sessionId,
+        pageNum: m.pageNum,
+        upload: 0 /* Async */,
+        end: 0 /* False */
+    };
 }
 function stop$7() {
-    data$1 = {};
-    updates = {};
-}
-function count$1(metric, increment) {
-    if (increment === void 0) { increment = 1; }
-    if (!(metric in data$1)) {
-        data$1[metric] = 0;
-    }
-    if (!(metric in updates)) {
-        updates[metric] = 0;
-    }
-    data$1[metric] += increment;
-    updates[metric] += increment;
+    data$1 = null;
 }
-function sum(metric, value) {
-    if (value !== null) {
-        if (!(metric in data$1)) {
-            data$1[metric] = 0;
-        }
-        if (!(metric in updates)) {
-            updates[metric] = 0;
-        }
-        data$1[metric] += value;
-        updates[metric] += value;
-    }
+function envelope(last) {
+    data$1.start = data$1.start + data$1.duration;
+    data$1.duration = time() - data$1.start;
+    data$1.sequence++;
+    data$1.upload = last && "sendBeacon" in navigator ? 1 /* Beacon */ : 0 /* Async */;
+    data$1.end = last ? 1 /* True */ : 0 /* False */;
+    return [
+        data$1.version,
+        data$1.sequence,
+        data$1.start,
+        data$1.duration,
+        data$1.projectId,
+        data$1.userId,
+        data$1.sessionId,
+        data$1.pageNum,
+        data$1.upload,
+        data$1.end
+    ];
+}
+
+var history$1;
+function reset$2() {
+    history$1 = [];
 }
-function max(metric, value) {
-    // Ensure that we do not process null or NaN values
-    if (value !== null && isNaN(value) === false) {
-        if (!(metric in data$1)) {
-            data$1[metric] = 0;
-        }
-        if (value > data$1[metric] || data$1[metric] === 0) {
-            updates[metric] = value;
-            data$1[metric] = value;
+function report(e) {
+    // Do not report the same message twice for the same page
+    if (history$1 && history$1.indexOf(e.message) === -1) {
+        var url = config$1.report;
+        if (url && url.length > 0) {
+            var payload = { v: data$1.version, p: data$1.projectId, u: data$1.userId, s: data$1.sessionId, n: data$1.pageNum };
+            if (e.message) {
+                payload.m = e.message;
+            }
+            if (e.stack) {
+                payload.e = e.stack;
+            }
+            // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
+            // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
+            var xhr = new XMLHttpRequest();
+            xhr.open("POST", url);
+            xhr.send(JSON.stringify(payload));
+            history$1.push(e.message);
         }
     }
-}
-function compute$2() {
-    encode$1(0 /* Metric */);
-}
-function reset$2() {
-    updates = {};
+    return e;
 }
 
 // tslint:disable-next-line: ban-types
 function measure (method) {
     return function () {
         var start = performance.now();
-        method.apply(this, arguments);
+        try {
+            method.apply(this, arguments);
+        }
+        catch (ex) {
+            throw report(ex);
+        }
         var duration = performance.now() - start;
         sum(4 /* TotalCost */, duration);
         if (duration > 30 /* LongTask */) {
@@ -4101,7 +4168,7 @@ function start$7() {
 }
 function check$1() {
     if (count++ > 20 /* CallStackDepth */) {
-        log(4 /* CallStackDepth */, 0 /* Info */);
+        log$1(4 /* CallStackDepth */, 0 /* Info */);
         return false;
     }
     return true;
@@ -4136,16 +4203,16 @@ var status = false;
 function start$6() {
     status = true;
     start$E();
-    reset$i();
+    reset$j();
     reset$1();
-    reset$m();
+    reset$2();
     start$7();
 }
 function stop$5() {
     stop$6();
-    reset$m();
+    reset$2();
     reset$1();
-    reset$i();
+    reset$j();
     stop$B();
     status = false;
 }
@@ -4200,11 +4267,11 @@ function restart() {
 }
 
 function start$5() {
-    start$q();
-    start$p();
+    start$t();
+    start$s();
 }
 function stop$4() {
-    stop$o();
+    stop$r();
 }
 
 var diagnostic = /*#__PURE__*/Object.freeze({
@@ -4215,8 +4282,8 @@ var diagnostic = /*#__PURE__*/Object.freeze({
 
 function start$4() {
     schedule$1(discover, 1 /* High */).then(function () {
-        measure(compute$6)();
-        measure(compute$4)();
+        measure(compute$7)();
+        measure(compute$5)();
     });
 }
 function discover() {
@@ -4227,14 +4294,14 @@ function discover() {
                 case 0:
                     ts = time();
                     timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$t(timer);
+                    start$w(timer);
                     return [4 /*yield*/, traverse(document, timer, 0 /* Discover */)];
                 case 1:
                     _a.sent();
                     return [4 /*yield*/, encode$4(5 /* Discover */, timer, ts)];
                 case 2:
                     _a.sent();
-                    stop$q(timer);
+                    stop$t(timer);
                     return [2 /*return*/];
             }
         });
@@ -4244,18 +4311,18 @@ function discover() {
 function start$3() {
     // The order below is important 
     // and is determined by interdependencies of modules
-    start$s();
-    start$n();
-    start$o();
-    start$b();
-    start$4();
+    start$v();
+    start$q();
     start$r();
+    start$e();
+    start$4();
+    start$u();
 }
 function stop$3() {
-    stop$m();
-    stop$n();
-    stop$a();
     stop$p();
+    stop$q();
+    stop$d();
+    stop$s();
     end();
 }
 
@@ -4340,7 +4407,7 @@ function start$2() {
         }
     }
     else {
-        log(3 /* PerformanceObserver */, 0 /* Info */);
+        log$1(3 /* PerformanceObserver */, 0 /* Info */);
     }
 }
 function observe() {
@@ -4368,7 +4435,7 @@ function observe() {
         }
     }
     catch (_a) {
-        log(3 /* PerformanceObserver */, 1 /* Warning */);
+        log$1(3 /* PerformanceObserver */, 1 /* Warning */);
     }
 }
 function handle(entries) {
@@ -4383,7 +4450,7 @@ function process(entries) {
                 compute(entry);
                 break;
             case "resource" /* Resource */:
-                log$1(4 /* NetworkHosts */, host(entry.name));
+                log(4 /* NetworkHosts */, host(entry.name));
                 break;
             case "longtask" /* LongTask */:
                 count$1(7 /* LongTaskCount */);
@@ -4441,7 +4508,7 @@ function start(config$1) {
     if (check()) {
         config(config$1);
         start$6();
-        start$u();
+        start$x();
         modules.forEach(function (x) { return measure(x.start)(); });
     }
 }
@@ -4467,7 +4534,7 @@ function stop() {
     if (active()) {
         // Stop modules in the reverse order of their initialization
         modules.slice().reverse().forEach(function (x) { return measure(x.stop)(); });
-        stop$r();
+        stop$u();
         stop$5();
     }
 }
@@ -4484,7 +4551,7 @@ var clarity = /*#__PURE__*/Object.freeze({
     identify: identify,
     set: set,
     upgrade: upgrade,
-    metadata: metadata$1
+    metadata: metadata
 });
 
 var helper = { hash: hash, selector: selector, get: get, getNode: getNode, lookup: lookup };