clarity-js 0.6.34 → 0.6.35

package/build/clarity.js

@@ -62,7 +62,6 @@ var metadata$1 = /*#__PURE__*/Object.freeze({
     get data () { return data$2; },
     get callbacks () { return callbacks; },
     get start () { return start$9; },
-    get userAgentData () { return userAgentData; },
     get stop () { return stop$8; },
     get metadata () { return metadata; },
     get id () { return id; },
@@ -89,6 +88,7 @@ var config$1 = {
     regions: [],
     extract: [],
     cookies: [],
+    fraud: [],
     report: null,
     upload: null,
     fallback: null,
@@ -111,11 +111,11 @@ function time(ts) {
     ts = ts ? ts : performance.now();
     return Math.max(Math.round(ts - startTime), 0);
 }
-function stop$C() {
+function stop$B() {
     startTime = 0;
 }
 
-var version$1 = "0.6.34";
+var version$1 = "0.6.35";
 
 // tslint:disable: no-bitwise
 function hash (input) {
@@ -142,9 +142,9 @@ var buffer = null;
 var update$2 = false;
 function start$E() {
     update$2 = false;
-    reset$p();
+    reset$o();
 }
-function reset$p() {
+function reset$o() {
     // Baseline state holds the previous values - if it is updated in the current payload,
     // reset the state to current value after sending the previous state
     if (update$2) {
@@ -206,25 +206,25 @@ function visibility(t, visible) {
     }
     update$2 = true;
 }
-function compute$d() {
+function compute$c() {
     if (update$2) {
         encode$1(4 /* Baseline */);
     }
 }
-function stop$B() {
-    reset$p();
+function stop$A() {
+    reset$o();
 }
 
 var baseline = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get state () { return state$9; },
     start: start$E,
-    reset: reset$p,
+    reset: reset$o,
     track: track$7,
     activity: activity,
     visibility: visibility,
-    compute: compute$d,
-    stop: stop$B
+    compute: compute$c,
+    stop: stop$A
 });
 
 var data$j = null;
@@ -248,20 +248,19 @@ function start$D() {
     updates$3 = {};
     count$1(5 /* InvokeCount */);
 }
-function stop$A() {
+function stop$z() {
     data$i = {};
     updates$3 = {};
 }
-function count$1(metric, increment) {
-    if (increment === void 0) { increment = 1; }
+function count$1(metric) {
     if (!(metric in data$i)) {
         data$i[metric] = 0;
     }
     if (!(metric in updates$3)) {
         updates$3[metric] = 0;
     }
-    data$i[metric] += increment;
-    updates$3[metric] += increment;
+    data$i[metric]++;
+    updates$3[metric]++;
 }
 function sum(metric, value) {
     if (value !== null) {
@@ -287,10 +286,10 @@ function max(metric, value) {
         }
     }
 }
-function compute$c() {
+function compute$b() {
     encode$1(0 /* Metric */);
 }
-function reset$o() {
+function reset$n() {
     updates$3 = {};
 }
 
@@ -309,7 +308,7 @@ function start$C() {
     interval = 60000 /* PingInterval */;
     last = 0;
 }
-function reset$n() {
+function reset$m() {
     if (timeout$6) {
         clearTimeout(timeout$6);
     }
@@ -327,7 +326,7 @@ function ping() {
         suspend();
     }
 }
-function stop$z() {
+function stop$y() {
     clearTimeout(timeout$6);
     last = 0;
     interval = 0;
@@ -337,15 +336,15 @@ var ping$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$h; },
     start: start$C,
-    reset: reset$n,
-    stop: stop$z
+    reset: reset$m,
+    stop: stop$y
 });
 
 var data$g = null;
 function start$B() {
     data$g = {};
 }
-function stop$y() {
+function stop$x() {
     data$g = {};
 }
 function track$6(event, time) {
@@ -365,10 +364,10 @@ function track$6(event, time) {
         }
     }
 }
-function compute$b() {
+function compute$a() {
     encode$1(36 /* Summary */);
 }
-function reset$m() {
+function reset$l() {
     data$g = {};
 }
 
@@ -376,10 +375,10 @@ var summary = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$g; },
     start: start$B,
-    stop: stop$y,
+    stop: stop$x,
     track: track$6,
-    compute: compute$b,
-    reset: reset$m
+    compute: compute$a,
+    reset: reset$l
 });
 
 var data$f = null;
@@ -407,7 +406,7 @@ function upgrade(key) {
         encode$1(3 /* Upgrade */);
     }
 }
-function stop$x() {
+function stop$w() {
     data$f = null;
 }
 
@@ -416,12 +415,12 @@ var upgrade$1 = /*#__PURE__*/Object.freeze({
     get data () { return data$f; },
     start: start$A,
     upgrade: upgrade,
-    stop: stop$x
+    stop: stop$w
 });
 
 var data$e = null;
 function start$z() {
-    reset$l();
+    reset$k();
 }
 function set(variable, value) {
     var values = typeof value === "string" /* String */ ? [value] : value;
@@ -449,14 +448,14 @@ function log$2(variable, value) {
         data$e[variable] = validValues;
     }
 }
-function compute$a() {
+function compute$9() {
     encode$1(34 /* Variable */);
 }
-function reset$l() {
+function reset$k() {
     data$e = {};
 }
-function stop$w() {
-    reset$l();
+function stop$v() {
+    reset$k();
 }
 
 var variable = /*#__PURE__*/Object.freeze({
@@ -465,9 +464,9 @@ var variable = /*#__PURE__*/Object.freeze({
     start: start$z,
     set: set,
     identify: identify,
-    compute: compute$a,
-    reset: reset$l,
-    stop: stop$w
+    compute: compute$9,
+    reset: reset$k,
+    stop: stop$v
 });
 
 /*! *****************************************************************************
@@ -587,20 +586,20 @@ function start$y() {
     start$D();
     modules$1.forEach(function (x) { return measure(x.start)(); });
 }
-function stop$v() {
+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$A();
+    stop$z();
 }
-function compute$9() {
-    compute$a();
-    compute$d();
-    compute$2();
+function compute$8() {
+    compute$9();
     compute$c();
+    compute$2();
     compute$b();
+    compute$a();
     compute$3();
     compute$4();
 }
@@ -650,7 +649,7 @@ function mangleText(value) {
         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 "".concat(prefix).concat(trimmed.length.toString(36)).concat(suffix);
     }
     return value;
 }
@@ -701,12 +700,30 @@ function mutate(array, start, end) {
     }
 }
 
+var history$5 = [];
+var data$d;
+function start$x() {
+    history$5 = [];
+    max(26 /* Automation */, navigator.webdriver ? 1 /* True */ : 0 /* False */);
+}
+function check$4(id, target, input) {
+    // Compute hash for fraud detection. Hash is computed only if input meets the minimum length criteria
+    if (id !== null && input && input.length >= 5 /* WordLength */) {
+        data$d = { id: id, target: target, hash: hash(input) };
+        // Only encode this event if we haven't already reported this hash
+        if (history$5.indexOf(data$d.hash) < 0) {
+            history$5.push(data$d.hash);
+            encode$2(41 /* Fraud */);
+        }
+    }
+}
+
 var TAGS = ["DIV", "TR", "P", "LI", "UL", "A", "BUTTON"];
 function selector (input, beta) {
     if (beta === void 0) { beta = false; }
     var a = input.attributes;
     var prefix = input.prefix ? input.prefix[beta ? 1 /* Beta */ : 0 /* Stable */] : null;
-    var suffix = beta || ((a && !("class" /* Class */ in a)) || TAGS.indexOf(input.tag) >= 0) ? ":nth-of-type(" + input.position + ")" : "" /* Empty */;
+    var suffix = beta || ((a && !("class" /* Class */ in a)) || TAGS.indexOf(input.tag) >= 0) ? ":nth-of-type(".concat(input.position, ")") : "" /* Empty */;
     switch (input.tag) {
         case "STYLE":
         case "TITLE":
@@ -721,9 +738,9 @@ function selector (input, beta) {
             if (prefix === null) {
                 return "" /* Empty */;
             }
-            prefix = prefix + ">";
+            prefix = "".concat(prefix, ">");
             input.tag = input.tag.indexOf("svg:" /* SvgPrefix */) === 0 ? input.tag.substr("svg:" /* SvgPrefix */.length) : input.tag;
-            var selector = "" + prefix + input.tag + suffix;
+            var selector = "".concat(prefix).concat(input.tag).concat(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. There are two exceptions:
@@ -731,19 +748,19 @@ function selector (input, beta) {
                 // (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 ? getDomPrefix(prefix) + "#" + id : selector;
+                selector = classes.length > 0 ? "".concat(prefix).concat(input.tag, ".").concat(classes.join(".")).concat(suffix) : selector;
+                selector = id && hasDigits(id) === false ? "".concat(getDomPrefix(prefix), "#").concat(id) : selector;
             }
             else {
                 // Otherwise, fallback to stable mode, where we include class names as part of the selector
-                selector = classes ? "" + prefix + input.tag + "." + classes.join(".") + suffix : selector;
+                selector = classes ? "".concat(prefix).concat(input.tag, ".").concat(classes.join(".")).concat(suffix) : selector;
             }
             return selector;
     }
 }
 function getDomPrefix(prefix) {
     var shadowDomStart = prefix.lastIndexOf("*S" /* ShadowDomTag */);
-    var iframeDomStart = prefix.lastIndexOf("" + "iframe:" /* IFramePrefix */ + "HTML" /* HTML */);
+    var iframeDomStart = prefix.lastIndexOf("".concat("iframe:" /* IFramePrefix */).concat("HTML" /* HTML */));
     var domStart = Math.max(shadowDomStart, iframeDomStart);
     if (domStart < 0) {
         return "";
@@ -785,7 +802,7 @@ function resume$1() {
         }
     }
 }
-function reset$k() {
+function reset$j() {
     tracker = {};
     queuedTasks = [];
     activeTask = null;
@@ -855,20 +872,20 @@ function state$8(timer) {
     // If this task is no longer being tracked, send stop message to the caller
     return 2 /* Stop */;
 }
-function start$x(timer) {
+function start$w(timer) {
     tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
 }
-function restart$1(timer) {
+function restart$2(timer) {
     var id = key(timer);
     if (tracker && tracker[id]) {
         var c = tracker[id].calls;
         var y = tracker[id].yield;
-        start$x(timer);
+        start$w(timer);
         tracker[id].calls = c + 1;
         tracker[id].yield = y;
     }
 }
-function stop$u(timer) {
+function stop$t(timer) {
     var end = performance.now();
     var id = key(timer);
     var duration = end - tracker[id].start;
@@ -888,12 +905,12 @@ function suspend$1(timer) {
                 case 0:
                     id = key(timer);
                     if (!(id in tracker)) return [3 /*break*/, 2];
-                    stop$u(timer);
+                    stop$t(timer);
                     _a = tracker[id];
                     return [4 /*yield*/, wait()];
                 case 1:
                     _a.yield = (_b.sent()).timeRemaining();
-                    restart$1(timer);
+                    restart$2(timer);
                     _b.label = 2;
                 case 2: 
                 // After we are done with suspending task, ensure that we are still operating in the right context
@@ -904,7 +921,7 @@ function suspend$1(timer) {
     });
 }
 function key(timer) {
-    return timer.id + "." + timer.cost;
+    return "".concat(timer.id, ".").concat(timer.cost);
 }
 function wait() {
     return __awaiter(this, void 0, void 0, function () {
@@ -1000,91 +1017,13 @@ function tokenize (tokens) {
     return output;
 }
 
-var data$d = [];
-var enabled = false;
-var observer$2 = null;
-function start$w() {
-    reset$j();
-    observer$2 = null;
-    enabled = window["ResizeObserver"] ? true : false;
-}
-function compute$8(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$d.push({ id: id, width: w, height: h });
-                }
-            }
-        }
-        // Schedule encode only when we have at least one valid data entry
-        if (data$d.length > 0) {
-            encode$4(37 /* Box */);
-        }
-    });
-}
-function reset$j() {
-    data$d = [];
-}
-function stop$t() {
-    reset$j();
-    if (observer$2) {
-        observer$2.disconnect();
-        observer$2 = null;
-    }
-    enabled = false;
-}
-
 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) {
+        var eventTime, tokens, _a, d, _i, _b, r, values, _c, values_1, value, state, data, active, suspend, privacy, mangle, keys, _d, keys_1, key, box, factor, attr;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
                 case 0:
                     eventTime = ts || time();
                     tokens = [eventTime, type];
@@ -1092,18 +1031,17 @@ function encode$4 (type, timer, ts) {
                     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];
+                        case 5 /* Discover */: return [3 /*break*/, 3];
+                        case 6 /* Mutation */: return [3 /*break*/, 3];
                     }
-                    return [3 /*break*/, 11];
+                    return [3 /*break*/, 10];
                 case 1:
                     d = data$c;
                     tokens.push(d.width);
                     tokens.push(d.height);
                     track$7(type, d.width, d.height);
                     queue(tokens);
-                    return [3 /*break*/, 11];
+                    return [3 /*break*/, 10];
                 case 2:
                     for (_i = 0, _b = state$1; _i < _b.length; _i++) {
                         r = _b[_i];
@@ -1115,39 +1053,28 @@ function encode$4 (type, timer, ts) {
                         queue(tokens);
                     }
                     reset$6();
-                    return [3 /*break*/, 11];
+                    return [3 /*break*/, 10];
                 case 3:
-                    b = data$d;
-                    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$j();
-                    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];
+                        return [3 /*break*/, 10];
                     }
                     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];
+                    if (!(values.length > 0)) return [3 /*break*/, 9];
+                    _c = 0, values_1 = values;
+                    _e.label = 4;
+                case 4:
+                    if (!(_c < values_1.length)) return [3 /*break*/, 8];
+                    value = values_1[_c];
                     state = state$8(timer);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 7];
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 6];
                     return [4 /*yield*/, suspend$1(timer)];
+                case 5:
+                    state = _e.sent();
+                    _e.label = 6;
                 case 6:
-                    state = _f.sent();
-                    _f.label = 7;
-                case 7:
                     if (state === 2 /* Stop */) {
-                        return [3 /*break*/, 9];
+                        return [3 /*break*/, 8];
                     }
                     data = value.data;
                     active = value.metadata.active;
@@ -1155,13 +1082,12 @@ function encode$4 (type, timer, ts) {
                     privacy = value.metadata.privacy;
                     mangle = shouldMangle(value);
                     keys = active ? ["tag", "attributes", "value"] : ["tag"];
-                    compute$8(value.id);
-                    for (_e = 0, keys_1 = keys; _e < keys_1.length; _e++) {
-                        key = keys_1[_e];
+                    for (_d = 0, keys_1 = keys; _d < keys_1.length; _d++) {
+                        key = keys_1[_d];
                         if (data[key]) {
                             switch (key) {
                                 case "tag":
-                                    size = value.metadata.size;
+                                    box = size$1(value);
                                     factor = mangle ? -1 : 1;
                                     tokens.push(value.id * factor);
                                     if (value.parent && active) {
@@ -1171,8 +1097,8 @@ function encode$4 (type, timer, ts) {
                                         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]));
+                                    if (box && box.length === 2) {
+                                        tokens.push("".concat("#" /* Box */).concat(str$1(box[0]), ".").concat(str$1(box[1])));
                                     }
                                     break;
                                 case "attributes":
@@ -1183,23 +1109,24 @@ function encode$4 (type, timer, ts) {
                                     }
                                     break;
                                 case "value":
+                                    check$4(value.metadata.fraud, value.id, data[key]);
                                     tokens.push(scrub(data[key], data.tag, privacy, mangle));
                                     break;
                             }
                         }
                     }
-                    _f.label = 8;
+                    _e.label = 7;
+                case 7:
+                    _c++;
+                    return [3 /*break*/, 4];
                 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*/];
+                    _e.label = 9;
+                case 9: return [3 /*break*/, 10];
+                case 10: return [2 /*return*/];
             }
         });
     });
@@ -1208,11 +1135,20 @@ function shouldMangle(value) {
     var privacy = value.metadata.privacy;
     return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
 }
+function size$1(value) {
+    if (value.metadata.size !== null && value.metadata.size.length === 0) {
+        var img = getNode(value.id);
+        if (img) {
+            return [Math.floor(img.offsetWidth * 100 /* BoxPrecision */), Math.floor(img.offsetHeight * 100 /* BoxPrecision */)];
+        }
+    }
+    return value.metadata.size;
+}
 function str$1(input) {
     return input.toString(36);
 }
 function attribute(key, value, privacy) {
-    return key + "=" + scrub(value, key, privacy);
+    return "".concat(key, "=").concat(scrub(value, key, privacy));
 }
 
 var data$c;
@@ -1316,7 +1252,8 @@ function handler$3(event, root, evt) {
                 context: context(a),
                 text: text(t),
                 link: a ? a.href : null,
-                hash: null
+                hash: null,
+                trust: evt.isTrusted ? 1 /* True */ : 0 /* False */
             }
         });
         schedule$1(encode$3.bind(this, event));
@@ -1415,18 +1352,12 @@ function recompute$6(evt) {
     var input = target(evt);
     var value = get(input);
     if (input && input.type && value) {
-        var v = void 0;
+        var v = input.value;
         switch (input.type) {
             case "radio":
             case "checkbox":
                 v = input.checked ? "true" : "false";
                 break;
-            case "range":
-                v = input.value;
-                break;
-            default:
-                v = scrub(input.value, "input", value.metadata.privacy);
-                break;
         }
         var data = { target: input, value: v };
         // If last entry in the queue is for the same target node as the current one, remove it so we can later swap it with current data.
@@ -2202,7 +2133,7 @@ function process$2() {
             switch (_b.label) {
                 case 0:
                     timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$x(timer);
+                    start$w(timer);
                     _b.label = 1;
                 case 1:
                     if (!(mutations.length > 0)) return [3 /*break*/, 8];
@@ -2257,7 +2188,7 @@ function process$2() {
                     _b.sent();
                     return [3 /*break*/, 1];
                 case 8:
-                    stop$u(timer);
+                    stop$t(timer);
                     return [2 /*return*/];
             }
         });
@@ -2384,10 +2315,6 @@ function generate(target, type) {
 }
 
 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", "card", "account", "cvv", "ccv"];
-var DISALLOWED_MATCH = ["address", "password", "contact"];
 var nodes = [];
 var values = [];
 var updateMap = [];
@@ -2395,10 +2322,13 @@ var hashMap = {};
 var override = [];
 var unmask = [];
 var updatedFragments = {};
+var maskText = [];
+var maskDisable = [];
 // 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)
+var fraudMap = null; // Maps node => FraudId (number)
 function start$i() {
     reset$7();
     parse$1(document, true);
@@ -2414,9 +2344,12 @@ function reset$7() {
     hashMap = {};
     override = [];
     unmask = [];
+    maskText = "password,secret,pass,social,ssn,name,code,dob,cell,mob,contact,hidden,account,cvv,ccv,email,tel,phone,address,addr,card,zip" /* Text */.split("," /* Comma */);
+    maskDisable = "radio,checkbox,range,button,reset,submit" /* Disable */.split("," /* Comma */);
     idMap = new WeakMap();
     iframeMap = new WeakMap();
     privacyMap = new WeakMap();
+    fraudMap = 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)
@@ -2432,8 +2365,9 @@ function parse$1(root, init) {
         // 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) {
-            config$1.regions.forEach(function (x) { return root.querySelectorAll(x[1]).forEach(function (e) { return observe$1(e, "" + x[0]); }); }); // Regions
+            config$1.regions.forEach(function (x) { return root.querySelectorAll(x[1]).forEach(function (e) { return observe$1(e, "".concat(x[0])); }); }); // Regions
             config$1.mask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 3 /* TextImage */); }); }); // Masked Elements
+            config$1.fraud.forEach(function (x) { return root.querySelectorAll(x[1]).forEach(function (e) { return fraudMap.set(e, x[0]); }); }); // Fraud Check
             unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* None */); }); }); // Unmasked Elements
         }
     }
@@ -2457,19 +2391,18 @@ function add(node, parent, data, source) {
     var id = getId(node, true);
     var parentId = parent ? getId(parent) : null;
     var previousId = getPreviousId(node);
-    var privacy = config$1.content ? 1 /* Sensitive */ : 2 /* Text */;
     var parentValue = null;
     var regionId = exists(node) ? id : null;
     var fragmentId = null;
+    var fraudId = fraudMap.has(node) ? fraudMap.get(node) : null;
+    var privacyId = config$1.content ? 1 /* Sensitive */ : 2 /* Text */;
     if (parentId >= 0 && values[parentId]) {
         parentValue = values[parentId];
         parentValue.children.push(id);
         regionId = regionId === null ? parentValue.region : regionId;
         fragmentId = parentValue.fragment;
-        privacy = parentValue.metadata.privacy;
+        fraudId = fraudId === null ? parentValue.metadata.fraud : fraudId;
     }
-    // Check to see if this particular node should be masked or not
-    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$1(node, data.attributes["data-clarity-region" /* RegionData */]);
@@ -2485,11 +2418,12 @@ function add(node, parent, data, source) {
         selector: null,
         hash: null,
         region: regionId,
-        metadata: { active: true, suspend: false, privacy: privacy, position: null, size: null },
+        metadata: { active: true, suspend: false, privacy: privacyId, position: null, fraud: fraudId, size: null },
         fragment: fragmentId,
     };
+    privacy(node, values[id], parentValue);
     updateSelector(values[id]);
-    size(values[id], parentValue);
+    size(values[id]);
     track$4(id, source, values[id].fragment);
 }
 function update$1(node, parent, data, source) {
@@ -2569,75 +2503,61 @@ 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, parent, privacy) {
-    var attributes = data.attributes;
+function privacy(node, value, parent) {
+    var data = value.data;
+    var metadata = value.metadata;
+    var current = metadata.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 _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;
-            }
-        }
-    }
-    // Check for disallowed list of fields (e.g. address, phone, etc.) only if the input node is not already masked
-    if (tag === "INPUT" /* InputTag */) {
-        if (privacy === 0 /* None */) {
-            var field = "" /* Empty */;
-            // Be aggressive in looking up any attribute (id, class, name, etc.) for disallowed names
-            for (var _b = 0, _c = Object.keys(attributes); _b < _c.length; _b++) {
-                var attribute = _c[_b];
-                field += attributes[attribute].toLowerCase();
-            }
-            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;
-                }
-            }
-        }
-        else if (privacy === 1 /* Sensitive */) {
-            // Mask all input fields with an exception of type=submit; since they do not accept user input
-            privacy = attributes && attributes["type" /* Type */] === "submit" /* Submit */ ? 0 /* None */ : 2 /* Text */;
-        }
-    }
-    // Check for disallowed list of types (e.g. password, email, etc.) and set the masked property appropriately
-    if ("type" /* Type */ in attributes && DISALLOWED_TYPES.indexOf(attributes["type" /* Type */]) >= 0) {
-        privacy = 2 /* Text */;
-    }
-    // Following two conditions supersede any of the above. If there are explicit instructions to mask / unmask a field, we honor that.
-    if ("data-clarity-mask" /* MaskData */ in attributes) {
-        privacy = 3 /* TextImage */;
+    switch (true) {
+        case "data-clarity-mask" /* MaskData */ in attributes:
+            metadata.privacy = 3 /* TextImage */;
+            break;
+        case "data-clarity-unmask" /* UnmaskData */ in attributes:
+            metadata.privacy = 0 /* None */;
+            break;
+        case privacyMap.has(node):
+            // If this node was explicitly configured to contain sensitive content, honor that privacy setting
+            metadata.privacy = privacyMap.get(node);
+            break;
+        case fraudMap.has(node):
+            // If this node was explicitly configured to be evaluated for fraud, then also mask content
+            metadata.privacy = 2 /* Text */;
+            break;
+        case tag === "*T" /* TextTag */:
+            // If it's a text node belonging to a STYLE or TITLE tag or one of SCRUB_EXCEPTIONS, then capture content
+            var pTag = parent && parent.data ? parent.data.tag : "" /* Empty */;
+            var pSelector_1 = parent && parent.selector ? parent.selector[0 /* Stable */] : "" /* Empty */;
+            metadata.privacy = pTag === "STYLE" /* StyleTag */ || pTag === "TITLE" /* TitleTag */ || override.some(function (x) { return pSelector_1.indexOf(x) >= 0; }) ? 0 /* None */ : current;
+            break;
+        case "type" /* Type */ in attributes:
+            // If this node has an explicit type assigned to it, go through masking rules to determine right privacy setting
+            metadata.privacy = inspect(attributes["type" /* Type */], metadata);
+            break;
+        case tag === "INPUT" /* InputTag */ && current === 0 /* None */:
+            // If even default privacy setting is to not mask, we still scan through input fields for any sensitive information
+            var field_1 = "" /* Empty */;
+            Object.keys(attributes).forEach(function (x) { return field_1 += attributes[x].toLowerCase(); });
+            metadata.privacy = inspect(field_1, metadata);
+            break;
+        case current === 1 /* Sensitive */ && tag === "INPUT" /* InputTag */:
+            // If it's a button or an input option, make an exception to disable masking
+            metadata.privacy = maskDisable.indexOf(attributes["type" /* Type */]) >= 0 ? 0 /* None */ : current;
+            break;
+        case current === 1 /* Sensitive */:
+            // In a mode where we mask sensitive information by default, look through class names to aggressively mask content
+            metadata.privacy = inspect(attributes["class" /* Class */], metadata);
+            break;
+        default:
+            metadata.privacy = parent ? parent.metadata.privacy : metadata.privacy;
+            break;
     }
-    if ("data-clarity-unmask" /* UnmaskData */ in attributes) {
-        privacy = 0 /* None */;
+}
+function inspect(input, metadata) {
+    if (input && maskText.some(function (x) { return input.indexOf(x) >= 0; })) {
+        return 2 /* Text */;
     }
-    return privacy;
+    return metadata.privacy;
 }
 function diff(a, b, field) {
     if (typeof a[field] === "object" && typeof b[field] === "object") {
@@ -2725,17 +2645,9 @@ function remove(id, source) {
         track$4(id, source);
     }
 }
-function size(value, parent) {
-    var data = value.data;
-    var tag = data.tag;
-    // If this element is a text node, is masked, and longer than configured length, then track box model for the parent element
-    var isLongText = tag === "*T" /* TextTag */ && data.value && data.value.length > 15 /* ResizeObserverThreshold */;
-    var isMasked = value.metadata.privacy === 2 /* Text */ || value.metadata.privacy === 3 /* TextImage */;
-    if (isLongText && isMasked && parent && parent.metadata.size === null) {
-        parent.metadata.size = [];
-    }
+function size(value) {
     // If this element is a image node, and is masked, then track box model for the current element
-    if (data.tag === "IMG" /* ImageTag */ && value.metadata.privacy === 3 /* TextImage */) {
+    if (value.data.tag === "IMG" /* ImageTag */ && value.metadata.privacy === 3 /* TextImage */) {
         value.metadata.size = [];
     }
 }
@@ -2944,18 +2856,23 @@ function link(node) {
     }
     return null;
 }
-function metadata$2(node, event) {
+function metadata$2(node, event, text) {
+    if (text === void 0) { text = null; }
     // 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) {
         var value = get(node);
         if (value !== null) {
+            var metadata_1 = value.metadata;
             output.id = value.id;
             output.hash = value.hash;
-            output.privacy = value.metadata.privacy;
+            output.privacy = metadata_1.privacy;
             if (value.region) {
                 track$3(value.region, event);
             }
+            if (metadata_1.fraud) {
+                check$4(metadata_1.fraud, value.id, text || value.data.value);
+            }
         }
     }
     return output;
@@ -2994,7 +2911,7 @@ function encode$3 (type) {
                 case 9 /* Click */:
                     for (_b = 0, _c = state$7; _b < _c.length; _b++) {
                         entry = _c[_b];
-                        cTarget = metadata$2(entry.data.target, entry.event);
+                        cTarget = metadata$2(entry.data.target, entry.event, entry.data.text);
                         tokens = [entry.time, entry.event];
                         cHash = cTarget.hash.join("." /* Dot */);
                         tokens.push(cTarget.id);
@@ -3008,6 +2925,7 @@ function encode$3 (type) {
                         tokens.push(scrub(entry.data.text, "click", cTarget.privacy));
                         tokens.push(entry.data.link);
                         tokens.push(cHash);
+                        tokens.push(entry.data.trust);
                         queue(tokens);
                         track$2(entry.time, entry.event, cHash, entry.data.x, entry.data.y, entry.data.reaction, entry.data.context);
                     }
@@ -3043,10 +2961,10 @@ function encode$3 (type) {
                 case 27 /* Input */:
                     for (_f = 0, _g = state$5; _f < _g.length; _f++) {
                         entry = _g[_f];
-                        iTarget = metadata$2(entry.data.target, entry.event);
+                        iTarget = metadata$2(entry.data.target, entry.event, entry.data.value);
                         tokens = [entry.time, entry.event];
                         tokens.push(iTarget.id);
-                        tokens.push(entry.data.value);
+                        tokens.push(scrub(entry.data.value, "input", iTarget.privacy));
                         queue(tokens);
                     }
                     reset$f();
@@ -3221,7 +3139,7 @@ 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$n();
+                reset$m();
             }
             timeout = setTimeout(upload, gap);
             queuedTime = now;
@@ -3257,11 +3175,11 @@ function upload(final) {
                     // Otherwise you run a risk of infinite loop.
                     compute$6();
                     compute$5();
-                    compute$9();
+                    compute$8();
                     last = final === true;
                     e = JSON.stringify(envelope(last));
-                    a = "[" + analysis.join() + "]";
-                    p = sendPlaybackBytes ? "[" + playback.join() + "]" : "" /* Empty */;
+                    a = "[".concat(analysis.join(), "]");
+                    p = sendPlaybackBytes ? "[".concat(playback.join(), "]") : "" /* Empty */;
                     encoded = { e: e, a: a, p: p };
                     payload = stringify(encoded);
                     if (!last) return [3 /*break*/, 1];
@@ -3288,7 +3206,7 @@ function upload(final) {
     });
 }
 function stringify(encoded) {
-    return encoded.p.length > 0 ? "{\"e\":" + encoded.e + ",\"a\":" + encoded.a + ",\"p\":" + encoded.p + "}" : "{\"e\":" + encoded.e + ",\"a\":" + encoded.a + "}";
+    return encoded.p.length > 0 ? "{\"e\":".concat(encoded.e, ",\"a\":").concat(encoded.a, ",\"p\":").concat(encoded.p, "}") : "{\"e\":".concat(encoded.e, ",\"a\":").concat(encoded.a, "}");
 }
 function send(payload, zipped, sequence, beacon) {
     if (beacon === void 0) { beacon = false; }
@@ -3449,14 +3367,6 @@ function handler(error) {
             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$t();
-            return false;
-        }
         encode$2(31 /* ScriptError */);
     }
     return true;
@@ -3486,6 +3396,14 @@ function encode$2 (type) {
                         queue(tokens, false);
                     }
                     break;
+                case 41 /* Fraud */:
+                    if (data$d) {
+                        tokens.push(data$d.id);
+                        tokens.push(data$d.target);
+                        tokens.push(data$d.hash);
+                        queue(tokens, false);
+                    }
+                    break;
             }
             return [2 /*return*/];
         });
@@ -3501,7 +3419,7 @@ 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 : "";
+    var key = name ? "".concat(name, "|").concat(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) {
@@ -3676,7 +3594,7 @@ function encode$1 (event) {
                 tokens.push(b.data.activityTime);
                 queue(tokens, false);
             }
-            reset$p();
+            reset$o();
             break;
         case 25 /* Ping */:
             tokens.push(data$h.gap);
@@ -3709,7 +3627,7 @@ function encode$1 (event) {
                     tokens.push(v);
                     tokens.push(data$e[v]);
                 }
-                reset$l();
+                reset$k();
                 queue(tokens, false);
             }
             break;
@@ -3724,7 +3642,7 @@ function encode$1 (event) {
                     // However, for data over the wire, we round it off to milliseconds precision.
                     tokens.push(Math.round(updates$3[m]));
                 }
-                reset$o();
+                reset$n();
                 queue(tokens, false);
             }
             break;
@@ -3750,7 +3668,7 @@ function encode$1 (event) {
                     tokens.push(key);
                     tokens.push([].concat.apply([], data$g[e]));
                 }
-                reset$m();
+                reset$l();
                 queue(tokens, false);
             }
             break;
@@ -3809,7 +3727,7 @@ 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;
+        value = "".concat(value);
         if (!(dimension in data$3)) {
             data$3[dimension] = [];
         }
@@ -3864,7 +3782,6 @@ function start$9() {
     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
@@ -3992,7 +3909,7 @@ function session() {
             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];
+            output.upload = parts.length >= 6 ? "".concat("https://" /* HTTPS */).concat(parts[5], "/").concat(parts[4]) : "".concat("https://" /* HTTPS */).concat(parts[4]);
         }
     }
     return output;
@@ -4017,11 +3934,11 @@ function user() {
         // 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 */;
+            var deleted = "".concat(";" /* Semicolon */).concat("expires=" /* Expires */).concat((new Date(0)).toUTCString()).concat(";path=/" /* Path */);
             // First, delete current user cookie which might be set on current sub-domain vs. root domain
-            document.cookie = "_clck" /* CookieKey */ + "=" + deleted;
+            document.cookie = "".concat("_clck" /* CookieKey */, "=").concat(deleted);
             // Second, same thing for current session cookie so it can be re-written later with the root domain
-            document.cookie = "_clsk" /* SessionKey */ + "=" + deleted;
+            document.cookie = "".concat("_clsk" /* SessionKey */, "=").concat(deleted);
         }
         // End code for backward compatibility
         // Read version information and timestamp from cookie, if available
@@ -4058,19 +3975,19 @@ function setCookie(key, value, time) {
         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 */;
+        var cookie = "".concat(key, "=").concat(value).concat(";" /* Semicolon */).concat(expires).concat(";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 */);
+                    rootDomain = ".".concat(hostname[i]).concat(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;
+                        document.cookie = "".concat(cookie).concat(";" /* Semicolon */).concat("domain=" /* Domain */).concat(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
@@ -4088,7 +4005,7 @@ function setCookie(key, value, time) {
         catch (_a) {
             rootDomain = "" /* Empty */;
         }
-        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
+        document.cookie = rootDomain ? "".concat(cookie).concat(";" /* Semicolon */).concat("domain=" /* Domain */).concat(rootDomain) : cookie;
     }
 }
 
@@ -4243,9 +4160,13 @@ function compute$1() {
     if (url !== getCurrentUrl()) {
         // If the url changed, start tracking it as a new page
         stop();
-        window.setTimeout(start, 250 /* RestartDelay */);
+        window.setTimeout(restart$1, 250 /* RestartDelay */);
     }
 }
+function restart$1() {
+    start();
+    max(29 /* SinglePage */, 1 /* True */);
+}
 function getCurrentUrl() {
     return location.href ? location.href.replace(location.hash, "" /* Empty */) : location.href;
 }
@@ -4258,7 +4179,7 @@ var status = false;
 function start$6() {
     status = true;
     start$F();
-    reset$k();
+    reset$j();
     reset$1();
     reset$2();
     start$7();
@@ -4267,8 +4188,8 @@ function stop$5() {
     stop$6();
     reset$2();
     reset$1();
-    reset$k();
-    stop$C();
+    reset$j();
+    stop$B();
     status = false;
 }
 function active() {
@@ -4322,6 +4243,7 @@ function restart() {
 }
 
 function start$5() {
+    start$x();
     start$e();
     start$d();
 }
@@ -4349,14 +4271,14 @@ function discover() {
                 case 0:
                     ts = time();
                     timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$x(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$u(timer);
+                    stop$t(timer);
                     return [2 /*return*/];
             }
         });
@@ -4371,13 +4293,11 @@ function start$3() {
     start$i();
     start$j();
     start$4();
-    start$w();
 }
 function stop$3() {
     stop$f();
     stop$g();
     stop$h();
-    stop$t();
     end();
 }
 
@@ -4505,7 +4425,11 @@ function process(entries) {
                 compute(entry);
                 break;
             case "resource" /* Resource */:
-                log(4 /* NetworkHosts */, host(entry.name));
+                var name_1 = entry.name;
+                log(4 /* NetworkHosts */, host(name_1));
+                if (name_1 === config$1.upload || name_1 === config$1.fallback) {
+                    max(28 /* UploadTime */, entry.duration);
+                }
                 break;
             case "longtask" /* LongTask */:
                 count$1(7 /* LongTaskCount */);
@@ -4528,6 +4452,11 @@ function process(entries) {
                 break;
         }
     }
+    if (performance && "memory" /* Memory */ in performance && performance["memory" /* Memory */].usedJSHeapSize) {
+        // Track consumed memory (MBs) where "memory" API is available
+        // Reference: https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
+        max(30 /* UsedMemory */, Math.abs(performance["memory" /* Memory */].usedJSHeapSize / 1048576 /* MegaByte */));
+    }
 }
 function stop$2() {
     if (observer) {
@@ -4589,7 +4518,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$v();
+        stop$u();
         stop$5();
     }
 }