clarity-js 0.6.43 → 0.7.1

package/build/clarity.module.js

@@ -80,12 +80,14 @@ var config$1 = {
     lean: false,
     track: true,
     content: true,
+    drop: [],
     mask: [],
     unmask: [],
     regions: [],
     extract: [],
     cookies: [],
-    fraud: [],
+    fraud: true,
+    checksum: [],
     report: null,
     upload: null,
     fallback: null,
@@ -101,22 +103,23 @@ function api(method) {
 }
 
 var startTime = 0;
-function start$F() {
+function start$G() {
     startTime = performance.now();
 }
-function time(ts) {
-    if (ts === void 0) { ts = null; }
-    ts = ts ? ts : performance.now();
+function time(event) {
+    if (event === void 0) { event = null; }
+    var ts = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
     return Math.max(Math.round(ts - startTime), 0);
 }
-function stop$B() {
+function stop$C() {
     startTime = 0;
 }
 
-var version$1 = "0.6.43";
+var version$1 = "0.7.1";
 
 // tslint:disable: no-bitwise
-function hash (input) {
+function hash (input, precision) {
+    if (precision === void 0) { precision = null; }
     // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
     var hash = 0;
     var hashOne = 5381;
@@ -132,21 +135,166 @@ function hash (input) {
     // 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);
+    return (precision ? hash % Math.pow(2, precision) : hash).toString(36);
 }
 
-var state$9 = null;
+var catchallRegex = /\S/gi;
+var unicodeRegex = true;
+var digitRegex = null;
+var letterRegex = null;
+var currencyRegex = null;
+function text$1(value, hint, privacy, mangle) {
+    if (mangle === void 0) { mangle = false; }
+    if (value) {
+        switch (privacy) {
+            case 0 /* Privacy.None */:
+                return value;
+            case 1 /* Privacy.Sensitive */:
+                switch (hint) {
+                    case "*T" /* Layout.Constant.TextTag */:
+                    case "value":
+                    case "placeholder":
+                    case "click":
+                        return redact(value);
+                    case "input":
+                    case "change":
+                        return mangleToken(value);
+                }
+                return value;
+            case 2 /* Privacy.Text */:
+            case 3 /* Privacy.TextImage */:
+                switch (hint) {
+                    case "*T" /* Layout.Constant.TextTag */:
+                        return mangle ? mangleText(value) : mask(value);
+                    case "src":
+                    case "srcset":
+                    case "title":
+                    case "alt":
+                        return privacy === 3 /* Privacy.TextImage */ ? "" /* Data.Constant.Empty */ : value;
+                    case "value":
+                    case "click":
+                    case "input":
+                    case "change":
+                        return mangleToken(value);
+                    case "placeholder":
+                        return mask(value);
+                }
+                break;
+            case 4 /* Privacy.Exclude */:
+                switch (hint) {
+                    case "*T" /* Layout.Constant.TextTag */:
+                        return mangle ? mangleText(value) : mask(value);
+                    case "value":
+                    case "input":
+                    case "click":
+                    case "change":
+                        return Array(5 /* Data.Setting.WordLength */).join("\u2022" /* Data.Constant.Mask */);
+                    case "checksum":
+                        return "" /* Data.Constant.Empty */;
+                }
+        }
+    }
+    return value;
+}
+function url$1(input) {
+    var drop = config$1.drop;
+    if (drop && drop.length > 0 && input && input.indexOf("?") > 0) {
+        var _a = input.split("?"), path = _a[0], query = _a[1];
+        var swap_1 = "*na*" /* Data.Constant.Dropped */;
+        return path + "?" + query.split("&").map(function (p) { return drop.some(function (x) { return p.indexOf("".concat(x, "=")) === 0; }) ? "".concat(p.split("=")[0], "=").concat(swap_1) : p; }).join("&");
+    }
+    return input;
+}
+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 "".concat(prefix).concat(trimmed.length.toString(36)).concat(suffix);
+    }
+    return value;
+}
+function mask(value) {
+    return value.replace(catchallRegex, "\u2022" /* Data.Constant.Mask */);
+}
+function mangleToken(value) {
+    var length = ((Math.floor(value.length / 5 /* Data.Setting.WordLength */) + 1) * 5 /* Data.Setting.WordLength */);
+    var output = "" /* Layout.Constant.Empty */;
+    for (var i = 0; i < length; i++) {
+        output += i > 0 && i % 5 /* Data.Setting.WordLength */ === 0 ? " " /* Data.Constant.Space */ : "\u2022" /* Data.Constant.Mask */;
+    }
+    return output;
+}
+function redact(value) {
+    var spaceIndex = -1;
+    var gap = 0;
+    var hasDigit = false;
+    var hasEmail = false;
+    var hasWhitespace = false;
+    var array = null;
+    // Initialize unicode regex, if supported by the browser
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
+    if (unicodeRegex && digitRegex === null) {
+        try {
+            digitRegex = new RegExp("\\p{N}", "gu");
+            letterRegex = new RegExp("\\p{L}", "gu");
+            currencyRegex = new RegExp("\\p{Sc}", "gu");
+        }
+        catch (_a) {
+            unicodeRegex = false;
+        }
+    }
+    for (var i = 0; i < value.length; i++) {
+        var c = value.charCodeAt(i);
+        hasDigit = hasDigit || (c >= 48 /* Data.Character.Zero */ && c <= 57 /* Data.Character.Nine */); // Check for digits in the current word
+        hasEmail = hasEmail || c === 64 /* Data.Character.At */; // Check for @ sign anywhere within the current word
+        hasWhitespace = c === 9 /* Data.Character.Tab */ || c === 10 /* Data.Character.NewLine */ || c === 13 /* Data.Character.Return */ || c === 32 /* Data.Character.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("" /* Data.Constant.Empty */);
+                }
+                // Work on a token at a time so we don't have to apply regex to a larger string
+                var token = value.substring(spaceIndex + 1, hasWhitespace ? i : i + 1);
+                // Check if unicode regex is supported, otherwise fallback to calling mask function on this token
+                if (unicodeRegex && currencyRegex !== null) {
+                    // Do not redact information if the token contains a currency symbol
+                    token = token.match(currencyRegex) ? token : token.replace(letterRegex, "\u25AA" /* Data.Constant.Letter */).replace(digitRegex, "\u25AB" /* Data.Constant.Digit */);
+                }
+                else {
+                    token = mask(token);
+                }
+                // Merge token back into array at the right place
+                array.splice(spaceIndex + 1 - gap, token.length, token);
+                gap += token.length - 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("" /* Data.Constant.Empty */) : value;
+}
+
+var state$a = null;
 var buffer = null;
 var update$2 = false;
-function start$E() {
+function start$F() {
     update$2 = false;
-    reset$p();
+    reset$q();
 }
-function reset$p() {
+function reset$q() {
     // 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) {
-        state$9 = { time: time(), event: 4 /* Event.Baseline */, data: {
+        state$a = { time: time(), event: 4 /* Event.Baseline */, data: {
                 visible: buffer.visible,
                 docWidth: buffer.docWidth,
                 docHeight: buffer.docHeight,
@@ -209,20 +357,20 @@ function compute$c() {
         encode$1(4 /* Event.Baseline */);
     }
 }
-function stop$A() {
-    reset$p();
+function stop$B() {
+    reset$q();
 }
 
 var baseline = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get state () { return state$9; },
-    start: start$E,
-    reset: reset$p,
+    get state () { return state$a; },
+    start: start$F,
+    reset: reset$q,
     track: track$7,
     activity: activity,
     visibility: visibility,
     compute: compute$c,
-    stop: stop$A
+    stop: stop$B
 });
 
 var data$j = null;
@@ -241,12 +389,12 @@ function event(key, value) {
 
 var data$i = null;
 var updates$3 = null;
-function start$D() {
+function start$E() {
     data$i = {};
     updates$3 = {};
     count$1(5 /* Metric.InvokeCount */);
 }
-function stop$z() {
+function stop$A() {
     data$i = {};
     updates$3 = {};
 }
@@ -287,7 +435,7 @@ function max(metric, value) {
 function compute$b() {
     encode$1(0 /* Event.Metric */);
 }
-function reset$o() {
+function reset$p() {
     updates$3 = {};
 }
 
@@ -302,11 +450,11 @@ var data$h;
 var last = 0;
 var interval = 0;
 var timeout$6 = null;
-function start$C() {
+function start$D() {
     interval = 60000 /* Setting.PingInterval */;
     last = 0;
 }
-function reset$n() {
+function reset$o() {
     if (timeout$6) {
         clearTimeout(timeout$6);
     }
@@ -324,7 +472,7 @@ function ping() {
         suspend();
     }
 }
-function stop$y() {
+function stop$z() {
     clearTimeout(timeout$6);
     last = 0;
     interval = 0;
@@ -333,16 +481,16 @@ function stop$y() {
 var ping$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$h; },
-    start: start$C,
-    reset: reset$n,
-    stop: stop$y
+    start: start$D,
+    reset: reset$o,
+    stop: stop$z
 });
 
 var data$g = null;
-function start$B() {
+function start$C() {
     data$g = {};
 }
-function stop$x() {
+function stop$y() {
     data$g = {};
 }
 function track$6(event, time) {
@@ -365,22 +513,22 @@ function track$6(event, time) {
 function compute$a() {
     encode$1(36 /* Event.Summary */);
 }
-function reset$m() {
+function reset$n() {
     data$g = {};
 }
 
 var summary = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$g; },
-    start: start$B,
-    stop: stop$x,
+    start: start$C,
+    stop: stop$y,
     track: track$6,
     compute: compute$a,
-    reset: reset$m
+    reset: reset$n
 });
 
 var data$f = null;
-function start$A() {
+function start$B() {
     if (!config$1.lean && config$1.upgrade) {
         config$1.upgrade("Config" /* Constant.Config */);
     }
@@ -404,21 +552,21 @@ function upgrade(key) {
         encode$1(3 /* Event.Upgrade */);
     }
 }
-function stop$w() {
+function stop$x() {
     data$f = null;
 }
 
 var upgrade$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$f; },
-    start: start$A,
+    start: start$B,
     upgrade: upgrade,
-    stop: stop$w
+    stop: stop$x
 });
 
 var data$e = null;
-function start$z() {
-    reset$l();
+function start$A() {
+    reset$m();
 }
 function set(variable, value) {
     var values = typeof value === "string" /* Constant.String */ ? [value] : value;
@@ -449,22 +597,22 @@ function log$2(variable, value) {
 function compute$9() {
     encode$1(34 /* Event.Variable */);
 }
-function reset$l() {
+function reset$m() {
     data$e = {};
 }
-function stop$v() {
-    reset$l();
+function stop$w() {
+    reset$m();
 }
 
 var variable = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get data () { return data$e; },
-    start: start$z,
+    start: start$A,
     set: set,
     identify: identify,
     compute: compute$9,
-    reset: reset$l,
-    stop: stop$v
+    reset: reset$m,
+    stop: stop$w
 });
 
 /******************************************************************************
@@ -579,18 +727,18 @@ function read(stream) {
 }
 
 var modules$1 = [baseline, dimension, variable, limit, summary, metadata$1, envelope$1, upload$1, ping$1, upgrade$1, extract];
-function start$y() {
+function start$z() {
     // Metric needs to be initialized before we can start measuring. so metric is not wrapped in measure
-    start$D();
+    start$E();
     modules$1.forEach(function (x) { return measure(x.start)(); });
 }
-function stop$u() {
+function stop$v() {
     // 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();
+    stop$A();
 }
 function compute$8() {
     compute$9();
@@ -602,130 +750,9 @@ function compute$8() {
     compute$4();
 }
 
-var catchallRegex = /\S/gi;
-var unicodeRegex = true;
-var digitRegex = null;
-var letterRegex = null;
-var currencyRegex = null;
-function scrub (value, hint, privacy, mangle) {
-    if (mangle === void 0) { mangle = false; }
-    if (value) {
-        switch (privacy) {
-            case 0 /* Privacy.None */:
-                return value;
-            case 1 /* Privacy.Sensitive */:
-                switch (hint) {
-                    case "*T" /* Layout.Constant.TextTag */:
-                    case "value":
-                    case "placeholder":
-                    case "click":
-                    case "input":
-                        return redact(value);
-                }
-                return value;
-            case 2 /* Privacy.Text */:
-            case 3 /* Privacy.TextImage */:
-                switch (hint) {
-                    case "*T" /* Layout.Constant.TextTag */:
-                        return mangle ? mangleText(value) : mask(value);
-                    case "src":
-                    case "srcset":
-                    case "title":
-                    case "alt":
-                        return privacy === 3 /* Privacy.TextImage */ ? "" /* Data.Constant.Empty */ : value;
-                    case "value":
-                    case "click":
-                    case "input":
-                        return mangleToken(value);
-                    case "placeholder":
-                        return mask(value);
-                }
-                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 "".concat(prefix).concat(trimmed.length.toString(36)).concat(suffix);
-    }
-    return value;
-}
-function mask(value) {
-    return value.replace(catchallRegex, "\u2022" /* Data.Constant.Mask */);
-}
-function mangleToken(value) {
-    var length = ((Math.floor(value.length / 5 /* Data.Setting.WordLength */) + 1) * 5 /* Data.Setting.WordLength */);
-    var output = "" /* Layout.Constant.Empty */;
-    for (var i = 0; i < length; i++) {
-        output += i > 0 && i % 5 /* Data.Setting.WordLength */ === 0 ? " " /* Data.Constant.Space */ : "\u2022" /* Data.Constant.Mask */;
-    }
-    return output;
-}
-function redact(value) {
-    var spaceIndex = -1;
-    var gap = 0;
-    var hasDigit = false;
-    var hasEmail = false;
-    var hasWhitespace = false;
-    var array = null;
-    // Initialize unicode regex, if supported by the browser
-    // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
-    if (unicodeRegex && digitRegex === null) {
-        try {
-            digitRegex = new RegExp("\\p{N}", "gu");
-            letterRegex = new RegExp("\\p{L}", "gu");
-            currencyRegex = new RegExp("\\p{Sc}", "gu");
-        }
-        catch (_a) {
-            unicodeRegex = false;
-        }
-    }
-    for (var i = 0; i < value.length; i++) {
-        var c = value.charCodeAt(i);
-        hasDigit = hasDigit || (c >= 48 /* Data.Character.Zero */ && c <= 57 /* Data.Character.Nine */); // Check for digits in the current word
-        hasEmail = hasEmail || c === 64 /* Data.Character.At */; // Check for @ sign anywhere within the current word
-        hasWhitespace = c === 9 /* Data.Character.Tab */ || c === 10 /* Data.Character.NewLine */ || c === 13 /* Data.Character.Return */ || c === 32 /* Data.Character.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("" /* Data.Constant.Empty */);
-                }
-                // Work on a token at a time so we don't have to apply regex to a larger string
-                var token = value.substring(spaceIndex + 1, hasWhitespace ? i : i + 1);
-                // Check if unicode regex is supported, otherwise fallback to calling mask function on this token
-                if (unicodeRegex && currencyRegex !== null) {
-                    // Do not redact information if the token contains a currency symbol
-                    token = token.match(currencyRegex) ? token : token.replace(letterRegex, "\u25AA" /* Data.Constant.Letter */).replace(digitRegex, "\u25AB" /* Data.Constant.Digit */);
-                }
-                else {
-                    token = mask(token);
-                }
-                // Merge token back into array at the right place
-                array.splice(spaceIndex + 1 - gap, token.length, token);
-                gap += token.length - 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("" /* Data.Constant.Empty */) : value;
-}
-
 var history$5 = [];
 var data$d;
-function start$x() {
+function start$y() {
     history$5 = [];
     max(26 /* Metric.Automation */, navigator.webdriver ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */);
     try {
@@ -736,12 +763,12 @@ function start$x() {
     }
 }
 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 /* Setting.WordLength */) {
-        data$d = { id: id, target: target, hash: hash(input) };
+    // Compute hash for fraud detection, if enabled. Hash is computed only if input meets the minimum length criteria
+    if (config$1.fraud && id !== null && input && input.length >= 5 /* Setting.WordLength */) {
+        data$d = { id: id, target: target, checksum: hash(input, 24 /* Setting.ChecksumPrecision */) };
         // 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);
+        if (history$5.indexOf(data$d.checksum) < 0) {
+            history$5.push(data$d.checksum);
             encode$2(41 /* Event.Fraud */);
         }
     }
@@ -749,7 +776,7 @@ function check$4(id, target, input) {
 
 var excludeClassNames = "load,active,fixed,visible,focus,show,collaps,animat" /* Constant.ExcludeClassNames */.split("," /* Constant.Comma */);
 var selectorMap = {};
-function reset$k() {
+function reset$l() {
     selectorMap = {};
 }
 function get$1(input, type) {
@@ -837,7 +864,7 @@ function filter(value) {
 
 var selector = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    reset: reset$k,
+    reset: reset$l,
     get: get$1
 });
 
@@ -864,7 +891,7 @@ function resume$1() {
         }
     }
 }
-function reset$j() {
+function reset$k() {
     tracker = {};
     queuedTasks = [];
     activeTask = null;
@@ -925,7 +952,7 @@ function run() {
         });
     }
 }
-function state$8(timer) {
+function state$9(timer) {
     var id = key(timer);
     if (id in tracker) {
         var elapsed = performance.now() - tracker[id].start;
@@ -934,7 +961,7 @@ function state$8(timer) {
     // If this task is no longer being tracked, send stop message to the caller
     return 2 /* Task.Stop */;
 }
-function start$w(timer) {
+function start$x(timer) {
     tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* Setting.LongTask */ };
 }
 function restart$2(timer) {
@@ -942,12 +969,12 @@ function restart$2(timer) {
     if (tracker && tracker[id]) {
         var c = tracker[id].calls;
         var y = tracker[id].yield;
-        start$w(timer);
+        start$x(timer);
         tracker[id].calls = c + 1;
         tracker[id].yield = y;
     }
 }
-function stop$t(timer) {
+function stop$u(timer) {
     var end = performance.now();
     var id = key(timer);
     var duration = end - tracker[id].start;
@@ -967,7 +994,7 @@ function suspend$1(timer) {
                 case 0:
                     id = key(timer);
                     if (!(id in tracker)) return [3 /*break*/, 2];
-                    stop$t(timer);
+                    stop$u(timer);
                     _a = tracker[id];
                     return [4 /*yield*/, wait()];
                 case 1:
@@ -1118,7 +1145,7 @@ function encode$4 (type, timer, ts) {
                     return [3 /*break*/, 10];
                 case 3:
                     // Check if we are operating within the context of the current page
-                    if (state$8(timer) === 2 /* Task.Stop */) {
+                    if (state$9(timer) === 2 /* Task.Stop */) {
                         return [3 /*break*/, 10];
                     }
                     values = updates$2();
@@ -1128,7 +1155,7 @@ function encode$4 (type, timer, ts) {
                 case 4:
                     if (!(_c < values_1.length)) return [3 /*break*/, 8];
                     value = values_1[_c];
-                    state = state$8(timer);
+                    state = state$9(timer);
                     if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 6];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 5:
@@ -1172,7 +1199,7 @@ 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));
+                                    tokens.push(text$1(data[key], data.tag, privacy, mangle));
                                     break;
                             }
                         }
@@ -1210,15 +1237,15 @@ function str$1(input) {
     return input.toString(36);
 }
 function attribute(key, value, privacy) {
-    return "".concat(key, "=").concat(scrub(value, key, privacy));
+    return "".concat(key, "=").concat(text$1(value, key, privacy));
 }
 
 var data$c;
-function reset$i() {
+function reset$j() {
     data$c = null;
 }
-function start$v() {
-    reset$i();
+function start$w() {
+    reset$j();
     compute$7();
 }
 function compute$7() {
@@ -1245,6 +1272,29 @@ function compute$7() {
     }
 }
 function end() {
+    reset$j();
+}
+
+var state$8 = [];
+function start$v() {
+    reset$i();
+}
+function observe$c(root) {
+    bind(root, "change", recompute$8, true);
+}
+function recompute$8(evt) {
+    var element = target(evt);
+    if (element) {
+        var value = element.value;
+        var checksum = value && value.length >= 5 /* Setting.WordLength */ && config$1.fraud ? hash(value, 24 /* Setting.ChecksumPrecision */) : "" /* Constant.Empty */;
+        state$8.push({ time: time(evt), event: 42 /* Event.Change */, data: { target: target(evt), type: element.type, value: value, checksum: checksum } });
+        schedule$1(encode$3.bind(this, 42 /* Event.Change */));
+    }
+}
+function reset$i() {
+    state$8 = [];
+}
+function stop$t() {
     reset$i();
 }
 
@@ -1301,7 +1351,7 @@ function handler$3(event, root, evt) {
     // Check for null values before processing this event
     if (x !== null && y !== null) {
         state$7.push({
-            time: time(),
+            time: time(evt),
             event: event,
             data: {
                 target: t,
@@ -1392,7 +1442,7 @@ function observe$a(root) {
     bind(root, "paste", recompute$7.bind(this, 2 /* Clipboard.Paste */), true);
 }
 function recompute$7(action, evt) {
-    state$6.push({ time: time(), event: 38 /* Event.Clipboard */, data: { target: target(evt), action: action } });
+    state$6.push({ time: time(evt), event: 38 /* Event.Clipboard */, data: { target: target(evt), action: action } });
     schedule$1(encode$3.bind(this, 38 /* Event.Clipboard */));
 }
 function reset$g() {
@@ -1426,9 +1476,9 @@ function recompute$6(evt) {
         if (state$5.length > 0 && (state$5[state$5.length - 1].data.target === data.target)) {
             state$5.pop();
         }
-        state$5.push({ time: time(), event: 27 /* Event.Input */, data: data });
+        state$5.push({ time: time(evt), event: 27 /* Event.Input */, data: data });
         clearTimeout(timeout$5);
-        timeout$5 = setTimeout(process$6, 500 /* Setting.LookAhead */, 27 /* Event.Input */);
+        timeout$5 = setTimeout(process$6, 1000 /* Setting.InputLookAhead */, 27 /* Event.Input */);
     }
 }
 function process$6(event) {
@@ -1471,14 +1521,14 @@ function mouse(event, root, evt) {
     }
     // Check for null values before processing this event
     if (x !== null && y !== null) {
-        handler$2({ time: time(), event: event, data: { target: target(evt), x: x, y: y } });
+        handler$2({ time: time(evt), event: event, data: { target: target(evt), x: x, y: y } });
     }
 }
 function touch(event, root, evt) {
     var frame = iframe(root);
     var d = frame ? frame.contentDocument.documentElement : document.documentElement;
     var touches = evt.changedTouches;
-    var t = time();
+    var t = time(evt);
     if (touches) {
         for (var i = 0; i < touches.length; i++) {
             var entry = touches[i];
@@ -1584,7 +1634,7 @@ function recompute$4(event) {
     // And, if for some reason that is not available, fall back to looking up scrollTop on document.documentElement.
     var x = element === de && "pageXOffset" in w ? Math.round(w.pageXOffset) : Math.round(element.scrollLeft);
     var y = element === de && "pageYOffset" in w ? Math.round(w.pageYOffset) : Math.round(element.scrollTop);
-    var current = { time: time(), event: 10 /* Event.Scroll */, data: { target: element, x: x, y: y } };
+    var current = { time: time(event), event: 10 /* Event.Scroll */, data: { target: element, x: x, y: y } };
     // We don't send any scroll events if this is the first event and the current position is top (0,0)
     if ((event === null && x === 0 && y === 0) || (x === null || y === null)) {
         return;
@@ -1674,7 +1724,7 @@ function observe$5(root) {
     bind(root, "submit", recompute$2, true);
 }
 function recompute$2(evt) {
-    state$2.push({ time: time(), event: 39 /* Event.Submit */, data: { target: target(evt) } });
+    state$2.push({ time: time(evt), event: 39 /* Event.Submit */, data: { target: target(evt) } });
     schedule$1(encode$3.bind(this, 39 /* Event.Submit */));
 }
 function reset$a() {
@@ -1690,7 +1740,7 @@ function start$m() {
 }
 function recompute$1(evt) {
     data$9 = { name: evt.type };
-    encode$3(26 /* Event.Unload */);
+    encode$3(26 /* Event.Unload */, time(evt));
     stop();
 }
 function reset$9() {
@@ -1705,9 +1755,10 @@ function start$l() {
     bind(document, "visibilitychange", recompute);
     recompute();
 }
-function recompute() {
+function recompute(evt) {
+    if (evt === void 0) { evt = null; }
     data$8 = { visible: "visibilityState" in document ? document.visibilityState : "default" };
-    encode$3(28 /* Event.Visibility */);
+    encode$3(28 /* Event.Visibility */, time(evt));
 }
 function reset$8() {
     data$8 = null;
@@ -1726,6 +1777,7 @@ function start$k() {
     start$l();
     start$p();
     start$o();
+    start$v();
     start$n();
     start$m();
 }
@@ -1739,6 +1791,7 @@ function stop$i() {
     stop$j();
     stop$n();
     stop$m();
+    stop$t();
     stop$l();
     stop$k();
 }
@@ -1752,6 +1805,7 @@ function observe$4(root) {
         observe$8(root);
         observe$9(root);
         observe$6(root);
+        observe$c(root);
         observe$5(root);
     }
 }
@@ -1832,6 +1886,7 @@ function num$1(input, scale) {
 var IGNORE_ATTRIBUTES = ["title", "alt", "onload", "onfocus", "onerror", "data-drupal-form-submit-last"];
 var newlineRegex = /[\r\n]+/g;
 function processNode (node, source) {
+    var _a;
     var child = null;
     // Do not track this change if we are attempting to remove a node before discovering it
     if (source === 2 /* Source.ChildListRemove */ && has(node) === false) {
@@ -1928,7 +1983,7 @@ function processNode (node, source) {
                         try {
                             ld(JSON.parse(element.text.replace(newlineRegex, "" /* Constant.Empty */)));
                         }
-                        catch ( /* do nothing */_a) { /* do nothing */ }
+                        catch ( /* do nothing */_b) { /* do nothing */ }
                     }
                     break;
                 case "NOSCRIPT":
@@ -1954,11 +2009,20 @@ function processNode (node, source) {
                     break;
                 case "HEAD":
                     var head = { tag: tag, attributes: attributes };
-                    if (location) {
-                        head.attributes["*B" /* Constant.Base */] = location.protocol + "//" + location.hostname;
-                    }
+                    var l = insideFrame && ((_a = node.ownerDocument) === null || _a === void 0 ? void 0 : _a.location) ? node.ownerDocument.location : location;
+                    head.attributes["*B" /* Constant.Base */] = l.protocol + "//" + l.hostname + l.pathname;
                     dom[call](node, parent, head, source);
                     break;
+                case "BASE":
+                    // Override the auto detected base path to explicit value specified in this tag
+                    var baseHead = get(node.parentElement);
+                    if (baseHead) {
+                        // We create "a" element so we can generate protocol and hostname for relative paths like "/path/"
+                        var a = document.createElement("a");
+                        a.href = attributes["href"];
+                        baseHead.data.attributes["*B" /* Constant.Base */] = a.protocol + "//" + a.hostname + a.pathname;
+                    }
+                    break;
                 case "STYLE":
                     var styleData = { tag: tag, attributes: attributes, value: getStyleValue(element) };
                     dom[call](node, parent, styleData, source);
@@ -2058,7 +2122,7 @@ function traverse (root, timer, source) {
                         queue.push(next);
                         next = next.nextSibling;
                     }
-                    state = state$8(timer);
+                    state = state$9(timer);
                     if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 3];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 2:
@@ -2195,7 +2259,7 @@ function process$2() {
             switch (_b.label) {
                 case 0:
                     timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
-                    start$w(timer);
+                    start$x(timer);
                     _b.label = 1;
                 case 1:
                     if (!(mutations.length > 0)) return [3 /*break*/, 8];
@@ -2205,7 +2269,7 @@ function process$2() {
                 case 2:
                     if (!(_i < _a.length)) return [3 /*break*/, 6];
                     mutation = _a[_i];
-                    state = state$8(timer);
+                    state = state$9(timer);
                     if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
@@ -2250,7 +2314,7 @@ function process$2() {
                     _b.sent();
                     return [3 /*break*/, 1];
                 case 8:
-                    stop$t(timer);
+                    stop$u(timer);
                     return [2 /*return*/];
             }
         });
@@ -2312,7 +2376,7 @@ function processNodeList(list, source, timer) {
                     traverse(list[i], timer, source);
                     return [3 /*break*/, 5];
                 case 2:
-                    state = state$8(timer);
+                    state = state$9(timer);
                     if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
@@ -2385,8 +2449,9 @@ var override = [];
 var unmask = [];
 var updatedFragments = {};
 var maskText = [];
-var maskInput = [];
+var maskExclude = [];
 var maskDisable = [];
+var maskTags = [];
 // 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
@@ -2408,13 +2473,14 @@ function reset$7() {
     override = [];
     unmask = [];
     maskText = "address,password,contact" /* Mask.Text */.split("," /* Constant.Comma */);
-    maskInput = "password,secret,pass,social,ssn,name,code,dob,cell,mob,contact,hidden,account,cvv,ccv,email,tel,phone,address,addr,card,zip" /* Mask.Input */.split("," /* Constant.Comma */);
+    maskExclude = "password,secret,pass,social,ssn,code,hidden" /* Mask.Exclude */.split("," /* Constant.Comma */);
     maskDisable = "radio,checkbox,range,button,reset,submit" /* Mask.Disable */.split("," /* Constant.Comma */);
+    maskTags = "INPUT,SELECT,TEXTAREA" /* Mask.Tags */.split("," /* Constant.Comma */);
     idMap = new WeakMap();
     iframeMap = new WeakMap();
     privacyMap = new WeakMap();
     fraudMap = new WeakMap();
-    reset$k();
+    reset$l();
 }
 // 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,7 +2498,7 @@ function parse$1(root, init) {
         if ("querySelectorAll" in root) {
             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 /* Privacy.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
+            config$1.checksum.forEach(function (x) { return root.querySelectorAll(x[1]).forEach(function (e) { return fraudMap.set(e, x[0]); }); }); // Fraud Checksum Check
             unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* Privacy.None */); }); }); // Unmasked Elements
         }
     }
@@ -2576,6 +2642,16 @@ function privacy(node, value, parent) {
     var attributes = data.attributes || {};
     var tag = data.tag.toUpperCase();
     switch (true) {
+        case maskTags.indexOf(tag) >= 0:
+            var type = attributes["type" /* Constant.Type */];
+            var meta_1 = "" /* Constant.Empty */;
+            Object.keys(attributes).forEach(function (x) { return meta_1 += attributes[x].toLowerCase(); });
+            var exclude = maskExclude.some(function (x) { return meta_1.indexOf(x) >= 0; });
+            // Regardless of privacy mode, always mask off user input from input boxes or drop downs with two exceptions:
+            // (1) The node is detected to be one of the excluded fields, in which case we drop everything
+            // (2) The node's type is one of the allowed types (like checkboxes)
+            metadata.privacy = tag === "INPUT" /* Constant.InputTag */ && maskDisable.indexOf(type) >= 0 ? current : (exclude ? 4 /* Privacy.Exclude */ : 2 /* Privacy.Text */);
+            break;
         case "data-clarity-mask" /* Constant.MaskData */ in attributes:
             metadata.privacy = 3 /* Privacy.TextImage */;
             break;
@@ -2597,20 +2673,6 @@ function privacy(node, value, parent) {
             var tags = ["STYLE" /* Constant.StyleTag */, "TITLE" /* Constant.TitleTag */, "svg:style" /* Constant.SvgStyle */];
             metadata.privacy = tags.includes(pTag) || override.some(function (x) { return pSelector_1.indexOf(x) >= 0; }) ? 0 /* Privacy.None */ : current;
             break;
-        case tag === "INPUT" /* Constant.InputTag */ && current === 0 /* Privacy.None */:
-            // If even default privacy setting is to not mask, we still scan through input fields for any sensitive information
-            var field_1 = "" /* Constant.Empty */;
-            Object.keys(attributes).forEach(function (x) { return field_1 += attributes[x].toLowerCase(); });
-            metadata.privacy = inspect(field_1, maskInput, metadata);
-            break;
-        case tag === "INPUT" /* Constant.InputTag */ && current === 1 /* Privacy.Sensitive */:
-            // Look through class names to aggressively mask content
-            metadata.privacy = inspect(attributes["class" /* Constant.Class */], maskText, metadata);
-            // If this node has an explicit type assigned to it, go through masking rules to determine right privacy setting
-            metadata.privacy = inspect(attributes["type" /* Constant.Type */], maskInput, metadata);
-            // If it's a button or an input option, make an exception to disable masking in sensitive mode
-            metadata.privacy = maskDisable.indexOf(attributes["type" /* Constant.Type */]) >= 0 ? 0 /* Privacy.None */ : metadata.privacy;
-            break;
         case current === 1 /* Privacy.Sensitive */:
             // In a mode where we mask sensitive information by default, look through class names to aggressively mask content
             metadata.privacy = inspect(attributes["class" /* Constant.Class */], maskText, metadata);
@@ -2948,11 +3010,12 @@ function metadata$2(node, event, text) {
     return output;
 }
 
-function encode$3 (type) {
+function encode$3 (type, ts) {
+    if (ts === void 0) { ts = null; }
     return __awaiter(this, void 0, void 0, function () {
-        var t, tokens, _i, _a, entry, pTarget, _b, _c, entry, cTarget, cHash, _d, _e, entry, target, r, u, _f, _g, entry, iTarget, s, startTarget, endTarget, _h, _j, entry, sTarget, _k, _l, entry, target, _m, _o, entry, v;
-        return __generator(this, function (_p) {
-            t = time();
+        var t, tokens, _i, _a, entry, pTarget, _b, _c, entry, cTarget, cHash, _d, _e, entry, target, r, u, _f, _g, entry, iTarget, s, startTarget, endTarget, _h, _j, entry, sTarget, _k, _l, entry, target, _m, _o, entry, target, _p, _q, entry, v;
+        return __generator(this, function (_r) {
+            t = ts || time();
             tokens = [t, type];
             switch (type) {
                 case 13 /* Event.MouseDown */:
@@ -2992,8 +3055,8 @@ function encode$3 (type) {
                         tokens.push(entry.data.button);
                         tokens.push(entry.data.reaction);
                         tokens.push(entry.data.context);
-                        tokens.push(scrub(entry.data.text, "click", cTarget.privacy));
-                        tokens.push(entry.data.link);
+                        tokens.push(text$1(entry.data.text, "click", cTarget.privacy));
+                        tokens.push(url$1(entry.data.link));
                         tokens.push(cHash);
                         tokens.push(entry.data.trust);
                         queue(tokens);
@@ -3034,7 +3097,7 @@ function encode$3 (type) {
                         iTarget = metadata$2(entry.data.target, entry.event, entry.data.value);
                         tokens = [entry.time, entry.event];
                         tokens.push(iTarget.id);
-                        tokens.push(scrub(entry.data.value, "input", iTarget.privacy));
+                        tokens.push(text$1(entry.data.value, "input", iTarget.privacy));
                         queue(tokens);
                     }
                     reset$f();
@@ -3067,11 +3130,27 @@ function encode$3 (type) {
                     }
                     reset$c();
                     break;
-                case 39 /* Event.Submit */:
-                    for (_k = 0, _l = state$2; _k < _l.length; _k++) {
+                case 42 /* Event.Change */:
+                    for (_k = 0, _l = state$8; _k < _l.length; _k++) {
                         entry = _l[_k];
                         tokens = [entry.time, entry.event];
                         target = metadata$2(entry.data.target, entry.event);
+                        if (target.id > 0) {
+                            tokens = [entry.time, entry.event];
+                            tokens.push(target.id);
+                            tokens.push(entry.data.type);
+                            tokens.push(text$1(entry.data.value, "change", target.privacy));
+                            tokens.push(text$1(entry.data.checksum, "checksum", target.privacy));
+                            queue(tokens);
+                        }
+                    }
+                    reset$i();
+                    break;
+                case 39 /* Event.Submit */:
+                    for (_m = 0, _o = state$2; _m < _o.length; _m++) {
+                        entry = _o[_m];
+                        tokens = [entry.time, entry.event];
+                        target = metadata$2(entry.data.target, entry.event);
                         if (target.id > 0) {
                             tokens.push(target.id);
                             queue(tokens);
@@ -3080,8 +3159,8 @@ function encode$3 (type) {
                     reset$a();
                     break;
                 case 22 /* Event.Timeline */:
-                    for (_m = 0, _o = updates$1; _m < _o.length; _m++) {
-                        entry = _o[_m];
+                    for (_p = 0, _q = updates$1; _p < _q.length; _p++) {
+                        entry = _q[_p];
                         tokens = [entry.time, entry.event];
                         tokens.push(entry.data.type);
                         tokens.push(entry.data.hash);
@@ -3209,7 +3288,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 /* Event.Ping */) {
-                reset$n();
+                reset$o();
             }
             timeout = setTimeout(upload, gap);
             queuedTime = now;
@@ -3459,7 +3538,7 @@ function encode$2 (type) {
                     tokens.push(data$7.line);
                     tokens.push(data$7.column);
                     tokens.push(data$7.stack);
-                    tokens.push(data$7.source);
+                    tokens.push(url$1(data$7.source));
                     queue(tokens);
                     break;
                 case 33 /* Event.Log */:
@@ -3476,7 +3555,7 @@ function encode$2 (type) {
                     if (data$d) {
                         tokens.push(data$d.id);
                         tokens.push(data$d.target);
-                        tokens.push(data$d.hash);
+                        tokens.push(data$d.checksum);
                         queue(tokens, false);
                     }
                     break;
@@ -3655,7 +3734,7 @@ function encode$1 (event) {
     var tokens = [t, event];
     switch (event) {
         case 4 /* Event.Baseline */:
-            var b = state$9;
+            var b = state$a;
             if (b) {
                 tokens = [b.time, b.event];
                 tokens.push(b.data.visible);
@@ -3670,7 +3749,7 @@ function encode$1 (event) {
                 tokens.push(b.data.activityTime);
                 queue(tokens, false);
             }
-            reset$p();
+            reset$q();
             break;
         case 25 /* Event.Ping */:
             tokens.push(data$h.gap);
@@ -3703,7 +3782,7 @@ function encode$1 (event) {
                     tokens.push(v);
                     tokens.push(data$e[v]);
                 }
-                reset$l();
+                reset$m();
                 queue(tokens, false);
             }
             break;
@@ -3718,7 +3797,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$p();
                 queue(tokens, false);
             }
             break;
@@ -3744,7 +3823,7 @@ function encode$1 (event) {
                     tokens.push(key);
                     tokens.push([].concat.apply([], data$g[e]));
                 }
-                reset$m();
+                reset$n();
                 queue(tokens, false);
             }
             break;
@@ -3839,30 +3918,31 @@ function start$9() {
     // 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
-    };
+    var projectId = config$1.projectId || hash(location.host);
+    data$2 = { projectId: projectId, 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 /* BooleanFlag.False */ : config$1.lean;
     config$1.upload = config$1.track && typeof config$1.upload === "string" /* Constant.String */ && s.upload && s.upload.length > "https://" /* Constant.HTTPS */.length ? s.upload : config$1.upload;
-    // Log dimensions
+    // Log page metadata as dimensions
     log(0 /* Dimension.UserAgent */, ua);
     log(3 /* Dimension.PageTitle */, title);
-    log(1 /* Dimension.Url */, location.href);
+    log(1 /* Dimension.Url */, url$1(location.href));
     log(2 /* Dimension.Referrer */, document.referrer);
     log(15 /* Dimension.TabId */, tab());
     log(16 /* Dimension.PageLanguage */, document.documentElement.lang);
     log(17 /* Dimension.DocumentDirection */, document.dir);
+    log(26 /* Dimension.DevicePixelRatio */, "".concat(window.devicePixelRatio));
+    // Capture additional metadata as metrics
+    max(0 /* Metric.ClientTimestamp */, s.ts);
+    max(1 /* Metric.Playback */, 0 /* BooleanFlag.False */);
+    // Capture navigator specific dimensions
     if (navigator) {
-        log(9 /* Dimension.Language */, navigator.userLanguage || navigator.language);
+        log(9 /* Dimension.Language */, navigator.language);
+        max(33 /* Metric.HardwareConcurrency */, navigator.hardwareConcurrency);
+        max(32 /* Metric.MaxTouchPoints */, navigator.maxTouchPoints);
+        max(34 /* Metric.DeviceMemory */, Math.round(navigator.deviceMemory));
         userAgentData();
     }
-    // Metrics
-    max(0 /* Metric.ClientTimestamp */, s.ts);
-    max(1 /* Metric.Playback */, 0 /* BooleanFlag.False */);
     if (screen) {
         max(14 /* Metric.ScreenWidth */, Math.round(screen.width));
         max(15 /* Metric.ScreenHeight */, Math.round(screen.height));
@@ -3880,22 +3960,20 @@ function start$9() {
     track(u);
 }
 function userAgentData() {
-    if (navigator["userAgentData"] && navigator["userAgentData"].getHighEntropyValues) {
-        navigator["userAgentData"].getHighEntropyValues(["model",
-            "platform",
-            "platformVersion",
-            "uaFullVersion"])
-            .then(function (ua) {
+    var uaData = navigator["userAgentData"];
+    if (uaData && uaData.getHighEntropyValues) {
+        uaData.getHighEntropyValues(["model", "platform", "platformVersion", "uaFullVersion"]).then(function (ua) {
             var _a;
             log(22 /* Dimension.Platform */, ua.platform);
             log(23 /* Dimension.PlatformVersion */, ua.platformVersion);
-            (_a = ua.brands) === null || _a === void 0 ? void 0 : _a.forEach(function (brand) {
-                log(24 /* Dimension.Brand */, brand.name + "~" /* Constant.Tilde */ + brand.version);
-            });
+            (_a = ua.brands) === null || _a === void 0 ? void 0 : _a.forEach(function (brand) { log(24 /* Dimension.Brand */, brand.name + "~" /* Constant.Tilde */ + brand.version); });
             log(25 /* Dimension.Model */, ua.model);
             max(27 /* Metric.Mobile */, ua.mobile ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */);
         });
     }
+    else {
+        log(22 /* Dimension.Platform */, navigator.platform);
+    }
 }
 function stop$8() {
     rootDomain = null;
@@ -4254,8 +4332,8 @@ function stop$6() {
 var status = false;
 function start$6() {
     status = true;
-    start$F();
-    reset$j();
+    start$G();
+    reset$k();
     reset$1();
     reset$2();
     start$7();
@@ -4264,8 +4342,8 @@ function stop$5() {
     stop$6();
     reset$2();
     reset$1();
-    reset$j();
-    stop$B();
+    reset$k();
+    stop$C();
     status = false;
 }
 function active() {
@@ -4319,7 +4397,7 @@ function restart() {
 }
 
 function start$5() {
-    start$x();
+    start$y();
     start$e();
     start$d();
 }
@@ -4347,14 +4425,14 @@ function discover() {
                 case 0:
                     ts = time();
                     timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
-                    start$w(timer);
+                    start$x(timer);
                     return [4 /*yield*/, traverse(document, timer, 0 /* Source.Discover */)];
                 case 1:
                     _a.sent();
                     return [4 /*yield*/, encode$4(5 /* Event.Discover */, timer, ts)];
                 case 2:
                     _a.sent();
-                    stop$t(timer);
+                    stop$u(timer);
                     return [2 /*return*/];
             }
         });
@@ -4364,7 +4442,7 @@ function discover() {
 function start$3() {
     // The order below is important 
     // and is determined by interdependencies of modules
-    start$v();
+    start$w();
     start$h();
     start$i();
     start$j();
@@ -4446,6 +4524,10 @@ function compute(entry) {
 var observer;
 var types = ["navigation" /* Constant.Navigation */, "resource" /* Constant.Resource */, "longtask" /* Constant.LongTask */, "first-input" /* Constant.FID */, "layout-shift" /* Constant.CLS */, "largest-contentful-paint" /* Constant.LCP */];
 function start$2() {
+    // Capture connection properties, if available
+    if (navigator && "connection" in navigator) {
+        log(27 /* Dimension.ConnectionType */, navigator["connection"]["effectiveType"]);
+    }
     // Check the browser support performance observer as a pre-requisite for any performance measurement
     if (window["PerformanceObserver"] && PerformanceObserver.supportedEntryTypes) {
         // Start monitoring performance data after page has finished loading.
@@ -4569,7 +4651,7 @@ function start(config$1) {
     if (check()) {
         config(config$1);
         start$6();
-        start$y();
+        start$z();
         modules.forEach(function (x) { return measure(x.start)(); });
     }
 }
@@ -4595,7 +4677,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$u();
+        stop$v();
         stop$5();
     }
 }