clarity-js 0.6.42 → 0.7.0

package/build/clarity.js

@@ -12,6 +12,7 @@ var dom = /*#__PURE__*/Object.freeze({
     get update () { return update$1; },
     get sameorigin () { return sameorigin; },
     get iframe () { return iframe; },
+    get hashText () { return hashText; },
     get getNode () { return getNode; },
     get getValue () { return getValue; },
     get get () { return get; },
@@ -79,16 +80,18 @@ var envelope$1 = /*#__PURE__*/Object.freeze({
 
 var config$1 = {
     projectId: null,
-    delay: 1 * 1000 /* Second */,
+    delay: 1 * 1000 /* Time.Second */,
     lean: false,
     track: true,
     content: true,
+    drop: [],
     mask: [],
     unmask: [],
     regions: [],
     extract: [],
     cookies: [],
-    fraud: [],
+    fraud: true,
+    checksum: [],
     report: null,
     upload: null,
     fallback: null,
@@ -100,26 +103,27 @@ function api(method) {
     // Zone.js, a popular package for Angular, overrides native browser APIs which can lead to inconsistent state for single page applications.
     // Example issue: https://github.com/angular/angular/issues/31712
     // As a work around, we ensuring Clarity access APIs outside of Zone (and use native implementation instead)
-    return window["Zone" /* Zone */] && "__symbol__" /* Symbol */ in window["Zone" /* Zone */] ? window["Zone" /* Zone */]["__symbol__" /* Symbol */](method) : method;
+    return window["Zone" /* Constant.Zone */] && "__symbol__" /* Constant.Symbol */ in window["Zone" /* Constant.Zone */] ? window["Zone" /* Constant.Zone */]["__symbol__" /* Constant.Symbol */](method) : 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.42";
+var version$1 = "0.7.0";
 
 // 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;
@@ -135,21 +139,164 @@ 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 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 "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$9 = null;
+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 /* Baseline */, data: {
+        state$a = { time: time(), event: 4 /* Event.Baseline */, data: {
                 visible: buffer.visible,
                 docWidth: buffer.docWidth,
                 docHeight: buffer.docHeight,
@@ -164,7 +311,7 @@ function reset$p() {
         };
     }
     buffer = buffer ? buffer : {
-        visible: 1 /* True */,
+        visible: 1 /* BooleanFlag.True */,
         docWidth: 0,
         docHeight: 0,
         screenWidth: 0,
@@ -178,15 +325,15 @@ function reset$p() {
 }
 function track$7(event, x, y) {
     switch (event) {
-        case 8 /* Document */:
+        case 8 /* Event.Document */:
             buffer.docWidth = x;
             buffer.docHeight = y;
             break;
-        case 11 /* Resize */:
+        case 11 /* Event.Resize */:
             buffer.screenWidth = x;
             buffer.screenHeight = y;
             break;
-        case 10 /* Scroll */:
+        case 10 /* Event.Scroll */:
             buffer.scrollX = x;
             buffer.scrollY = y;
             break;
@@ -201,7 +348,7 @@ function activity(t) {
     buffer.activityTime = t;
 }
 function visibility(t, visible) {
-    buffer.visible = visible === "visible" ? 1 /* True */ : 0 /* False */;
+    buffer.visible = visible === "visible" ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */;
     if (!buffer.visible) {
         activity(t);
     }
@@ -209,23 +356,23 @@ function visibility(t, visible) {
 }
 function compute$c() {
     if (update$2) {
-        encode$1(4 /* Baseline */);
+        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;
@@ -233,23 +380,23 @@ function event(key, value) {
     if (active() &&
         key &&
         value &&
-        typeof key === "string" /* String */ &&
-        typeof value === "string" /* String */ &&
+        typeof key === "string" /* Constant.String */ &&
+        typeof value === "string" /* Constant.String */ &&
         key.length < 255 &&
         value.length < 255) {
         data$j = { key: key, value: value };
-        encode$1(24 /* Custom */);
+        encode$1(24 /* Event.Custom */);
     }
 }
 
 var data$i = null;
 var updates$3 = null;
-function start$D() {
+function start$E() {
     data$i = {};
     updates$3 = {};
-    count$1(5 /* InvokeCount */);
+    count$1(5 /* Metric.InvokeCount */);
 }
-function stop$z() {
+function stop$A() {
     data$i = {};
     updates$3 = {};
 }
@@ -288,9 +435,9 @@ function max(metric, value) {
     }
 }
 function compute$b() {
-    encode$1(0 /* Metric */);
+    encode$1(0 /* Event.Metric */);
 }
-function reset$o() {
+function reset$p() {
     updates$3 = {};
 }
 
@@ -305,11 +452,11 @@ var data$h;
 var last = 0;
 var interval = 0;
 var timeout$6 = null;
-function start$C() {
-    interval = 60000 /* PingInterval */;
+function start$D() {
+    interval = 60000 /* Setting.PingInterval */;
     last = 0;
 }
-function reset$n() {
+function reset$o() {
     if (timeout$6) {
         clearTimeout(timeout$6);
     }
@@ -319,15 +466,15 @@ function reset$n() {
 function ping() {
     var now = time();
     data$h = { gap: now - last };
-    encode$1(25 /* Ping */);
-    if (data$h.gap < 300000 /* PingTimeout */) {
+    encode$1(25 /* Event.Ping */);
+    if (data$h.gap < 300000 /* Setting.PingTimeout */) {
         timeout$6 = setTimeout(ping, interval);
     }
     else {
         suspend();
     }
 }
-function stop$y() {
+function stop$z() {
     clearTimeout(timeout$6);
     last = 0;
     interval = 0;
@@ -336,16 +483,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) {
@@ -357,7 +504,7 @@ function track$6(event, time) {
         var last = e[e.length - 1];
         // Add a new entry only if the new event occurs after configured interval
         // Otherwise, extend the duration of the previous entry
-        if (time - last[0] > 100 /* SummaryInterval */) {
+        if (time - last[0] > 100 /* Setting.SummaryInterval */) {
             data$g[event].push([time, 0]);
         }
         else {
@@ -366,26 +513,26 @@ function track$6(event, time) {
     }
 }
 function compute$a() {
-    encode$1(36 /* Summary */);
+    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" /* Config */);
+        config$1.upgrade("Config" /* Constant.Config */);
     }
     data$f = null;
 }
@@ -404,45 +551,45 @@ function upgrade(key) {
         if (config$1.upgrade) {
             config$1.upgrade(key);
         }
-        encode$1(3 /* Upgrade */);
+        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" /* String */ ? [value] : value;
+    var values = typeof value === "string" /* Constant.String */ ? [value] : value;
     log$2(variable, values);
 }
 function identify(userId, sessionId, pageId) {
     if (sessionId === void 0) { sessionId = null; }
     if (pageId === void 0) { pageId = null; }
-    log$2("userId" /* UserId */, [userId]);
-    log$2("sessionId" /* SessionId */, [sessionId]);
-    log$2("pageId" /* PageId */, [pageId]);
+    log$2("userId" /* Constant.UserId */, [userId]);
+    log$2("sessionId" /* Constant.SessionId */, [sessionId]);
+    log$2("pageId" /* Constant.PageId */, [pageId]);
 }
 function log$2(variable, value) {
     if (active() &&
         variable &&
         value &&
-        typeof variable === "string" /* String */ &&
+        typeof variable === "string" /* Constant.String */ &&
         variable.length < 255) {
         var validValues = variable in data$e ? data$e[variable] : [];
         for (var i = 0; i < value.length; i++) {
-            if (typeof value[i] === "string" /* String */ && value[i].length < 255) {
+            if (typeof value[i] === "string" /* Constant.String */ && value[i].length < 255) {
                 validValues.push(value[i]);
             }
         }
@@ -450,27 +597,27 @@ function log$2(variable, value) {
     }
 }
 function compute$9() {
-    encode$1(34 /* Variable */);
+    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
 });
 
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -523,7 +670,7 @@ function __generator(thisArg, body) {
     }
 }
 
-var supported$1 = "CompressionStream" /* CompressionStream */ in window;
+var supported$1 = "CompressionStream" /* Constant.CompressionStream */ in window;
 function compress (input) {
     return __awaiter(this, void 0, void 0, function () {
         var stream, _a;
@@ -540,7 +687,7 @@ function compress (input) {
                                     return [2 /*return*/];
                                 });
                             });
-                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* CompressionStream */]("gzip"));
+                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* Constant.CompressionStream */]("gzip"));
                     _a = Uint8Array.bind;
                     return [4 /*yield*/, read(stream)];
                 case 1: return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _c.sent()]))()];
@@ -582,18 +729,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();
@@ -605,215 +752,100 @@ 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 /* None */:
-                return value;
-            case 1 /* Sensitive */:
-                switch (hint) {
-                    case "*T" /* TextTag */:
-                    case "value":
-                    case "placeholder":
-                    case "click":
-                    case "input":
-                        return redact(value);
-                }
-                return value;
-            case 2 /* Text */:
-            case 3 /* TextImage */:
-                switch (hint) {
-                    case "*T" /* TextTag */:
-                        return mangle ? mangleText(value) : mask(value);
-                    case "src":
-                    case "srcset":
-                    case "title":
-                    case "alt":
-                        return privacy === 3 /* TextImage */ ? "" /* Empty */ : value;
-                    case "value":
-                    case "click":
-                    case "input":
-                        return mangleToken(value);
-                    case "placeholder":
-                        return mask(value);
-                }
-                break;
-        }
-    }
-    return value;
-}
-function mangleText(value) {
-    var trimmed = value.trim();
-    if (trimmed.length > 0) {
-        var first = trimmed[0];
-        var index = value.indexOf(first);
-        var prefix = value.substr(0, index);
-        var suffix = value.substr(index + trimmed.length);
-        return "" + prefix + trimmed.length.toString(36) + suffix;
-    }
-    return value;
-}
-function mask(value) {
-    return value.replace(catchallRegex, "\u2022" /* Mask */);
-}
-function mangleToken(value) {
-    var length = ((Math.floor(value.length / 5 /* WordLength */) + 1) * 5 /* WordLength */);
-    var output = "" /* Empty */;
-    for (var i = 0; i < length; i++) {
-        output += i > 0 && i % 5 /* WordLength */ === 0 ? " " /* Space */ : "\u2022" /* Mask */;
-    }
-    return output;
-}
-function redact(value) {
-    var spaceIndex = -1;
-    var 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 /* Zero */ && c <= 57 /* Nine */); // Check for digits in the current word
-        hasEmail = hasEmail || c === 64 /* At */; // Check for @ sign anywhere within the current word
-        hasWhitespace = c === 9 /* Tab */ || c === 10 /* NewLine */ || c === 13 /* Return */ || c === 32 /* Blank */;
-        // Process each word as an individual token to redact any sensitive information
-        if (i === 0 || i === value.length - 1 || hasWhitespace) {
-            // Performance optimization: Lazy load string -> array conversion only when required
-            if (hasDigit || hasEmail) {
-                if (array === null) {
-                    array = value.split("" /* Empty */);
-                }
-                // 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" /* Letter */).replace(digitRegex, "\u25AB" /* 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("" /* Empty */) : value;
-}
-
 var history$5 = [];
 var data$d;
-function start$x() {
+function start$y() {
     history$5 = [];
-    max(26 /* Automation */, navigator.webdriver ? 1 /* True */ : 0 /* False */);
+    max(26 /* Metric.Automation */, navigator.webdriver ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */);
+    try {
+        max(31 /* Metric.Iframed */, window.top == window.self ? 1 /* IframeStatus.TopFrame */ : 2 /* IframeStatus.Iframe */);
+    }
+    catch (ex) {
+        max(31 /* Metric.Iframed */, 0 /* IframeStatus.Unknown */);
+    }
 }
 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) };
+    // 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);
-            encode$2(41 /* Fraud */);
+        if (history$5.indexOf(data$d.checksum) < 0) {
+            history$5.push(data$d.checksum);
+            encode$2(41 /* Event.Fraud */);
         }
     }
 }
 
-var excludeClassNames = "load,active,fixed,visible,focus,show,collaps,animat" /* ExcludeClassNames */.split("," /* Comma */);
+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) {
     var a = input.attributes;
     var prefix = input.prefix ? input.prefix[type] : null;
-    var suffix = type === 0 /* Alpha */ ? "" + "~" /* Tilde */ + (input.position - 1) : ":nth-of-type(" + input.position + ")";
+    var suffix = type === 0 /* Selector.Alpha */ ? "".concat("~" /* Constant.Tilde */).concat(input.position - 1) : ":nth-of-type(".concat(input.position, ")");
     switch (input.tag) {
         case "STYLE":
         case "TITLE":
         case "LINK":
         case "META":
-        case "*T" /* TextTag */:
-        case "*D" /* DocumentTag */:
-            return "" /* Empty */;
+        case "*T" /* Constant.TextTag */:
+        case "*D" /* Constant.DocumentTag */:
+            return "" /* Constant.Empty */;
         case "HTML":
-            return "HTML" /* HTML */;
+            return "HTML" /* Constant.HTML */;
         default:
             if (prefix === null) {
-                return "" /* Empty */;
+                return "" /* Constant.Empty */;
             }
-            prefix = "" + prefix + ">" /* Separator */;
-            input.tag = input.tag.indexOf("svg:" /* SvgPrefix */) === 0 ? input.tag.substr("svg:" /* SvgPrefix */.length) : input.tag;
-            var selector = "" + prefix + input.tag + suffix;
-            var id = "id" /* Id */ in a && a["id" /* Id */].length > 0 ? a["id" /* Id */] : null;
-            var classes = input.tag !== "BODY" /* BodyTag */ && "class" /* Class */ in a && a["class" /* Class */].length > 0 ? a["class" /* Class */].trim().split(/\s+/).filter(function (c) { return filter(c); }).join("." /* Period */) : null;
+            prefix = "".concat(prefix).concat(">" /* Constant.Separator */);
+            input.tag = input.tag.indexOf("svg:" /* Constant.SvgPrefix */) === 0 ? input.tag.substr("svg:" /* Constant.SvgPrefix */.length) : input.tag;
+            var selector = "".concat(prefix).concat(input.tag).concat(suffix);
+            var id = "id" /* Constant.Id */ in a && a["id" /* Constant.Id */].length > 0 ? a["id" /* Constant.Id */] : null;
+            var classes = input.tag !== "BODY" /* Constant.BodyTag */ && "class" /* Constant.Class */ in a && a["class" /* Constant.Class */].length > 0 ? a["class" /* Constant.Class */].trim().split(/\s+/).filter(function (c) { return filter(c); }).join("." /* Constant.Period */) : null;
             if (classes && classes.length > 0) {
-                if (type === 0 /* Alpha */) {
+                if (type === 0 /* Selector.Alpha */) {
                     // In Alpha mode, update selector to use class names, with relative positioning within the parent id container.
                     // If the node has valid class name(s) then drop relative positioning within the parent path to keep things simple.
-                    var key = "" + getDomPath(prefix) + input.tag + "." /* Dot */ + classes;
+                    var key = "".concat(getDomPath(prefix)).concat(input.tag).concat("." /* Constant.Dot */).concat(classes);
                     if (!(key in selectorMap)) {
                         selectorMap[key] = [];
                     }
                     if (selectorMap[key].indexOf(input.id) < 0) {
                         selectorMap[key].push(input.id);
                     }
-                    selector = "" + key + "~" /* Tilde */ + selectorMap[key].indexOf(input.id);
+                    selector = "".concat(key).concat("~" /* Constant.Tilde */).concat(selectorMap[key].indexOf(input.id));
                 }
                 else {
                     // In Beta mode, we continue to look at query selectors in context of the full page
-                    selector = "" + prefix + input.tag + "." + classes + suffix;
+                    selector = "".concat(prefix).concat(input.tag, ".").concat(classes).concat(suffix);
                 }
             }
             // Update selector to use "id" field when available. There are two exceptions:
             // (1) if "id" appears to be an auto generated string token, e.g. guid or a random id containing digits
             // (2) if "id" appears inside a shadow DOM, in which case we continue to prefix up to shadow DOM to prevent conflicts
-            selector = id && filter(id) ? "" + getDomPrefix(prefix) + "#" /* Hash */ + id : selector;
+            selector = id && filter(id) ? "".concat(getDomPrefix(prefix)).concat("#" /* Constant.Hash */).concat(id) : selector;
             return selector;
     }
 }
 function getDomPrefix(prefix) {
-    var shadowDomStart = prefix.lastIndexOf("*S" /* ShadowDomTag */);
-    var iframeDomStart = prefix.lastIndexOf("" + "iframe:" /* IFramePrefix */ + "HTML" /* HTML */);
+    var shadowDomStart = prefix.lastIndexOf("*S" /* Constant.ShadowDomTag */);
+    var iframeDomStart = prefix.lastIndexOf("".concat("iframe:" /* Constant.IFramePrefix */).concat("HTML" /* Constant.HTML */));
     var domStart = Math.max(shadowDomStart, iframeDomStart);
     if (domStart < 0) {
-        return "" /* Empty */;
+        return "" /* Constant.Empty */;
     }
-    return prefix.substring(0, prefix.indexOf(">" /* Separator */, domStart) + 1);
+    return prefix.substring(0, prefix.indexOf(">" /* Constant.Separator */, domStart) + 1);
 }
 function getDomPath(input) {
-    var parts = input.split(">" /* Separator */);
+    var parts = input.split(">" /* Constant.Separator */);
     for (var i = 0; i < parts.length; i++) {
-        var tIndex = parts[i].indexOf("~" /* Tilde */);
-        var dIndex = parts[i].indexOf("." /* Dot */);
+        var tIndex = parts[i].indexOf("~" /* Constant.Tilde */);
+        var dIndex = parts[i].indexOf("." /* Constant.Dot */);
         parts[i] = parts[i].substring(0, dIndex > 0 ? dIndex : (tIndex > 0 ? tIndex : parts[i].length));
     }
-    return parts.join(">" /* Separator */);
+    return parts.join(">" /* Constant.Separator */);
 }
 // Check if the given input string has digits or excluded class names
 function filter(value) {
@@ -825,7 +857,7 @@ function filter(value) {
     }
     for (var i = 0; i < value.length; i++) {
         var c = value.charCodeAt(i);
-        if (c >= 48 /* Zero */ && c <= 57 /* Nine */) {
+        if (c >= 48 /* Character.Zero */ && c <= 57 /* Character.Nine */) {
             return false;
         }
     }
@@ -834,7 +866,7 @@ function filter(value) {
 
 var selector = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    reset: reset$k,
+    reset: reset$l,
     get: get$1
 });
 
@@ -861,14 +893,14 @@ function resume$1() {
         }
     }
 }
-function reset$j() {
+function reset$k() {
     tracker = {};
     queuedTasks = [];
     activeTask = null;
     pauseTask = null;
 }
 function schedule$1(task, priority) {
-    if (priority === void 0) { priority = 0 /* Normal */; }
+    if (priority === void 0) { priority = 0 /* Priority.Normal */; }
     return __awaiter(this, void 0, void 0, function () {
         var _i, queuedTasks_1, q, promise;
         return __generator(this, function (_a) {
@@ -880,7 +912,7 @@ function schedule$1(task, priority) {
                 }
             }
             promise = new Promise(function (resolve) {
-                var insert = priority === 1 /* High */ ? "unshift" : "push";
+                var insert = priority === 1 /* Priority.High */ ? "unshift" : "push";
                 // Queue this task for asynchronous execution later
                 // We also store a unique page identifier (id) along with the task to ensure
                 // ensure that we do not accidentally execute this task in context of a different page
@@ -915,45 +947,45 @@ function run() {
                 return;
             }
             if (error) {
-                log$1(0 /* RunTask */, 1 /* Warning */, error.name, error.message, error.stack);
+                log$1(0 /* Code.RunTask */, 1 /* Severity.Warning */, error.name, error.message, error.stack);
             }
             activeTask = null;
             run();
         });
     }
 }
-function state$8(timer) {
+function state$9(timer) {
     var id = key(timer);
     if (id in tracker) {
         var elapsed = performance.now() - tracker[id].start;
-        return (elapsed > tracker[id].yield) ? 0 /* Wait */ : 1 /* Run */;
+        return (elapsed > tracker[id].yield) ? 0 /* Task.Wait */ : 1 /* Task.Run */;
     }
     // If this task is no longer being tracked, send stop message to the caller
-    return 2 /* Stop */;
+    return 2 /* Task.Stop */;
 }
-function start$w(timer) {
-    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
+function start$x(timer) {
+    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* Setting.LongTask */ };
 }
 function restart$2(timer) {
     var id = key(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;
     sum(timer.cost, duration);
-    count$1(5 /* InvokeCount */);
+    count$1(5 /* Metric.InvokeCount */);
     // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
     // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
     if (tracker[id].calls > 0) {
-        sum(4 /* TotalCost */, duration);
+        sum(4 /* Metric.TotalCost */, duration);
     }
 }
 function suspend$1(timer) {
@@ -964,7 +996,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:
@@ -974,13 +1006,13 @@ function suspend$1(timer) {
                 case 2: 
                 // After we are done with suspending task, ensure that we are still operating in the right context
                 // If the task is still being tracked, continue running the task, otherwise ask caller to stop execution
-                return [2 /*return*/, id in tracker ? 1 /* Run */ : 2 /* Stop */];
+                return [2 /*return*/, id in tracker ? 1 /* Task.Run */ : 2 /* Task.Stop */];
             }
         });
     });
 }
 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 () {
@@ -1018,14 +1050,14 @@ function requestIdleCallbackPolyfill(callback, options) {
         var currentTime = performance.now();
         var elapsed = currentTime - startTime;
         var duration = currentTime - event.data;
-        if (duration > 30 /* LongTask */ && elapsed < options.timeout) {
+        if (duration > 30 /* Setting.LongTask */ && elapsed < options.timeout) {
             requestAnimationFrame(function () { outgoing.postMessage(currentTime); });
         }
         else {
             var didTimeout_1 = elapsed > options.timeout;
             callback({
                 didTimeout: didTimeout_1,
-                timeRemaining: function () { return didTimeout_1 ? 30 /* LongTask */ : Math.max(0, 30 /* LongTask */ - duration); }
+                timeRemaining: function () { return didTimeout_1 ? 30 /* Setting.LongTask */ : Math.max(0, 30 /* Setting.LongTask */ - duration); }
             });
         }
     };
@@ -1046,7 +1078,7 @@ function tokenize (tokens) {
     var reference = null;
     for (var i = 0; i < tokens.length; i++) {
         // Only optimize for string values
-        if (typeof tokens[i] === "string" /* String */) {
+        if (typeof tokens[i] === "string" /* Constant.String */) {
             var token = tokens[i];
             var index = lookup[token] || -1;
             if (index >= 0) {
@@ -1088,10 +1120,10 @@ function encode$4 (type, timer, ts) {
                     tokens = [eventTime, type];
                     _a = type;
                     switch (_a) {
-                        case 8 /* Document */: return [3 /*break*/, 1];
-                        case 7 /* Region */: return [3 /*break*/, 2];
-                        case 5 /* Discover */: return [3 /*break*/, 3];
-                        case 6 /* Mutation */: return [3 /*break*/, 3];
+                        case 8 /* Event.Document */: return [3 /*break*/, 1];
+                        case 7 /* Event.Region */: return [3 /*break*/, 2];
+                        case 5 /* Event.Discover */: return [3 /*break*/, 3];
+                        case 6 /* Event.Mutation */: return [3 /*break*/, 3];
                     }
                     return [3 /*break*/, 10];
                 case 1:
@@ -1104,7 +1136,7 @@ function encode$4 (type, timer, ts) {
                 case 2:
                     for (_i = 0, _b = state$1; _i < _b.length; _i++) {
                         r = _b[_i];
-                        tokens = [r.time, 7 /* Region */];
+                        tokens = [r.time, 7 /* Event.Region */];
                         tokens.push(r.data.id);
                         tokens.push(r.data.interaction);
                         tokens.push(r.data.visibility);
@@ -1115,7 +1147,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 /* Stop */) {
+                    if (state$9(timer) === 2 /* Task.Stop */) {
                         return [3 /*break*/, 10];
                     }
                     values = updates$2();
@@ -1125,14 +1157,14 @@ 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);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 6];
+                    state = state$9(timer);
+                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 6];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 5:
                     state = _e.sent();
                     _e.label = 6;
                 case 6:
-                    if (state === 2 /* Stop */) {
+                    if (state === 2 /* Task.Stop */) {
                         return [3 /*break*/, 8];
                     }
                     data = value.data;
@@ -1155,9 +1187,9 @@ function encode$4 (type, timer, ts) {
                                     if (value.previous && active) {
                                         tokens.push(value.previous);
                                     }
-                                    tokens.push(suspend ? "*M" /* SuspendMutationTag */ : data[key]);
+                                    tokens.push(suspend ? "*M" /* Constant.SuspendMutationTag */ : data[key]);
                                     if (box && box.length === 2) {
-                                        tokens.push("" + "#" /* Hash */ + str$1(box[0]) + "." + str$1(box[1]));
+                                        tokens.push("".concat("#" /* Constant.Hash */).concat(str$1(box[0]), ".").concat(str$1(box[1])));
                                     }
                                     break;
                                 case "attributes":
@@ -1169,7 +1201,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;
                             }
                         }
@@ -1179,7 +1211,7 @@ function encode$4 (type, timer, ts) {
                     _c++;
                     return [3 /*break*/, 4];
                 case 8:
-                    if (type === 6 /* Mutation */) {
+                    if (type === 6 /* Event.Mutation */) {
                         activity(eventTime);
                     }
                     queue(tokenize(tokens), !config$1.lean);
@@ -1192,13 +1224,13 @@ function encode$4 (type, timer, ts) {
 }
 function shouldMangle(value) {
     var privacy = value.metadata.privacy;
-    return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
+    return value.data.tag === "*T" /* Constant.TextTag */ && !(privacy === 0 /* Privacy.None */ || privacy === 1 /* Privacy.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 [Math.floor(img.offsetWidth * 100 /* Setting.BoxPrecision */), Math.floor(img.offsetHeight * 100 /* Setting.BoxPrecision */)];
         }
     }
     return value.metadata.size;
@@ -1207,15 +1239,15 @@ function str$1(input) {
     return input.toString(36);
 }
 function attribute(key, value, privacy) {
-    return key + "=" + 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() {
@@ -1238,10 +1270,33 @@ function compute$7() {
     // Check that width or height has changed from before, and also that width & height are not null values
     if ((data$c === null || width !== data$c.width || height !== data$c.height) && width !== null && height !== null) {
         data$c = { width: width, height: height };
-        encode$4(8 /* Document */);
+        encode$4(8 /* Event.Document */);
     }
 }
 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();
 }
 
@@ -1267,7 +1322,7 @@ function start$u() {
     reset$h();
 }
 function observe$b(root) {
-    bind(root, "click", handler$3.bind(this, 9 /* Click */, root), true);
+    bind(root, "click", handler$3.bind(this, 9 /* Event.Click */, root), true);
 }
 function handler$3(event, root, evt) {
     var frame = iframe(root);
@@ -1293,13 +1348,14 @@ function handler$3(event, root, evt) {
         x = Math.round(l.x + (l.w / 2));
         y = Math.round(l.y + (l.h / 2));
     }
-    var eX = l ? Math.max(Math.floor(((x - l.x) / l.w) * 32767 /* ClickPrecision */), 0) : 0;
-    var eY = l ? Math.max(Math.floor(((y - l.y) / l.h) * 32767 /* ClickPrecision */), 0) : 0;
+    var eX = l ? Math.max(Math.floor(((x - l.x) / l.w) * 32767 /* Setting.ClickPrecision */), 0) : 0;
+    var eY = l ? Math.max(Math.floor(((y - l.y) / l.h) * 32767 /* Setting.ClickPrecision */), 0) : 0;
     // Check for null values before processing this event
     if (x !== null && y !== null) {
         state$7.push({
-            time: time(),
-            event: event, data: {
+            time: time(evt),
+            event: event,
+            data: {
                 target: t,
                 x: x,
                 y: y,
@@ -1311,7 +1367,7 @@ function handler$3(event, root, evt) {
                 text: text(t),
                 link: a ? a.href : null,
                 hash: null,
-                trust: evt.isTrusted ? 1 /* True */ : 0 /* False */
+                trust: evt.isTrusted ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */
             }
         });
         schedule$1(encode$3.bind(this, event));
@@ -1326,7 +1382,7 @@ function text(element) {
             // Trim any spaces at the beginning or at the end of string
             // Also, replace multiple occurrence of space characters with a single white space
             // Finally, send only first few characters as specified by the Setting
-            output = t.trim().replace(/\s+/g, " " /* Space */).substr(0, 25 /* ClickText */);
+            output = t.trim().replace(/\s+/g, " " /* Constant.Space */).substr(0, 25 /* Setting.ClickText */);
         }
     }
     return output;
@@ -1335,10 +1391,10 @@ function reaction(element) {
     if (element.nodeType === Node.ELEMENT_NODE) {
         var tag = element.tagName.toLowerCase();
         if (UserInputTags.indexOf(tag) >= 0) {
-            return 0 /* False */;
+            return 0 /* BooleanFlag.False */;
         }
     }
-    return 1 /* True */;
+    return 1 /* BooleanFlag.True */;
 }
 function layout$1(element) {
     var box = null;
@@ -1362,14 +1418,14 @@ function layout$1(element) {
     return box;
 }
 function context(a) {
-    if (a && a.hasAttribute("target" /* Target */)) {
-        switch (a.getAttribute("target" /* Target */)) {
-            case "_blank" /* Blank */: return 1 /* Blank */;
-            case "_parent" /* Parent */: return 2 /* Parent */;
-            case "_top" /* Top */: return 3 /* Top */;
+    if (a && a.hasAttribute("target" /* Constant.Target */)) {
+        switch (a.getAttribute("target" /* Constant.Target */)) {
+            case "_blank" /* Constant.Blank */: return 1 /* BrowsingContext.Blank */;
+            case "_parent" /* Constant.Parent */: return 2 /* BrowsingContext.Parent */;
+            case "_top" /* Constant.Top */: return 3 /* BrowsingContext.Top */;
         }
     }
-    return 0 /* Self */;
+    return 0 /* BrowsingContext.Self */;
 }
 function reset$h() {
     state$7 = [];
@@ -1383,13 +1439,13 @@ function start$t() {
     reset$g();
 }
 function observe$a(root) {
-    bind(root, "cut", recompute$7.bind(this, 0 /* Cut */), true);
-    bind(root, "copy", recompute$7.bind(this, 1 /* Copy */), true);
-    bind(root, "paste", recompute$7.bind(this, 2 /* Paste */), true);
+    bind(root, "cut", recompute$7.bind(this, 0 /* Clipboard.Cut */), true);
+    bind(root, "copy", recompute$7.bind(this, 1 /* Clipboard.Copy */), true);
+    bind(root, "paste", recompute$7.bind(this, 2 /* Clipboard.Paste */), true);
 }
 function recompute$7(action, evt) {
-    state$6.push({ time: time(), event: 38 /* Clipboard */, data: { target: target(evt), action: action } });
-    schedule$1(encode$3.bind(this, 38 /* Clipboard */));
+    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() {
     state$6 = [];
@@ -1422,9 +1478,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 /* Input */, data: data });
+        state$5.push({ time: time(evt), event: 27 /* Event.Input */, data: data });
         clearTimeout(timeout$5);
-        timeout$5 = setTimeout(process$6, 500 /* LookAhead */, 27 /* Input */);
+        timeout$5 = setTimeout(process$6, 1000 /* Setting.InputLookAhead */, 27 /* Event.Input */);
     }
 }
 function process$6(event) {
@@ -1444,15 +1500,15 @@ function start$r() {
     reset$e();
 }
 function observe$8(root) {
-    bind(root, "mousedown", mouse.bind(this, 13 /* MouseDown */, root), true);
-    bind(root, "mouseup", mouse.bind(this, 14 /* MouseUp */, root), true);
-    bind(root, "mousemove", mouse.bind(this, 12 /* MouseMove */, root), true);
-    bind(root, "wheel", mouse.bind(this, 15 /* MouseWheel */, root), true);
-    bind(root, "dblclick", mouse.bind(this, 16 /* DoubleClick */, root), true);
-    bind(root, "touchstart", touch.bind(this, 17 /* TouchStart */, root), true);
-    bind(root, "touchend", touch.bind(this, 18 /* TouchEnd */, root), true);
-    bind(root, "touchmove", touch.bind(this, 19 /* TouchMove */, root), true);
-    bind(root, "touchcancel", touch.bind(this, 20 /* TouchCancel */, root), true);
+    bind(root, "mousedown", mouse.bind(this, 13 /* Event.MouseDown */, root), true);
+    bind(root, "mouseup", mouse.bind(this, 14 /* Event.MouseUp */, root), true);
+    bind(root, "mousemove", mouse.bind(this, 12 /* Event.MouseMove */, root), true);
+    bind(root, "wheel", mouse.bind(this, 15 /* Event.MouseWheel */, root), true);
+    bind(root, "dblclick", mouse.bind(this, 16 /* Event.DoubleClick */, root), true);
+    bind(root, "touchstart", touch.bind(this, 17 /* Event.TouchStart */, root), true);
+    bind(root, "touchend", touch.bind(this, 18 /* Event.TouchEnd */, root), true);
+    bind(root, "touchmove", touch.bind(this, 19 /* Event.TouchMove */, root), true);
+    bind(root, "touchcancel", touch.bind(this, 20 /* Event.TouchCancel */, root), true);
 }
 function mouse(event, root, evt) {
     var frame = iframe(root);
@@ -1467,14 +1523,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];
@@ -1491,9 +1547,9 @@ function touch(event, root, evt) {
 }
 function handler$2(current) {
     switch (current.event) {
-        case 12 /* MouseMove */:
-        case 15 /* MouseWheel */:
-        case 19 /* TouchMove */:
+        case 12 /* Event.MouseMove */:
+        case 15 /* Event.MouseWheel */:
+        case 19 /* Event.TouchMove */:
             var length_1 = state$4.length;
             var last = length_1 > 1 ? state$4[length_1 - 2] : null;
             if (last && similar$1(last, current)) {
@@ -1501,7 +1557,7 @@ function handler$2(current) {
             }
             state$4.push(current);
             clearTimeout(timeout$4);
-            timeout$4 = setTimeout(process$5, 500 /* LookAhead */, current.event);
+            timeout$4 = setTimeout(process$5, 500 /* Setting.LookAhead */, current.event);
             break;
         default:
             state$4.push(current);
@@ -1521,7 +1577,7 @@ function similar$1(last, current) {
     var distance = Math.sqrt(dx * dx + dy * dy);
     var gap = current.time - last.time;
     var match = current.data.target === last.data.target;
-    return current.event === last.event && match && distance < 20 /* Distance */ && gap < 25 /* Interval */;
+    return current.event === last.event && match && distance < 20 /* Setting.Distance */ && gap < 25 /* Setting.Interval */;
 }
 function stop$p() {
     clearTimeout(timeout$4);
@@ -1544,7 +1600,7 @@ function recompute$5() {
         width: de && "clientWidth" in de ? Math.min(de.clientWidth, window.innerWidth) : window.innerWidth,
         height: de && "clientHeight" in de ? Math.min(de.clientHeight, window.innerHeight) : window.innerHeight,
     };
-    encode$3(11 /* Resize */);
+    encode$3(11 /* Event.Resize */);
 }
 function reset$d() {
     data$b = null;
@@ -1580,7 +1636,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 /* 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;
@@ -1592,7 +1648,7 @@ function recompute$4(event) {
     }
     state$3.push(current);
     clearTimeout(timeout$3);
-    timeout$3 = setTimeout(process$4, 500 /* LookAhead */, 10 /* Scroll */);
+    timeout$3 = setTimeout(process$4, 500 /* Setting.LookAhead */, 10 /* Event.Scroll */);
 }
 function reset$c() {
     state$3 = [];
@@ -1603,7 +1659,7 @@ function process$4(event) {
 function similar(last, current) {
     var dx = last.data.x - current.data.x;
     var dy = last.data.y - current.data.y;
-    return (dx * dx + dy * dy < 20 /* Distance */ * 20 /* Distance */) && (current.time - last.time < 25 /* Interval */);
+    return (dx * dx + dy * dy < 20 /* Setting.Distance */ * 20 /* Setting.Distance */) && (current.time - last.time < 25 /* Setting.Interval */);
 }
 function stop$n() {
     clearTimeout(timeout$3);
@@ -1638,7 +1694,7 @@ function recompute$3(root) {
     var startNode = data$a.start ? data$a.start : null;
     if (previous !== null && data$a.start !== null && startNode !== current.anchorNode) {
         clearTimeout(timeout$2);
-        process$3(21 /* Selection */);
+        process$3(21 /* Event.Selection */);
     }
     data$a = {
         start: current.anchorNode,
@@ -1648,7 +1704,7 @@ function recompute$3(root) {
     };
     previous = current;
     clearTimeout(timeout$2);
-    timeout$2 = setTimeout(process$3, 500 /* LookAhead */, 21 /* Selection */);
+    timeout$2 = setTimeout(process$3, 500 /* Setting.LookAhead */, 21 /* Event.Selection */);
 }
 function process$3(event) {
     schedule$1(encode$3.bind(this, event));
@@ -1670,8 +1726,8 @@ function observe$5(root) {
     bind(root, "submit", recompute$2, true);
 }
 function recompute$2(evt) {
-    state$2.push({ time: time(), event: 39 /* Submit */, data: { target: target(evt) } });
-    schedule$1(encode$3.bind(this, 39 /* Submit */));
+    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() {
     state$2 = [];
@@ -1686,7 +1742,7 @@ function start$m() {
 }
 function recompute$1(evt) {
     data$9 = { name: evt.type };
-    encode$3(26 /* Unload */);
+    encode$3(26 /* Event.Unload */, time(evt));
     stop();
 }
 function reset$9() {
@@ -1701,9 +1757,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 /* Visibility */);
+    encode$3(28 /* Event.Visibility */, time(evt));
 }
 function reset$8() {
     data$8 = null;
@@ -1722,6 +1779,7 @@ function start$k() {
     start$l();
     start$p();
     start$o();
+    start$v();
     start$n();
     start$m();
 }
@@ -1735,6 +1793,7 @@ function stop$i() {
     stop$j();
     stop$n();
     stop$m();
+    stop$t();
     stop$l();
     stop$k();
 }
@@ -1748,6 +1807,7 @@ function observe$4(root) {
         observe$8(root);
         observe$9(root);
         observe$6(root);
+        observe$c(root);
         observe$5(root);
     }
 }
@@ -1765,51 +1825,51 @@ function ld(json) {
     for (var _i = 0, _a = Object.keys(json); _i < _a.length; _i++) {
         var key = _a[_i];
         var value = json[key];
-        if (key === "@type" /* Type */ && typeof value === "string") {
+        if (key === "@type" /* JsonLD.Type */ && typeof value === "string") {
             value = value.toLowerCase();
             /* Normalizations */
-            value = value.indexOf("article" /* Article */) >= 0 || value.indexOf("posting" /* Posting */) >= 0 ? "article" /* Article */ : value;
+            value = value.indexOf("article" /* JsonLD.Article */) >= 0 || value.indexOf("posting" /* JsonLD.Posting */) >= 0 ? "article" /* JsonLD.Article */ : value;
             switch (value) {
-                case "article" /* Article */:
-                case "recipe" /* Recipe */:
-                    log(5 /* SchemaType */, json[key]);
-                    log(8 /* AuthorName */, json["creator" /* Creator */]);
-                    log(18 /* Headline */, json["headline" /* Headline */]);
+                case "article" /* JsonLD.Article */:
+                case "recipe" /* JsonLD.Recipe */:
+                    log(5 /* Dimension.SchemaType */, json[key]);
+                    log(8 /* Dimension.AuthorName */, json["creator" /* JsonLD.Creator */]);
+                    log(18 /* Dimension.Headline */, json["headline" /* JsonLD.Headline */]);
                     break;
-                case "product" /* Product */:
-                    log(5 /* SchemaType */, json[key]);
-                    log(10 /* ProductName */, json["name" /* Name */]);
-                    log(12 /* ProductSku */, json["sku" /* Sku */]);
-                    if (json["brand" /* Brand */]) {
-                        log(6 /* ProductBrand */, json["brand" /* Brand */]["name" /* Name */]);
+                case "product" /* JsonLD.Product */:
+                    log(5 /* Dimension.SchemaType */, json[key]);
+                    log(10 /* Dimension.ProductName */, json["name" /* JsonLD.Name */]);
+                    log(12 /* Dimension.ProductSku */, json["sku" /* JsonLD.Sku */]);
+                    if (json["brand" /* JsonLD.Brand */]) {
+                        log(6 /* Dimension.ProductBrand */, json["brand" /* JsonLD.Brand */]["name" /* JsonLD.Name */]);
                     }
                     break;
-                case "aggregaterating" /* AggregateRating */:
-                    if (json["ratingValue" /* RatingValue */]) {
-                        max(11 /* RatingValue */, num$1(json["ratingValue" /* RatingValue */], 100 /* RatingScale */));
-                        max(18 /* BestRating */, num$1(json["bestRating" /* BestRating */]));
-                        max(19 /* WorstRating */, num$1(json["worstRating" /* WorstRating */]));
+                case "aggregaterating" /* JsonLD.AggregateRating */:
+                    if (json["ratingValue" /* JsonLD.RatingValue */]) {
+                        max(11 /* Metric.RatingValue */, num$1(json["ratingValue" /* JsonLD.RatingValue */], 100 /* Setting.RatingScale */));
+                        max(18 /* Metric.BestRating */, num$1(json["bestRating" /* JsonLD.BestRating */]));
+                        max(19 /* Metric.WorstRating */, num$1(json["worstRating" /* JsonLD.WorstRating */]));
                     }
-                    max(12 /* RatingCount */, num$1(json["ratingCount" /* RatingCount */]));
-                    max(17 /* ReviewCount */, num$1(json["reviewCount" /* ReviewCount */]));
+                    max(12 /* Metric.RatingCount */, num$1(json["ratingCount" /* JsonLD.RatingCount */]));
+                    max(17 /* Metric.ReviewCount */, num$1(json["reviewCount" /* JsonLD.ReviewCount */]));
                     break;
-                case "person" /* Author */:
-                    log(8 /* AuthorName */, json["name" /* Name */]);
+                case "person" /* JsonLD.Author */:
+                    log(8 /* Dimension.AuthorName */, json["name" /* JsonLD.Name */]);
                     break;
-                case "offer" /* Offer */:
-                    log(7 /* ProductAvailability */, json["availability" /* Availability */]);
-                    log(14 /* ProductCondition */, json["itemCondition" /* ItemCondition */]);
-                    log(13 /* ProductCurrency */, json["priceCurrency" /* PriceCurrency */]);
-                    log(12 /* ProductSku */, json["sku" /* Sku */]);
-                    max(13 /* ProductPrice */, num$1(json["price" /* Price */]));
+                case "offer" /* JsonLD.Offer */:
+                    log(7 /* Dimension.ProductAvailability */, json["availability" /* JsonLD.Availability */]);
+                    log(14 /* Dimension.ProductCondition */, json["itemCondition" /* JsonLD.ItemCondition */]);
+                    log(13 /* Dimension.ProductCurrency */, json["priceCurrency" /* JsonLD.PriceCurrency */]);
+                    log(12 /* Dimension.ProductSku */, json["sku" /* JsonLD.Sku */]);
+                    max(13 /* Metric.ProductPrice */, num$1(json["price" /* JsonLD.Price */]));
                     break;
-                case "brand" /* Brand */:
-                    log(6 /* ProductBrand */, json["name" /* Name */]);
+                case "brand" /* JsonLD.Brand */:
+                    log(6 /* Dimension.ProductBrand */, json["name" /* JsonLD.Name */]);
                     break;
             }
         }
         // Continue parsing nested objects
-        if (value !== null && typeof (value) === "object" /* Object */) {
+        if (value !== null && typeof (value) === "object" /* Constant.Object */) {
             ld(value);
         }
     }
@@ -1818,8 +1878,8 @@ function num$1(input, scale) {
     if (scale === void 0) { scale = 1; }
     if (input !== null) {
         switch (typeof input) {
-            case "number" /* Number */: return Math.round(input * scale);
-            case "string" /* String */: return Math.round(parseFloat(input.replace(digitsRegex, "" /* Empty */)) * scale);
+            case "number" /* Constant.Number */: return Math.round(input * scale);
+            case "string" /* Constant.String */: return Math.round(parseFloat(input.replace(digitsRegex, "" /* Constant.Empty */)) * scale);
         }
     }
     return null;
@@ -1828,13 +1888,14 @@ 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 /* ChildListRemove */ && has(node) === false) {
+    if (source === 2 /* Source.ChildListRemove */ && has(node) === false) {
         return child;
     }
     // Special handling for text nodes that belong to style nodes
-    if (source !== 0 /* Discover */ &&
+    if (source !== 0 /* Source.Discover */ &&
         node.nodeType === Node.TEXT_NODE &&
         node.parentElement &&
         node.parentElement.tagName === "STYLE") {
@@ -1847,10 +1908,10 @@ function processNode (node, source) {
     switch (node.nodeType) {
         case Node.DOCUMENT_TYPE_NODE:
             parent = insideFrame && node.parentNode ? iframe(node.parentNode) : parent;
-            var docTypePrefix = insideFrame ? "iframe:" /* IFramePrefix */ : "" /* Empty */;
+            var docTypePrefix = insideFrame ? "iframe:" /* Constant.IFramePrefix */ : "" /* Constant.Empty */;
             var doctype = node;
             var docAttributes = { name: doctype.name, publicId: doctype.publicId, systemId: doctype.systemId };
-            var docData = { tag: docTypePrefix + "*D" /* DocumentTag */, attributes: docAttributes };
+            var docData = { tag: docTypePrefix + "*D" /* Constant.DocumentTag */, attributes: docAttributes };
             dom[call](node, parent, docData, source);
             break;
         case Node.DOCUMENT_NODE:
@@ -1865,26 +1926,26 @@ function processNode (node, source) {
             if (shadowRoot.host) {
                 parse$1(shadowRoot);
                 var type = typeof (shadowRoot.constructor);
-                if (type === "function" /* Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* NativeCode */) >= 0) {
+                if (type === "function" /* Constant.Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* Constant.NativeCode */) >= 0) {
                     observe$3(shadowRoot);
                     // See: https://wicg.github.io/construct-stylesheets/ for more details on adoptedStyleSheets.
                     // At the moment, we are only able to capture "open" shadow DOM nodes. If they are closed, they are not accessible.
                     // In future we may decide to proxy "attachShadow" call to gain access, but at the moment, we don't want to
                     // cause any unintended side effect to the page. We will re-evaluate after we gather more real world data on this.
-                    var style = "" /* Empty */;
+                    var style = "" /* Constant.Empty */;
                     var adoptedStyleSheets = "adoptedStyleSheets" in shadowRoot ? shadowRoot["adoptedStyleSheets"] : [];
                     for (var _i = 0, adoptedStyleSheets_1 = adoptedStyleSheets; _i < adoptedStyleSheets_1.length; _i++) {
                         var styleSheet = adoptedStyleSheets_1[_i];
                         style += getCssRules(styleSheet);
                     }
-                    var fragementData = { tag: "*S" /* ShadowDomTag */, attributes: { style: style } };
+                    var fragementData = { tag: "*S" /* Constant.ShadowDomTag */, attributes: { style: style } };
                     dom[call](node, shadowRoot.host, fragementData, source);
                 }
                 else {
                     // If the browser doesn't support shadow DOM natively, we detect that, and send appropriate tag back.
                     // The differentiation is important because we don't have to observe pollyfill shadow DOM nodes,
                     // the same way we observe real shadow DOM nodes (encapsulation provided by the browser).
-                    dom[call](node, shadowRoot.host, { tag: "*P" /* PolyfillShadowDomTag */, attributes: {} }, source);
+                    dom[call](node, shadowRoot.host, { tag: "*P" /* Constant.PolyfillShadowDomTag */, attributes: {} }, source);
                 }
             }
             break;
@@ -1897,7 +1958,7 @@ function processNode (node, source) {
             // The only exception is when we receive a mutation to remove the text node, in that case
             // parent will be null, but we can still process the node by checking it's an update call.
             if (call === "update" || (parent && has(parent) && parent.tagName !== "STYLE")) {
-                var textData = { tag: "*T" /* TextTag */, value: node.nodeValue };
+                var textData = { tag: "*T" /* Constant.TextTag */, value: node.nodeValue };
                 dom[call](node, parent, textData, source);
             }
             break;
@@ -1909,52 +1970,61 @@ function processNode (node, source) {
             // For correctness, we first look at parentElement and if it not present then fall back to using parentNode
             parent = node.parentElement ? node.parentElement : (node.parentNode ? node.parentNode : null);
             // If we encounter a node that is part of SVG namespace, prefix the tag with SVG_PREFIX
-            if (element.namespaceURI === "http://www.w3.org/2000/svg" /* SvgNamespace */) {
-                tag = "svg:" /* SvgPrefix */ + tag;
+            if (element.namespaceURI === "http://www.w3.org/2000/svg" /* Constant.SvgNamespace */) {
+                tag = "svg:" /* Constant.SvgPrefix */ + tag;
             }
             switch (tag) {
                 case "HTML":
                     parent = insideFrame && parent ? iframe(parent) : null;
-                    var htmlPrefix = insideFrame ? "iframe:" /* IFramePrefix */ : "" /* Empty */;
+                    var htmlPrefix = insideFrame ? "iframe:" /* Constant.IFramePrefix */ : "" /* Constant.Empty */;
                     var htmlData = { tag: htmlPrefix + tag, attributes: attributes };
                     dom[call](node, parent, htmlData, source);
                     break;
                 case "SCRIPT":
-                    if ("type" /* Type */ in attributes && attributes["type" /* Type */] === "application/ld+json" /* JsonLD */) {
+                    if ("type" /* Constant.Type */ in attributes && attributes["type" /* Constant.Type */] === "application/ld+json" /* Constant.JsonLD */) {
                         try {
-                            ld(JSON.parse(element.text.replace(newlineRegex, "" /* Empty */)));
+                            ld(JSON.parse(element.text.replace(newlineRegex, "" /* Constant.Empty */)));
                         }
-                        catch ( /* do nothing */_a) { /* do nothing */ }
+                        catch ( /* do nothing */_b) { /* do nothing */ }
                     }
                     break;
                 case "NOSCRIPT":
                     break;
                 case "META":
-                    var key = ("property" /* Property */ in attributes ?
-                        "property" /* Property */ :
-                        ("name" /* Name */ in attributes ? "name" /* Name */ : null));
-                    if (key && "content" /* Content */ in attributes) {
-                        var content = attributes["content" /* Content */];
+                    var key = ("property" /* Constant.Property */ in attributes ?
+                        "property" /* Constant.Property */ :
+                        ("name" /* Constant.Name */ in attributes ? "name" /* Constant.Name */ : null));
+                    if (key && "content" /* Constant.Content */ in attributes) {
+                        var content = attributes["content" /* Constant.Content */];
                         switch (attributes[key]) {
-                            case "og:title" /* ogTitle */:
-                                log(20 /* MetaTitle */, content);
+                            case "og:title" /* Constant.ogTitle */:
+                                log(20 /* Dimension.MetaTitle */, content);
                                 break;
-                            case "og:type" /* ogType */:
-                                log(19 /* MetaType */, content);
+                            case "og:type" /* Constant.ogType */:
+                                log(19 /* Dimension.MetaType */, content);
                                 break;
-                            case "generator" /* Generator */:
-                                log(21 /* Generator */, content);
+                            case "generator" /* Constant.Generator */:
+                                log(21 /* Dimension.Generator */, content);
                                 break;
                         }
                     }
                     break;
                 case "HEAD":
                     var head = { tag: tag, attributes: attributes };
-                    if (location) {
-                        head.attributes["*B" /* 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);
@@ -1964,7 +2034,7 @@ function processNode (node, source) {
                     var frameData = { tag: tag, attributes: attributes };
                     if (sameorigin(iframe$1)) {
                         monitor(iframe$1);
-                        frameData.attributes["*O" /* SameOrigin */] = "true";
+                        frameData.attributes["*O" /* Constant.SameOrigin */] = "true";
                         if (iframe$1.contentDocument && iframe$1.contentWindow && iframe$1.contentDocument.readyState !== "loading") {
                             child = iframe$1.contentDocument;
                         }
@@ -1993,7 +2063,7 @@ function observe$3(root) {
 function getStyleValue(style) {
     // Call trim on the text content to ensure we do not process white spaces ( , \n, \r\n, \t, etc.)
     // Also, check if stylesheet has any data-* attribute, if so process rules instead of looking up text
-    var value = style.textContent ? style.textContent.trim() : "" /* Empty */;
+    var value = style.textContent ? style.textContent.trim() : "" /* Constant.Empty */;
     var dataset = style.dataset ? Object.keys(style.dataset).length : 0;
     if (value.length === 0 || dataset > 0) {
         value = getCssRules(style.sheet);
@@ -2001,14 +2071,14 @@ function getStyleValue(style) {
     return value;
 }
 function getCssRules(sheet) {
-    var value = "" /* Empty */;
+    var value = "" /* Constant.Empty */;
     var cssRules = null;
     // Firefox throws a SecurityError when trying to access cssRules of a stylesheet from a different domain
     try {
         cssRules = sheet ? sheet.cssRules : [];
     }
     catch (e) {
-        log$1(1 /* CssRules */, 1 /* Warning */, e ? e.name : null);
+        log$1(1 /* Code.CssRules */, 1 /* Severity.Warning */, e ? e.name : null);
         if (e && e.name !== "SecurityError") {
             throw e;
         }
@@ -2032,8 +2102,8 @@ function getAttributes(element) {
         }
     }
     // For INPUT tags read the dynamic "value" property if an explicit "value" attribute is not set
-    if (element.tagName === "INPUT" /* InputTag */ && !("value" /* Value */ in output) && element.value) {
-        output["value" /* Value */] = element.value;
+    if (element.tagName === "INPUT" /* Constant.InputTag */ && !("value" /* Constant.Value */ in output) && element.value) {
+        output["value" /* Constant.Value */] = element.value;
     }
     return output;
 }
@@ -2054,14 +2124,14 @@ function traverse (root, timer, source) {
                         queue.push(next);
                         next = next.nextSibling;
                     }
-                    state = state$8(timer);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 3];
+                    state = state$9(timer);
+                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 3];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 2:
                     state = _a.sent();
                     _a.label = 3;
                 case 3:
-                    if (state === 2 /* Stop */) {
+                    if (state === 2 /* Task.Stop */) {
                         return [3 /*break*/, 4];
                     }
                     subnode = processNode(node, source);
@@ -2138,7 +2208,7 @@ function observe$2(node) {
     // For this reason, we need to wire up mutations every time we see a new shadow dom.
     // Also, wrap it inside a try / catch. In certain browsers (e.g. legacy Edge), observer on shadow dom can throw errors
     try {
-        var m = api("MutationObserver" /* MutationObserver */);
+        var m = api("MutationObserver" /* Constant.MutationObserver */);
         var observer = m in window ? new window[m](measure(handle$1)) : null;
         if (observer) {
             observer.observe(node, { attributes: true, childList: true, characterData: true, subtree: true });
@@ -2146,7 +2216,7 @@ function observe$2(node) {
         }
     }
     catch (e) {
-        log$1(2 /* MutationObserver */, 0 /* Info */, e ? e.name : null);
+        log$1(2 /* Code.MutationObserver */, 0 /* Severity.Info */, e ? e.name : null);
     }
 }
 function monitor(frame) {
@@ -2154,7 +2224,7 @@ function monitor(frame) {
     // This includes cases where iframe location is updated without explicitly updating src attribute
     // E.g. iframe.contentWindow.location.href = "new-location";
     if (has(frame) === false) {
-        bind(frame, "load" /* LoadEvent */, generate.bind(this, frame, "childList" /* ChildList */), true);
+        bind(frame, "load" /* Constant.LoadEvent */, generate.bind(this, frame, "childList" /* Constant.ChildList */), true);
     }
 }
 function stop$h() {
@@ -2172,14 +2242,14 @@ function stop$h() {
     timeout$1 = null;
 }
 function active$2() {
-    activePeriod = time() + 3000 /* MutationActivePeriod */;
+    activePeriod = time() + 3000 /* Setting.MutationActivePeriod */;
 }
 function handle$1(m) {
     // Queue up mutation records for asynchronous processing
     var now = time();
-    track$6(6 /* Mutation */, now);
+    track$6(6 /* Event.Mutation */, now);
     mutations.push({ time: now, mutations: m });
-    schedule$1(process$2, 1 /* High */).then(function () {
+    schedule$1(process$2, 1 /* Priority.High */).then(function () {
         setTimeout(compute$7);
         measure(compute$6)();
     });
@@ -2190,8 +2260,8 @@ function process$2() {
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$w(timer);
+                    timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
+                    start$x(timer);
                     _b.label = 1;
                 case 1:
                     if (!(mutations.length > 0)) return [3 /*break*/, 8];
@@ -2201,14 +2271,14 @@ function process$2() {
                 case 2:
                     if (!(_i < _a.length)) return [3 /*break*/, 6];
                     mutation = _a[_i];
-                    state = state$8(timer);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 4];
+                    state = state$9(timer);
+                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
                     state = _b.sent();
                     _b.label = 4;
                 case 4:
-                    if (state === 2 /* Stop */) {
+                    if (state === 2 /* Task.Stop */) {
                         return [3 /*break*/, 6];
                     }
                     target = mutation.target;
@@ -2220,17 +2290,17 @@ function process$2() {
                         parse$1(target);
                     }
                     switch (type) {
-                        case "attributes" /* Attributes */:
-                            processNode(target, 3 /* Attributes */);
+                        case "attributes" /* Constant.Attributes */:
+                            processNode(target, 3 /* Source.Attributes */);
                             break;
-                        case "characterData" /* CharacterData */:
-                            processNode(target, 4 /* CharacterData */);
+                        case "characterData" /* Constant.CharacterData */:
+                            processNode(target, 4 /* Source.CharacterData */);
                             break;
-                        case "childList" /* ChildList */:
-                            processNodeList(mutation.addedNodes, 1 /* ChildListAdd */, timer);
-                            processNodeList(mutation.removedNodes, 2 /* ChildListRemove */, timer);
+                        case "childList" /* Constant.ChildList */:
+                            processNodeList(mutation.addedNodes, 1 /* Source.ChildListAdd */, timer);
+                            processNodeList(mutation.removedNodes, 2 /* Source.ChildListRemove */, timer);
                             break;
-                        case "suspend" /* Suspend */:
+                        case "suspend" /* Constant.Suspend */:
                             value = get(target);
                             if (value) {
                                 value.metadata.suspend = true;
@@ -2241,12 +2311,12 @@ function process$2() {
                 case 5:
                     _i++;
                     return [3 /*break*/, 2];
-                case 6: return [4 /*yield*/, encode$4(6 /* Mutation */, timer, record.time)];
+                case 6: return [4 /*yield*/, encode$4(6 /* Event.Mutation */, timer, record.time)];
                 case 7:
                     _b.sent();
                     return [3 /*break*/, 1];
                 case 8:
-                    stop$t(timer);
+                    stop$u(timer);
                     return [2 /*return*/];
             }
         });
@@ -2255,11 +2325,11 @@ function process$2() {
 function track$5(m, timer) {
     var value = m.target ? get(m.target.parentNode) : null;
     // Check if the parent is already discovered and that the parent is not the document root
-    if (value && value.data.tag !== "HTML" /* HTML */) {
+    if (value && value.data.tag !== "HTML" /* Constant.HTML */) {
         var inactive = time() > activePeriod;
         var target = get(m.target);
         var element = target && target.selector ? target.selector.join() : m.target.nodeName;
-        var parent_1 = value.selector ? value.selector.join() : "" /* Empty */;
+        var parent_1 = value.selector ? value.selector.join() : "" /* Constant.Empty */;
         // We use selector, instead of id, to determine the key (signature for the mutation) because in some cases
         // repeated mutations can cause elements to be destroyed and then recreated as new DOM nodes
         // In those cases, IDs will change however the selector (which is relative to DOM xPath) remains the same
@@ -2268,20 +2338,20 @@ function track$5(m, timer) {
         history$4[key] = key in history$4 ? history$4[key] : [0];
         var h = history$4[key];
         // Lookup any pending nodes queued up for removal, and process them now if we suspended a mutation before
-        if (inactive === false && h[0] >= 10 /* MutationSuspendThreshold */) {
-            processNodeList(h[1], 2 /* ChildListRemove */, timer);
+        if (inactive === false && h[0] >= 10 /* Setting.MutationSuspendThreshold */) {
+            processNodeList(h[1], 2 /* Source.ChildListRemove */, timer);
         }
         // Update the counter
         h[0] = inactive ? h[0] + 1 : 1;
         // Return updated mutation type based on if we have already hit the threshold or not
-        if (h[0] === 10 /* MutationSuspendThreshold */) {
+        if (h[0] === 10 /* Setting.MutationSuspendThreshold */) {
             // Store a reference to removedNodes so we can process them later
             // when we resume mutations again on user interactions
             h[1] = m.removedNodes;
-            return "suspend" /* Suspend */;
+            return "suspend" /* Constant.Suspend */;
         }
-        else if (h[0] > 10 /* MutationSuspendThreshold */) {
-            return "" /* Empty */;
+        else if (h[0] > 10 /* Setting.MutationSuspendThreshold */) {
+            return "" /* Constant.Empty */;
         }
     }
     return m.type;
@@ -2304,18 +2374,18 @@ function processNodeList(list, source, timer) {
                     _a.label = 1;
                 case 1:
                     if (!(i < length)) return [3 /*break*/, 6];
-                    if (!(source === 1 /* ChildListAdd */)) return [3 /*break*/, 2];
+                    if (!(source === 1 /* Source.ChildListAdd */)) return [3 /*break*/, 2];
                     traverse(list[i], timer, source);
                     return [3 /*break*/, 5];
                 case 2:
-                    state = state$8(timer);
-                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 4];
+                    state = state$9(timer);
+                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
                     state = _a.sent();
                     _a.label = 4;
                 case 4:
-                    if (state === 2 /* Stop */) {
+                    if (state === 2 /* Task.Stop */) {
                         return [3 /*break*/, 6];
                     }
                     processNode(list[i], source);
@@ -2340,7 +2410,7 @@ function schedule(node, fragment) {
     if (timeout$1) {
         clearTimeout(timeout$1);
     }
-    timeout$1 = setTimeout(function () { trigger$1(fragment); }, 33 /* LookAhead */);
+    timeout$1 = setTimeout(function () { trigger$1(fragment); }, 33 /* Setting.LookAhead */);
     return node;
 }
 function trigger$1(fragment) {
@@ -2353,7 +2423,7 @@ function trigger$1(fragment) {
             if (shadowRoot && has(node)) {
                 continue;
             }
-            generate(node, shadowRoot || fragment ? "childList" /* ChildList */ : "characterData" /* CharacterData */);
+            generate(node, shadowRoot || fragment ? "childList" /* Constant.ChildList */ : "characterData" /* Constant.CharacterData */);
         }
     }
     queue$2 = [];
@@ -2381,8 +2451,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
@@ -2403,14 +2474,15 @@ function reset$7() {
     hashMap = {};
     override = [];
     unmask = [];
-    maskText = "address,password,contact" /* Text */.split("," /* Comma */);
-    maskInput = "password,secret,pass,social,ssn,name,code,dob,cell,mob,contact,hidden,account,cvv,ccv,email,tel,phone,address,addr,card,zip" /* Input */.split("," /* Comma */);
-    maskDisable = "radio,checkbox,range,button,reset,submit" /* Disable */.split("," /* Comma */);
+    maskText = "address,password,contact" /* Mask.Text */.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)
@@ -2421,19 +2493,19 @@ function parse$1(root, init) {
     try {
         // Parse unmask configuration into separate query selectors and override tokens as part of initialization
         if (init) {
-            config$1.unmask.forEach(function (x) { return x.indexOf("!" /* Bang */) < 0 ? unmask.push(x) : override.push(x.substr(1)); });
+            config$1.unmask.forEach(function (x) { return x.indexOf("!" /* Constant.Bang */) < 0 ? unmask.push(x) : override.push(x.substr(1)); });
         }
         // Since mutations may happen on leaf nodes too, e.g. text nodes, which may not support all selector APIs.
         // We ensure that the root note supports querySelectorAll API before executing the code below to identify new regions.
         if ("querySelectorAll" in root) {
-            config$1.regions.forEach(function (x) { return root.querySelectorAll(x[1]).forEach(function (e) { return observe$1(e, "" + 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
+            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.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
         }
     }
     catch (e) {
-        log$1(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
+        log$1(5 /* Code.Selector */, 1 /* Severity.Warning */, e ? e.name : null);
     }
 }
 function getId(node, autogen) {
@@ -2456,7 +2528,7 @@ function add(node, parent, data, source) {
     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 */ : 3 /* TextImage */;
+    var privacyId = config$1.content ? 1 /* Privacy.Sensitive */ : 3 /* Privacy.TextImage */;
     if (parentId >= 0 && values[parentId]) {
         parentValue = values[parentId];
         parentValue.children.push(id);
@@ -2466,8 +2538,8 @@ function add(node, parent, data, source) {
         privacyId = parentValue.metadata.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 */]);
+    if (data.attributes && "data-clarity-region" /* Constant.RegionData */ in data.attributes) {
+        observe$1(node, data.attributes["data-clarity-region" /* Constant.RegionData */]);
         regionId = id;
     }
     nodes[id] = node;
@@ -2545,7 +2617,7 @@ function update$1(node, parent, data, source) {
 }
 function sameorigin(node) {
     var output = false;
-    if (node.nodeType === Node.ELEMENT_NODE && node.tagName === "IFRAME" /* IFrameTag */) {
+    if (node.nodeType === Node.ELEMENT_NODE && node.tagName === "IFRAME" /* Constant.IFrameTag */) {
         var frame = node;
         // To determine if the iframe is same-origin or not, we try accessing it's contentDocument.
         // If the browser throws an exception, we assume it's cross-origin and move on.
@@ -2572,11 +2644,21 @@ function privacy(node, value, parent) {
     var attributes = data.attributes || {};
     var tag = data.tag.toUpperCase();
     switch (true) {
-        case "data-clarity-mask" /* MaskData */ in attributes:
-            metadata.privacy = 3 /* TextImage */;
+        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;
-        case "data-clarity-unmask" /* UnmaskData */ in attributes:
-            metadata.privacy = 0 /* None */;
+        case "data-clarity-unmask" /* Constant.UnmaskData */ in attributes:
+            metadata.privacy = 0 /* Privacy.None */;
             break;
         case privacyMap.has(node):
             // If this node was explicitly configured to contain sensitive content, honor that privacy setting
@@ -2584,38 +2666,24 @@ function privacy(node, value, parent) {
             break;
         case fraudMap.has(node):
             // If this node was explicitly configured to be evaluated for fraud, then also mask content
-            metadata.privacy = 2 /* Text */;
+            metadata.privacy = 2 /* Privacy.Text */;
             break;
-        case tag === "*T" /* TextTag */:
+        case tag === "*T" /* Constant.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[1 /* Default */] : "" /* Empty */;
-            var tags = ["STYLE" /* StyleTag */, "TITLE" /* TitleTag */, "svg:style" /* SvgStyle */];
-            metadata.privacy = tags.includes(pTag) || override.some(function (x) { return pSelector_1.indexOf(x) >= 0; }) ? 0 /* None */ : current;
-            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, maskInput, metadata);
+            var pTag = parent && parent.data ? parent.data.tag : "" /* Constant.Empty */;
+            var pSelector_1 = parent && parent.selector ? parent.selector[1 /* Selector.Default */] : "" /* Constant.Empty */;
+            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" /* InputTag */ && current === 1 /* Sensitive */:
-            // Look through class names to aggressively mask content
-            metadata.privacy = inspect(attributes["class" /* 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" /* 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" /* Type */]) >= 0 ? 0 /* None */ : metadata.privacy;
-            break;
-        case current === 1 /* Sensitive */:
+        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" /* Class */], maskText, metadata);
+            metadata.privacy = inspect(attributes["class" /* Constant.Class */], maskText, metadata);
             break;
     }
 }
 function inspect(input, lookup, metadata) {
     if (input && lookup.some(function (x) { return input.indexOf(x) >= 0; })) {
-        return 2 /* Text */;
+        return 2 /* Privacy.Text */;
     }
     return metadata.privacy;
 }
@@ -2653,7 +2721,7 @@ function updateSelector(value) {
     var d = value.data;
     var p = position(parent, value);
     var s = { id: value.id, tag: d.tag, prefix: prefix, position: p, attributes: d.attributes };
-    value.selector = [get$1(s, 0 /* Alpha */), get$1(s, 1 /* Beta */)];
+    value.selector = [get$1(s, 0 /* Selector.Alpha */), get$1(s, 1 /* Selector.Beta */)];
     value.hash = value.selector.map(function (x) { return x ? hash(x) : null; });
     value.hash.forEach(function (h) { return hashMap[h] = value.id; });
     // Match fragment configuration against both alpha and beta hash
@@ -2661,6 +2729,11 @@ function updateSelector(value) {
         value.fragment = value.id;
     }
 }
+function hashText(hash) {
+    var id = lookup(hash);
+    var node = getNode(id);
+    return node !== null && node.textContent !== null ? node.textContent.substr(0, 25 /* Setting.ClickText */) : '';
+}
 function getNode(id) {
     if (id in nodes) {
         return nodes[id];
@@ -2708,7 +2781,7 @@ function remove(id, source) {
 }
 function size(value) {
     // If this element is a image node, and is masked, then track box model for the current element
-    if (value.data.tag === "IMG" /* ImageTag */ && value.metadata.privacy === 3 /* TextImage */) {
+    if (value.data.tag === "IMG" /* Constant.ImageTag */ && value.metadata.privacy === 3 /* Privacy.TextImage */) {
         value.metadata.size = [];
     }
 }
@@ -2743,7 +2816,7 @@ function track$4(id, source, fragment, changed, parentChanged) {
     // Edge case: If an element is added later on, and pre-discovered element is moved as a child.
     // In that case, we need to reorder the pre-discovered element in the update list to keep visualization consistent.
     var uIndex = updateMap.indexOf(id);
-    if (uIndex >= 0 && source === 1 /* ChildListAdd */ && parentChanged) {
+    if (uIndex >= 0 && source === 1 /* Source.ChildListAdd */ && parentChanged) {
         updateMap.splice(uIndex, 1);
         updateMap.push(id);
     }
@@ -2789,15 +2862,15 @@ function exists(node) {
 }
 function track$3(id, event) {
     var node = getNode(id);
-    var data = id in regions ? regions[id] : { id: id, visibility: 0 /* Rendered */, interaction: 16 /* None */, name: regionMap.get(node) };
+    var data = id in regions ? regions[id] : { id: id, visibility: 0 /* RegionVisibility.Rendered */, interaction: 16 /* InteractionState.None */, name: regionMap.get(node) };
     // Determine the interaction state based on incoming event
-    var interaction = 16 /* None */;
+    var interaction = 16 /* InteractionState.None */;
     switch (event) {
-        case 9 /* Click */:
-            interaction = 20 /* Clicked */;
+        case 9 /* Event.Click */:
+            interaction = 20 /* InteractionState.Clicked */;
             break;
-        case 27 /* Input */:
-            interaction = 30 /* Input */;
+        case 27 /* Event.Input */:
+            interaction = 30 /* InteractionState.Input */;
             break;
     }
     // Process updates to this region, if applicable
@@ -2825,7 +2898,7 @@ function compute$6() {
     queue$1 = q;
     // Schedule encode only when we have at least one valid data entry
     if (state$1.length > 0) {
-        encode$4(7 /* Region */);
+        encode$4(7 /* Event.Region */);
     }
 }
 function handler$1(entries) {
@@ -2841,27 +2914,27 @@ function handler$1(entries) {
         // Also, if these regions ever become non-zero width or height (through AJAX, user action or orientation change) - we will automatically start monitoring them from that point onwards
         if (regionMap.has(target) && rect.width + rect.height > 0 && viewport.width > 0 && viewport.height > 0) {
             var id = target ? getId(target) : null;
-            var data = id in regions ? regions[id] : { id: id, name: regionMap.get(target), interaction: 16 /* None */, visibility: 0 /* Rendered */ };
+            var data = id in regions ? regions[id] : { id: id, name: regionMap.get(target), interaction: 16 /* InteractionState.None */, visibility: 0 /* RegionVisibility.Rendered */ };
             // For regions that have relatively smaller area, we look at intersection ratio and see the overlap relative to element's area
             // However, for larger regions, area of regions could be bigger than viewport and therefore comparison is relative to visible area
             var viewportRatio = overlap ? (overlap.width * overlap.height * 1.0) / (viewport.width * viewport.height) : 0;
-            var visible = viewportRatio > 0.05 /* ViewportIntersectionRatio */ || entry.intersectionRatio > 0.8 /* IntersectionRatio */;
+            var visible = viewportRatio > 0.05 /* Setting.ViewportIntersectionRatio */ || entry.intersectionRatio > 0.8 /* Setting.IntersectionRatio */;
             // If an element is either visible or was visible and has been scrolled to the end
             // i.e. Scrolled to end is determined by if the starting position of the element + the window height is more than the total element height. 
             // starting position is relative to the viewport - so Intersection observer returns a negative value for rect.top to indicate that the element top is above the viewport
-            var scrolledToEnd = (visible || data.visibility == 10 /* Visible */) && Math.abs(rect.top) + viewport.height > rect.height;
+            var scrolledToEnd = (visible || data.visibility == 10 /* RegionVisibility.Visible */) && Math.abs(rect.top) + viewport.height > rect.height;
             // Process updates to this region, if applicable
             process$1(target, data, data.interaction, (scrolledToEnd ?
-                13 /* ScrolledToEnd */ :
-                (visible ? 10 /* Visible */ : 0 /* Rendered */)));
+                13 /* RegionVisibility.ScrolledToEnd */ :
+                (visible ? 10 /* RegionVisibility.Visible */ : 0 /* RegionVisibility.Rendered */)));
             // Stop observing this element now that we have already received scrolled signal
-            if (data.visibility >= 13 /* ScrolledToEnd */ && observer$1) {
+            if (data.visibility >= 13 /* RegionVisibility.ScrolledToEnd */ && observer$1) {
                 observer$1.unobserve(target);
             }
         }
     }
     if (state$1.length > 0) {
-        encode$4(7 /* Region */);
+        encode$4(7 /* Event.Region */);
     }
 }
 function process$1(n, d, s, v) {
@@ -2920,7 +2993,7 @@ function link(node) {
 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 };
+    var output = { id: 0, hash: null, privacy: 2 /* Privacy.Text */, node: node };
     if (node) {
         var value = get(node);
         if (value !== null) {
@@ -2939,22 +3012,23 @@ 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 /* MouseDown */:
-                case 14 /* MouseUp */:
-                case 12 /* MouseMove */:
-                case 15 /* MouseWheel */:
-                case 16 /* DoubleClick */:
-                case 17 /* TouchStart */:
-                case 18 /* TouchEnd */:
-                case 19 /* TouchMove */:
-                case 20 /* TouchCancel */:
+                case 13 /* Event.MouseDown */:
+                case 14 /* Event.MouseUp */:
+                case 12 /* Event.MouseMove */:
+                case 15 /* Event.MouseWheel */:
+                case 16 /* Event.DoubleClick */:
+                case 17 /* Event.TouchStart */:
+                case 18 /* Event.TouchEnd */:
+                case 19 /* Event.TouchMove */:
+                case 20 /* Event.TouchCancel */:
                     for (_i = 0, _a = state$4; _i < _a.length; _i++) {
                         entry = _a[_i];
                         pTarget = metadata$2(entry.data.target, entry.event);
@@ -2969,12 +3043,12 @@ function encode$3 (type) {
                     }
                     reset$e();
                     break;
-                case 9 /* Click */:
+                case 9 /* Event.Click */:
                     for (_b = 0, _c = state$7; _b < _c.length; _b++) {
                         entry = _c[_b];
                         cTarget = metadata$2(entry.data.target, entry.event, entry.data.text);
                         tokens = [entry.time, entry.event];
-                        cHash = cTarget.hash.join("." /* Dot */);
+                        cHash = cTarget.hash.join("." /* Constant.Dot */);
                         tokens.push(cTarget.id);
                         tokens.push(entry.data.x);
                         tokens.push(entry.data.y);
@@ -2983,8 +3057,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);
@@ -2992,7 +3066,7 @@ function encode$3 (type) {
                     }
                     reset$h();
                     break;
-                case 38 /* Clipboard */:
+                case 38 /* Event.Clipboard */:
                     for (_d = 0, _e = state$6; _d < _e.length; _d++) {
                         entry = _e[_d];
                         tokens = [entry.time, entry.event];
@@ -3005,7 +3079,7 @@ function encode$3 (type) {
                     }
                     reset$g();
                     break;
-                case 11 /* Resize */:
+                case 11 /* Event.Resize */:
                     r = data$b;
                     tokens.push(r.width);
                     tokens.push(r.height);
@@ -3013,24 +3087,24 @@ function encode$3 (type) {
                     reset$d();
                     queue(tokens);
                     break;
-                case 26 /* Unload */:
+                case 26 /* Event.Unload */:
                     u = data$9;
                     tokens.push(u.name);
                     reset$9();
                     queue(tokens);
                     break;
-                case 27 /* Input */:
+                case 27 /* Event.Input */:
                     for (_f = 0, _g = state$5; _f < _g.length; _f++) {
                         entry = _g[_f];
                         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();
                     break;
-                case 21 /* Selection */:
+                case 21 /* Event.Selection */:
                     s = data$a;
                     if (s) {
                         startTarget = metadata$2(s.start, type);
@@ -3043,7 +3117,7 @@ function encode$3 (type) {
                         queue(tokens);
                     }
                     break;
-                case 10 /* Scroll */:
+                case 10 /* Event.Scroll */:
                     for (_h = 0, _j = state$3; _h < _j.length; _h++) {
                         entry = _j[_h];
                         sTarget = metadata$2(entry.data.target, entry.event);
@@ -3058,22 +3132,38 @@ function encode$3 (type) {
                     }
                     reset$c();
                     break;
-                case 39 /* 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$a();
+                    reset$i();
                     break;
-                case 22 /* Timeline */:
-                    for (_m = 0, _o = updates$1; _m < _o.length; _m++) {
+                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);
+                        }
+                    }
+                    reset$a();
+                    break;
+                case 22 /* Event.Timeline */:
+                    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);
                         tokens.push(entry.data.x);
@@ -3084,7 +3174,7 @@ function encode$3 (type) {
                     }
                     reset$5();
                     break;
-                case 28 /* Visibility */:
+                case 28 /* Event.Visibility */:
                     v = data$8;
                     tokens.push(v.visible);
                     queue(tokens);
@@ -3107,11 +3197,11 @@ function reset$5() {
     updates$1 = [];
 }
 function track$2(time, event, hash, x, y, reaction, context) {
-    if (reaction === void 0) { reaction = 1 /* True */; }
-    if (context === void 0) { context = 0 /* Self */; }
+    if (reaction === void 0) { reaction = 1 /* BooleanFlag.True */; }
+    if (context === void 0) { context = 0 /* BrowsingContext.Self */; }
     state.push({
         time: time,
-        event: 22 /* Timeline */,
+        event: 22 /* Event.Timeline */,
         data: {
             type: event,
             hash: hash,
@@ -3130,7 +3220,7 @@ function compute$5() {
     var temp = [];
     updates$1 = [];
     var max = data$1.start + data$1.duration;
-    var min = Math.max(max - 2000 /* TimelineSpan */, 0);
+    var min = Math.max(max - 2000 /* Setting.TimelineSpan */, 0);
     for (var _i = 0, state_1 = state; _i < state_1.length; _i++) {
         var s = state_1[_i];
         if (s.time >= min) {
@@ -3141,7 +3231,7 @@ function compute$5() {
         }
     }
     state = temp; // Drop events less than the min time
-    encode$3(22 /* Timeline */);
+    encode$3(22 /* Event.Timeline */);
 }
 function stop$e() {
     state = [];
@@ -3174,10 +3264,10 @@ function queue(tokens, transmit) {
         var type = tokens.length > 1 ? tokens[1] : null;
         var event_1 = JSON.stringify(tokens);
         switch (type) {
-            case 5 /* Discover */:
+            case 5 /* Event.Discover */:
                 discoverBytes += event_1.length;
-            case 37 /* Box */:
-            case 6 /* Mutation */:
+            case 37 /* Event.Box */:
+            case 6 /* Event.Mutation */:
                 playbackBytes += event_1.length;
                 playback.push(event_1);
                 break;
@@ -3186,7 +3276,7 @@ function queue(tokens, transmit) {
                 break;
         }
         // Increment event count metric
-        count$1(25 /* EventCount */);
+        count$1(25 /* Metric.EventCount */);
         // Following two checks are precautionary and act as a fail safe mechanism to get out of unexpected situations.
         // Check 1: If for any reason the upload hasn't happened after waiting for 2x the config.delay time,
         // reset the timer. This allows Clarity to attempt an upload again.
@@ -3199,8 +3289,8 @@ function queue(tokens, transmit) {
         // However, in certain scenarios - like metric calculation - which are triggered as part of an existing upload
         // 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();
+            if (type !== 25 /* Event.Ping */) {
+                reset$o();
             }
             timeout = setTimeout(upload, gap);
             queuedTime = now;
@@ -3228,9 +3318,9 @@ function upload(final) {
             switch (_b.label) {
                 case 0:
                     timeout = null;
-                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* MaxFirstPayloadBytes */ || data$1.sequence > 0);
+                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* Setting.MaxFirstPayloadBytes */ || data$1.sequence > 0);
                     if (sendPlaybackBytes) {
-                        max(1 /* Playback */, 1 /* True */);
+                        max(1 /* Metric.Playback */, 1 /* BooleanFlag.True */);
                     }
                     // CAUTION: Ensure "transmit" is set to false in the queue function for following events
                     // Otherwise you run a risk of infinite loop.
@@ -3239,8 +3329,8 @@ function upload(final) {
                     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(), "]") : "" /* Constant.Empty */;
                     encoded = { e: e, a: a, p: p };
                     payload = stringify(encoded);
                     if (!last) return [3 /*break*/, 1];
@@ -3252,7 +3342,7 @@ function upload(final) {
                     _b.label = 3;
                 case 3:
                     zipped = _a;
-                    sum(2 /* TotalBytes */, zipped ? zipped.length : payload.length);
+                    sum(2 /* Metric.TotalBytes */, zipped ? zipped.length : payload.length);
                     send(payload, zipped, data$1.sequence, last);
                     // Clear out events now that payload has been dispatched
                     analysis = [];
@@ -3267,12 +3357,12 @@ 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; }
     // Upload data if a valid URL is defined in the config
-    if (typeof config$1.upload === "string" /* String */) {
+    if (typeof config$1.upload === "string" /* Constant.String */) {
         var url = config$1.upload;
         var dispatched = false;
         // If it's the last payload, attempt to upload using sendBeacon first.
@@ -3311,7 +3401,7 @@ function send(payload, zipped, sequence, beacon) {
             xhr_1.withCredentials = true;
             if (zipped) {
                 // If we do have valid compressed array, send it with appropriate HTTP headers so server can decode it appropriately
-                xhr_1.setRequestHeader("Accept" /* Accept */, "application/x-clarity-gzip" /* ClarityGzip */);
+                xhr_1.setRequestHeader("Accept" /* Constant.Accept */, "application/x-clarity-gzip" /* Constant.ClarityGzip */);
                 xhr_1.send(zipped);
             }
             else {
@@ -3328,13 +3418,13 @@ function send(payload, zipped, sequence, beacon) {
 }
 function check$3(xhr, sequence) {
     var transitData = transit[sequence];
-    if (xhr && xhr.readyState === 4 /* Done */ && transitData) {
+    if (xhr && xhr.readyState === 4 /* XMLReadyState.Done */ && transitData) {
         // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
-        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* RetryLimit */) {
+        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* Setting.RetryLimit */) {
             // We re-attempt in all cases except when server explicitly rejects our request with 4XX error
             if (xhr.status >= 400 && xhr.status < 500) {
                 // In case of a 4XX response from the server, we bail out instead of trying again
-                trigger(6 /* Server */);
+                trigger(6 /* Check.Server */);
             }
             else {
                 // Browser will send status = 0 when it refuses to put network request over the wire
@@ -3355,7 +3445,7 @@ function check$3(xhr, sequence) {
             track$1 = { sequence: sequence, attempts: transitData.attempts, status: xhr.status };
             // Send back an event only if we were not successful in our first attempt
             if (transitData.attempts > 1) {
-                encode$1(2 /* Upload */);
+                encode$1(2 /* Event.Upload */);
             }
             // Handle response if it was a 200 response with a valid body
             if (xhr.status === 200 && xhr.responseText) {
@@ -3366,7 +3456,7 @@ function check$3(xhr, sequence) {
                 // And, right before we terminate the session, we will attempt one last time to see if we can use
                 // different transport option (sendBeacon vs. XHR) to get this data to the server for analysis purposes
                 send(transitData.data, null, sequence, true);
-                trigger(3 /* Retry */);
+                trigger(3 /* Check.Retry */);
             }
             // Signal that this request completed successfully
             if (xhr.status >= 200 && xhr.status <= 208) {
@@ -3386,21 +3476,21 @@ function done(sequence) {
 function delay() {
     // Progressively increase delay as we continue to send more payloads from the client to the server
     // If we are not uploading data to a server, and instead invoking UploadCallback, in that case keep returning configured value
-    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* MinUploadDelay */ : data$1.sequence * config$1.delay;
-    return typeof config$1.upload === "string" /* String */ ? Math.max(Math.min(gap, 30000 /* MaxUploadDelay */), 100 /* MinUploadDelay */) : config$1.delay;
+    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* Setting.MinUploadDelay */ : data$1.sequence * config$1.delay;
+    return typeof config$1.upload === "string" /* Constant.String */ ? Math.max(Math.min(gap, 30000 /* Setting.MaxUploadDelay */), 100 /* Setting.MinUploadDelay */) : config$1.delay;
 }
 function response(payload) {
-    var parts = payload && payload.length > 0 ? payload.split(" ") : ["" /* Empty */];
+    var parts = payload && payload.length > 0 ? payload.split(" ") : ["" /* Constant.Empty */];
     switch (parts[0]) {
-        case "END" /* End */:
+        case "END" /* Constant.End */:
             // Clear out session storage and end the session so we can start fresh the next time
-            trigger(6 /* Server */);
+            trigger(6 /* Check.Server */);
             break;
-        case "UPGRADE" /* Upgrade */:
+        case "UPGRADE" /* Constant.Upgrade */:
             // Upgrade current session to send back playback information
-            upgrade("Auto" /* Auto */);
+            upgrade("Auto" /* Constant.Auto */);
             break;
-        case "ACTION" /* Action */:
+        case "ACTION" /* Constant.Action */:
             // Invoke action callback, if configured and has a valid value
             if (config$1.action && parts.length > 1) {
                 config$1.action(parts[1]);
@@ -3422,7 +3512,7 @@ function handler(error) {
     if (!(e.message in history$3)) {
         history$3[e.message] = 0;
     }
-    if (history$3[e.message]++ >= 5 /* ScriptErrorLimit */) {
+    if (history$3[e.message]++ >= 5 /* Setting.ScriptErrorLimit */) {
         return true;
     }
     // Send back information only if the handled error has valid information
@@ -3434,7 +3524,7 @@ function handler(error) {
             stack: e.stack,
             source: error["filename"]
         };
-        encode$2(31 /* ScriptError */);
+        encode$2(31 /* Event.ScriptError */);
     }
     return true;
 }
@@ -3445,15 +3535,15 @@ function encode$2 (type) {
         return __generator(this, function (_a) {
             tokens = [time(), type];
             switch (type) {
-                case 31 /* ScriptError */:
+                case 31 /* Event.ScriptError */:
                     tokens.push(data$7.message);
                     tokens.push(data$7.line);
                     tokens.push(data$7.column);
                     tokens.push(data$7.stack);
-                    tokens.push(data$7.source);
+                    tokens.push(url$1(data$7.source));
                     queue(tokens);
                     break;
-                case 33 /* Log */:
+                case 33 /* Event.Log */:
                     if (data$6) {
                         tokens.push(data$6.code);
                         tokens.push(data$6.name);
@@ -3463,11 +3553,11 @@ function encode$2 (type) {
                         queue(tokens, false);
                     }
                     break;
-                case 41 /* Fraud */:
+                case 41 /* Event.Fraud */:
                     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;
@@ -3486,7 +3576,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) {
@@ -3500,7 +3590,7 @@ function log$1(code, severity, name, message, stack) {
     else {
         history$2[code] = [key];
     }
-    encode$2(33 /* Log */);
+    encode$2(33 /* Event.Log */);
 }
 function stop$c() {
     history$2 = {};
@@ -3521,25 +3611,25 @@ function start$c() {
             var source = e[i];
             var key = e[i + 1];
             switch (source) {
-                case 0 /* Javascript */:
+                case 0 /* ExtractSource.Javascript */:
                     var variable = e[i + 2];
                     variables[key] = parse(variable);
                     break;
-                case 1 /* Cookie */:
+                case 1 /* ExtractSource.Cookie */:
                     /*Todo: Add cookie extract logic*/
                     break;
-                case 2 /* Text */:
+                case 2 /* ExtractSource.Text */:
                     var match_1 = e[i + 2];
                     selectors[key] = match_1;
                     break;
-                case 3 /* Fragment */:
+                case 3 /* ExtractSource.Fragment */:
                     fragments = e[i + 2];
                     break;
             }
         }
     }
     catch (e) {
-        log$1(8 /* Config */, 1 /* Warning */, e ? e.name : null);
+        log$1(8 /* Code.Config */, 1 /* Severity.Warning */, e ? e.name : null);
     }
 }
 function clone(v) {
@@ -3561,9 +3651,9 @@ function compute$4() {
         }
     }
     catch (e) {
-        log$1(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
+        log$1(5 /* Code.Selector */, 1 /* Severity.Warning */, e ? e.name : null);
     }
-    encode$1(40 /* Extract */);
+    encode$1(40 /* Event.Extract */);
 }
 function reset$4() {
     keys = [];
@@ -3583,15 +3673,15 @@ function stop$b() {
 }
 function parse(variable) {
     var syntax = [];
-    var parts = variable.split("." /* Dot */);
+    var parts = variable.split("." /* Constant.Dot */);
     while (parts.length > 0) {
         var part = parts.shift();
-        var arrayStart = part.indexOf("[" /* ArrayStart */);
-        var conditionStart = part.indexOf("{" /* ConditionStart */);
-        var conditionEnd = part.indexOf("}" /* ConditionEnd */);
+        var arrayStart = part.indexOf("[" /* Constant.ArrayStart */);
+        var conditionStart = part.indexOf("{" /* Constant.ConditionStart */);
+        var conditionEnd = part.indexOf("}" /* Constant.ConditionEnd */);
         syntax.push({
             name: arrayStart > 0 ? part.substring(0, arrayStart) : (conditionStart > 0 ? part.substring(0, conditionStart) : part),
-            type: arrayStart > 0 ? 1 /* Array */ : (conditionStart > 0 ? 2 /* Object */ : 3 /* Simple */),
+            type: arrayStart > 0 ? 1 /* Type.Array */ : (conditionStart > 0 ? 2 /* Type.Object */ : 3 /* Type.Simple */),
             condition: conditionStart > 0 ? part.substring(conditionStart + 1, conditionEnd) : null
         });
     }
@@ -3609,7 +3699,7 @@ function evaluate(variable, base) {
     var output;
     if (base && base[part.name]) {
         var obj = base[part.name];
-        if (part.type !== 1 /* Array */ && match(obj, part.condition)) {
+        if (part.type !== 1 /* Type.Array */ && match(obj, part.condition)) {
             output = evaluate(variable, obj);
         }
         else if (Array.isArray(obj)) {
@@ -3631,7 +3721,7 @@ function evaluate(variable, base) {
 }
 function str(input) {
     // Automatically trim string to max of Setting.ExtractLimit to avoid fetching long strings
-    return input ? JSON.stringify(input).substring(0, 10000 /* ExtractLimit */) : input;
+    return input ? JSON.stringify(input).substring(0, 10000 /* Setting.ExtractLimit */) : input;
 }
 function match(base, condition) {
     if (condition) {
@@ -3645,8 +3735,8 @@ function encode$1 (event) {
     var t = time();
     var tokens = [t, event];
     switch (event) {
-        case 4 /* Baseline */:
-            var b = state$9;
+        case 4 /* Event.Baseline */:
+            var b = state$a;
             if (b) {
                 tokens = [b.time, b.event];
                 tokens.push(b.data.visible);
@@ -3661,32 +3751,32 @@ function encode$1 (event) {
                 tokens.push(b.data.activityTime);
                 queue(tokens, false);
             }
-            reset$p();
+            reset$q();
             break;
-        case 25 /* Ping */:
+        case 25 /* Event.Ping */:
             tokens.push(data$h.gap);
             queue(tokens);
             break;
-        case 35 /* Limit */:
+        case 35 /* Event.Limit */:
             tokens.push(data$4.check);
             queue(tokens, false);
             break;
-        case 3 /* Upgrade */:
+        case 3 /* Event.Upgrade */:
             tokens.push(data$f.key);
             queue(tokens);
             break;
-        case 2 /* Upload */:
+        case 2 /* Event.Upload */:
             tokens.push(track$1.sequence);
             tokens.push(track$1.attempts);
             tokens.push(track$1.status);
             queue(tokens, false);
             break;
-        case 24 /* Custom */:
+        case 24 /* Event.Custom */:
             tokens.push(data$j.key);
             tokens.push(data$j.value);
             queue(tokens);
             break;
-        case 34 /* Variable */:
+        case 34 /* Event.Variable */:
             var variableKeys = Object.keys(data$e);
             if (variableKeys.length > 0) {
                 for (var _i = 0, variableKeys_1 = variableKeys; _i < variableKeys_1.length; _i++) {
@@ -3694,11 +3784,11 @@ function encode$1 (event) {
                     tokens.push(v);
                     tokens.push(data$e[v]);
                 }
-                reset$l();
+                reset$m();
                 queue(tokens, false);
             }
             break;
-        case 0 /* Metric */:
+        case 0 /* Event.Metric */:
             var metricKeys = Object.keys(updates$3);
             if (metricKeys.length > 0) {
                 for (var _a = 0, metricKeys_1 = metricKeys; _a < metricKeys_1.length; _a++) {
@@ -3709,11 +3799,11 @@ 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;
-        case 1 /* Dimension */:
+        case 1 /* Event.Dimension */:
             var dimensionKeys = Object.keys(updates);
             if (dimensionKeys.length > 0) {
                 for (var _b = 0, dimensionKeys_1 = dimensionKeys; _b < dimensionKeys_1.length; _b++) {
@@ -3726,7 +3816,7 @@ function encode$1 (event) {
                 queue(tokens, false);
             }
             break;
-        case 36 /* Summary */:
+        case 36 /* Event.Summary */:
             var eventKeys = Object.keys(data$g);
             if (eventKeys.length > 0) {
                 for (var _c = 0, eventKeys_1 = eventKeys; _c < eventKeys_1.length; _c++) {
@@ -3735,11 +3825,11 @@ function encode$1 (event) {
                     tokens.push(key);
                     tokens.push([].concat.apply([], data$g[e]));
                 }
-                reset$m();
+                reset$n();
                 queue(tokens, false);
             }
             break;
-        case 40 /* Extract */:
+        case 40 /* Event.Extract */:
             var extractKeys = keys;
             for (var _d = 0, extractKeys_1 = extractKeys; _d < extractKeys_1.length; _d++) {
                 var e = extractKeys_1[_d];
@@ -3753,14 +3843,14 @@ function encode$1 (event) {
 
 var data$4;
 function start$b() {
-    data$4 = { check: 0 /* None */ };
+    data$4 = { check: 0 /* Check.None */ };
 }
 function check$2(bytes) {
-    if (data$4.check === 0 /* None */) {
+    if (data$4.check === 0 /* Check.None */) {
         var reason = data$4.check;
-        reason = data$1.sequence >= 128 /* PayloadLimit */ ? 1 /* Payload */ : reason;
-        reason = time() > 7200000 /* ShutdownLimit */ ? 2 /* Shutdown */ : reason;
-        reason = bytes > 10485760 /* PlaybackBytesLimit */ ? 2 /* Shutdown */ : reason;
+        reason = data$1.sequence >= 128 /* Setting.PayloadLimit */ ? 1 /* Check.Payload */ : reason;
+        reason = time() > 7200000 /* Setting.ShutdownLimit */ ? 2 /* Check.Shutdown */ : reason;
+        reason = bytes > 10485760 /* Setting.PlaybackBytesLimit */ ? 2 /* Check.Shutdown */ : reason;
         if (reason !== data$4.check) {
             trigger(reason);
         }
@@ -3772,8 +3862,8 @@ function trigger(reason) {
     stop();
 }
 function compute$3() {
-    if (data$4.check !== 0 /* None */) {
-        encode$1(35 /* Limit */);
+    if (data$4.check !== 0 /* Check.None */) {
+        encode$1(35 /* Event.Limit */);
     }
 }
 function stop$a() {
@@ -3794,7 +3884,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] = [];
         }
@@ -3807,14 +3897,14 @@ function log(dimension, value) {
             }
             updates[dimension].push(value);
             // Limit check to ensure we have a cap on number of dimensions we can collect
-            if (data$3[dimension].length > 128 /* CollectionLimit */) {
-                trigger(5 /* Collection */);
+            if (data$3[dimension].length > 128 /* Setting.CollectionLimit */) {
+                trigger(5 /* Check.Collection */);
             }
         }
     }
 }
 function compute$2() {
-    encode$1(1 /* Dimension */);
+    encode$1(1 /* Event.Dimension */);
 }
 function reset$3() {
     updates = {};
@@ -3825,39 +3915,40 @@ var callbacks = [];
 var rootDomain = null;
 function start$9() {
     rootDomain = null;
-    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Empty */;
-    var title = document && document.title ? document.title : "" /* Empty */;
+    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Constant.Empty */;
+    var title = document && document.title ? document.title : "" /* Constant.Empty */;
     // Populate ids for this page
     var s = session();
     var u = user();
-    data$2 = {
-        projectId: config$1.projectId || hash(location.host),
-        userId: u.id,
-        sessionId: s.session,
-        pageNum: s.count
-    };
+    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 /* False */ : config$1.lean;
-    config$1.upload = config$1.track && typeof config$1.upload === "string" /* String */ && s.upload && s.upload.length > "https://" /* HTTPS */.length ? s.upload : config$1.upload;
-    // Log dimensions
-    log(0 /* UserAgent */, ua);
-    log(3 /* PageTitle */, title);
-    log(1 /* Url */, location.href);
-    log(2 /* Referrer */, document.referrer);
-    log(15 /* TabId */, tab());
-    log(16 /* PageLanguage */, document.documentElement.lang);
-    log(17 /* DocumentDirection */, document.dir);
+    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 page metadata as dimensions
+    log(0 /* Dimension.UserAgent */, ua);
+    log(3 /* Dimension.PageTitle */, title);
+    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 /* 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 /* ClientTimestamp */, s.ts);
-    max(1 /* Playback */, 0 /* False */);
     if (screen) {
-        max(14 /* ScreenWidth */, Math.round(screen.width));
-        max(15 /* ScreenHeight */, Math.round(screen.height));
-        max(16 /* ColorDepth */, Math.round(screen.colorDepth));
+        max(14 /* Metric.ScreenWidth */, Math.round(screen.width));
+        max(15 /* Metric.ScreenHeight */, Math.round(screen.height));
+        max(16 /* Metric.ColorDepth */, Math.round(screen.colorDepth));
     }
     // Read cookies specified in configuration
     for (var _i = 0, _a = config$1.cookies; _i < _a.length; _i++) {
@@ -3871,22 +3962,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 /* Platform */, ua.platform);
-            log(23 /* PlatformVersion */, ua.platformVersion);
-            (_a = ua.brands) === null || _a === void 0 ? void 0 : _a.forEach(function (brand) {
-                log(24 /* Brand */, brand.name + "~" /* Tilde */ + brand.version);
-            });
-            log(25 /* Model */, ua.model);
-            max(27 /* Mobile */, ua.mobile ? 1 /* True */ : 0 /* False */);
+            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); });
+            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;
@@ -3901,33 +3990,33 @@ function metadata(cb, wait) {
     callbacks.push({ callback: cb, wait: wait });
 }
 function id() {
-    return data$2 ? [data$2.userId, data$2.sessionId, data$2.pageNum].join("." /* Dot */) : "" /* Empty */;
+    return data$2 ? [data$2.userId, data$2.sessionId, data$2.pageNum].join("." /* Constant.Dot */) : "" /* Constant.Empty */;
 }
 function consent() {
     if (active()) {
         config$1.track = true;
-        track(user(), 1 /* True */);
+        track(user(), 1 /* BooleanFlag.True */);
     }
 }
 function clear() {
     // Clear any stored information in the cookie that tracks session information so we can restart fresh the next time
-    setCookie("_clsk" /* SessionKey */, "" /* Empty */, 0);
+    setCookie("_clsk" /* Constant.SessionKey */, "" /* Constant.Empty */, 0);
 }
 function tab() {
     var id = shortid();
-    if (config$1.track && supported(window, "sessionStorage" /* SessionStorage */)) {
-        var value = sessionStorage.getItem("_cltk" /* TabKey */);
+    if (config$1.track && supported(window, "sessionStorage" /* Constant.SessionStorage */)) {
+        var value = sessionStorage.getItem("_cltk" /* Constant.TabKey */);
         id = value ? value : id;
-        sessionStorage.setItem("_cltk" /* TabKey */, id);
+        sessionStorage.setItem("_cltk" /* Constant.TabKey */, id);
     }
     return id;
 }
 function save() {
     var ts = Math.round(Date.now());
-    var upload = config$1.upload && typeof config$1.upload === "string" /* String */ ? config$1.upload.replace("https://" /* HTTPS */, "" /* Empty */) : "" /* Empty */;
-    var upgrade = config$1.lean ? 0 /* False */ : 1 /* True */;
+    var upload = config$1.upload && typeof config$1.upload === "string" /* Constant.String */ ? config$1.upload.replace("https://" /* Constant.HTTPS */, "" /* Constant.Empty */) : "" /* Constant.Empty */;
+    var upgrade = config$1.lean ? 0 /* BooleanFlag.False */ : 1 /* BooleanFlag.True */;
     processCallback(upgrade);
-    setCookie("_clsk" /* SessionKey */, [data$2.sessionId, ts, data$2.pageNum, upgrade, upload].join("|" /* Pipe */), 1 /* SessionExpire */);
+    setCookie("_clsk" /* Constant.SessionKey */, [data$2.sessionId, ts, data$2.pageNum, upgrade, upload].join("|" /* Constant.Pipe */), 1 /* Setting.SessionExpire */);
 }
 function processCallback(upgrade) {
     if (callbacks.length > 0) {
@@ -3952,10 +4041,10 @@ function track(u, consent) {
     consent = consent === null ? u.consent : consent;
     // Convert time precision into days to reduce number of bytes we have to write in a cookie
     // E.g. Math.ceil(1628735962643 / (24*60*60*1000)) => 18852 (days) => ejo in base36 (13 bytes => 3 bytes)
-    var end = Math.ceil((Date.now() + (365 /* Expire */ * 86400000 /* Day */)) / 86400000 /* Day */);
+    var end = Math.ceil((Date.now() + (365 /* Setting.Expire */ * 86400000 /* Time.Day */)) / 86400000 /* Time.Day */);
     // To avoid cookie churn, write user id cookie only once every day
-    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* CookieInterval */ || u.consent !== consent) {
-        setCookie("_clck" /* CookieKey */, [data$2.userId, 1 /* CookieVersion */, end.toString(36), consent].join("|" /* Pipe */), 365 /* Expire */);
+    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* Setting.CookieInterval */ || u.consent !== consent) {
+        setCookie("_clck" /* Constant.CookieKey */, [data$2.userId, 1 /* Setting.CookieVersion */, end.toString(36), consent].join("|" /* Constant.Pipe */), 365 /* Setting.Expire */);
     }
 }
 function shortid() {
@@ -3966,17 +4055,17 @@ function shortid() {
     return id.toString(36);
 }
 function session() {
-    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Empty */ };
-    var value = getCookie("_clsk" /* SessionKey */);
+    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Constant.Empty */ };
+    var value = getCookie("_clsk" /* Constant.SessionKey */);
     if (value) {
-        var parts = value.split("|" /* Pipe */);
+        var parts = value.split("|" /* Constant.Pipe */);
         // Making it backward & forward compatible by using greater than comparison (v0.6.21)
         // In future version, we can reduce the parts length to be 5 where the last part contains the full upload URL
-        if (parts.length >= 5 && output.ts - num(parts[1]) < 1800000 /* SessionTimeout */) {
+        if (parts.length >= 5 && output.ts - num(parts[1]) < 1800000 /* Setting.SessionTimeout */) {
             output.session = parts[0];
             output.count = num(parts[2]) + 1;
             output.upgrade = num(parts[3]);
-            output.upload = parts.length >= 6 ? "" + "https://" /* HTTPS */ + parts[5] + "/" + parts[4] : "" + "https://" /* HTTPS */ + parts[4];
+            output.upload = parts.length >= 6 ? "".concat("https://" /* Constant.HTTPS */).concat(parts[5], "/").concat(parts[4]) : "".concat("https://" /* Constant.HTTPS */).concat(parts[4]);
         }
     }
     return output;
@@ -3986,26 +4075,26 @@ function num(string, base) {
     return parseInt(string, base);
 }
 function user() {
-    var output = { id: shortid(), expiry: null, consent: 0 /* False */ };
-    var cookie = getCookie("_clck" /* CookieKey */);
+    var output = { id: shortid(), expiry: null, consent: 0 /* BooleanFlag.False */ };
+    var cookie = getCookie("_clck" /* Constant.CookieKey */);
     if (cookie && cookie.length > 0) {
         // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
-        var parts = cookie.split("|" /* Pipe */);
+        var parts = cookie.split("|" /* Constant.Pipe */);
         // For backward compatibility introduced in v0.6.18; following code can be removed with future iterations
         // Count number of times Clarity's user cookie crumb appears in document.cookie (could be on different sub-domains e.g. www.domain.com and .domain.com)
         var count = 0;
-        for (var _i = 0, _a = document.cookie.split(";" /* Semicolon */); _i < _a.length; _i++) {
+        for (var _i = 0, _a = document.cookie.split(";" /* Constant.Semicolon */); _i < _a.length; _i++) {
             var c = _a[_i];
-            count += c.split("=" /* Equals */)[0].trim() === "_clck" /* CookieKey */ ? 1 : 0;
+            count += c.split("=" /* Constant.Equals */)[0].trim() === "_clck" /* Constant.CookieKey */ ? 1 : 0;
         }
         // Check if we either got version-less cookie value or saw multiple copies of the user cookie crumbs
         // In both these cases, we go ahead and delete the existing cookie set on current domain
         if (parts.length === 1 || count > 1) {
-            var deleted = "" + ";" /* Semicolon */ + "expires=" /* Expires */ + (new Date(0)).toUTCString() + ";path=/" /* Path */;
+            var deleted = "".concat(";" /* Constant.Semicolon */).concat("expires=" /* Constant.Expires */).concat((new Date(0)).toUTCString()).concat(";path=/" /* Constant.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" /* Constant.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" /* Constant.SessionKey */, "=").concat(deleted);
         }
         // End code for backward compatibility
         // Read version information and timestamp from cookie, if available
@@ -4014,21 +4103,21 @@ function user() {
         }
         // Check if we have explicit consent to track this user
         if (parts.length > 3 && num(parts[3]) === 1) {
-            output.consent = 1 /* True */;
+            output.consent = 1 /* BooleanFlag.True */;
         }
         // Set track configuration to true for this user if we have explicit consent, regardless of project setting
-        config$1.track = config$1.track || output.consent === 1 /* True */;
+        config$1.track = config$1.track || output.consent === 1 /* BooleanFlag.True */;
         // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
         output.id = config$1.track ? parts[0] : output.id;
     }
     return output;
 }
 function getCookie(key) {
-    if (supported(document, "cookie" /* Cookie */)) {
-        var cookies = document.cookie.split(";" /* Semicolon */);
+    if (supported(document, "cookie" /* Constant.Cookie */)) {
+        var cookies = document.cookie.split(";" /* Constant.Semicolon */);
         if (cookies) {
             for (var i = 0; i < cookies.length; i++) {
-                var pair = cookies[i].split("=" /* Equals */);
+                var pair = cookies[i].split("=" /* Constant.Equals */);
                 if (pair.length > 1 && pair[0] && pair[0].trim() === key) {
                     return pair[1];
                 }
@@ -4038,23 +4127,23 @@ function getCookie(key) {
     return null;
 }
 function setCookie(key, value, time) {
-    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported(document, "cookie" /* Cookie */))) {
+    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported(document, "cookie" /* Constant.Cookie */))) {
         var expiry = new Date();
         expiry.setDate(expiry.getDate() + time);
-        var expires = expiry ? "expires=" /* Expires */ + expiry.toUTCString() : "" /* Empty */;
-        var cookie = key + "=" + value + ";" /* Semicolon */ + expires + ";path=/" /* Path */;
+        var expires = expiry ? "expires=" /* Constant.Expires */ + expiry.toUTCString() : "" /* Constant.Empty */;
+        var cookie = "".concat(key, "=").concat(value).concat(";" /* Constant.Semicolon */).concat(expires).concat(";path=/" /* Constant.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 */) : [];
+                var hostname = location.hostname ? location.hostname.split("." /* Constant.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 : "" /* Constant.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(";" /* Constant.Semicolon */).concat("domain=" /* Constant.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
@@ -4066,13 +4155,13 @@ function setCookie(key, value, time) {
                 }
                 // Finally, if we were not successful and gone through all the options, play it safe and reset rootDomain to be empty
                 // This forces our code to fall back to always writing cookie to the current domain
-                rootDomain = "" /* Empty */;
+                rootDomain = "" /* Constant.Empty */;
             }
         }
         catch (_a) {
-            rootDomain = "" /* Empty */;
+            rootDomain = "" /* Constant.Empty */;
         }
-        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
+        document.cookie = rootDomain ? "".concat(cookie).concat(";" /* Constant.Semicolon */).concat("domain=" /* Constant.Domain */).concat(rootDomain) : cookie;
     }
 }
 
@@ -4088,8 +4177,8 @@ function start$8() {
         userId: m.userId,
         sessionId: m.sessionId,
         pageNum: m.pageNum,
-        upload: 0 /* Async */,
-        end: 0 /* False */
+        upload: 0 /* Upload.Async */,
+        end: 0 /* BooleanFlag.False */
     };
 }
 function stop$7() {
@@ -4099,8 +4188,8 @@ function envelope(last) {
     data$1.start = data$1.start + data$1.duration;
     data$1.duration = time() - data$1.start;
     data$1.sequence++;
-    data$1.upload = last && "sendBeacon" in navigator ? 1 /* Beacon */ : 0 /* Async */;
-    data$1.end = last ? 1 /* True */ : 0 /* False */;
+    data$1.upload = last && "sendBeacon" in navigator ? 1 /* Upload.Beacon */ : 0 /* Upload.Async */;
+    data$1.end = last ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */;
     return [
         data$1.version,
         data$1.sequence,
@@ -4153,10 +4242,10 @@ function measure (method) {
             throw report(ex);
         }
         var duration = performance.now() - start;
-        sum(4 /* TotalCost */, duration);
-        if (duration > 30 /* LongTask */) {
-            count$1(7 /* LongTaskCount */);
-            max(6 /* ThreadBlockedTime */, duration);
+        sum(4 /* Metric.TotalCost */, duration);
+        if (duration > 30 /* Setting.LongTask */) {
+            count$1(7 /* Metric.LongTaskCount */);
+            max(6 /* Metric.ThreadBlockedTime */, duration);
         }
     };
 }
@@ -4168,7 +4257,7 @@ function bind(target, event, listener, capture) {
     // Wrapping following lines inside try / catch to cover edge cases where we might try to access an inaccessible element.
     // E.g. Iframe may start off as same-origin but later turn into cross-origin, and the following lines will throw an exception.
     try {
-        target[api("addEventListener" /* AddEventListener */)](event, listener, capture);
+        target[api("addEventListener" /* Constant.AddEventListener */)](event, listener, capture);
         bindings.push({ event: event, target: target, listener: listener, capture: capture });
     }
     catch ( /* do nothing */_a) { /* do nothing */ }
@@ -4179,7 +4268,7 @@ function reset$1() {
         var binding = bindings_1[_i];
         // Wrapping inside try / catch to avoid situations where the element may be destroyed before we get a chance to unbind
         try {
-            binding.target[api("removeEventListener" /* RemoveEventListener */)](binding.event, binding.listener, binding.capture);
+            binding.target[api("removeEventListener" /* Constant.RemoveEventListener */)](binding.event, binding.listener, binding.capture);
         }
         catch ( /* do nothing */_a) { /* do nothing */ }
     }
@@ -4216,8 +4305,8 @@ function start$7() {
     }
 }
 function check$1() {
-    if (count++ > 20 /* CallStackDepth */) {
-        log$1(4 /* CallStackDepth */, 0 /* Info */);
+    if (count++ > 20 /* Setting.CallStackDepth */) {
+        log$1(4 /* Code.CallStackDepth */, 0 /* Severity.Info */);
         return false;
     }
     return true;
@@ -4227,15 +4316,15 @@ function compute$1() {
     if (url !== getCurrentUrl()) {
         // If the url changed, start tracking it as a new page
         stop();
-        window.setTimeout(restart$1, 250 /* RestartDelay */);
+        window.setTimeout(restart$1, 250 /* Setting.RestartDelay */);
     }
 }
 function restart$1() {
     start();
-    max(29 /* SinglePage */, 1 /* True */);
+    max(29 /* Metric.SinglePage */, 1 /* BooleanFlag.True */);
 }
 function getCurrentUrl() {
-    return location.href ? location.href.replace(location.hash, "" /* Empty */) : location.href;
+    return location.href ? location.href.replace(location.hash, "" /* Constant.Empty */) : location.href;
 }
 function stop$6() {
     url = null;
@@ -4245,8 +4334,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();
@@ -4255,8 +4344,8 @@ function stop$5() {
     stop$6();
     reset$2();
     reset$1();
-    reset$j();
-    stop$B();
+    reset$k();
+    stop$C();
     status = false;
 }
 function active() {
@@ -4298,7 +4387,7 @@ function config(override) {
 // not holding the session during inactive time periods.
 function suspend() {
     if (status) {
-        event("clarity" /* Clarity */, "suspend" /* Suspend */);
+        event("clarity" /* Constant.Clarity */, "suspend" /* Constant.Suspend */);
         stop();
         ["mousemove", "touchstart"].forEach(function (x) { return bind(document, x, restart); });
         ["resize", "scroll", "pageshow"].forEach(function (x) { return bind(window, x, restart); });
@@ -4306,11 +4395,11 @@ function suspend() {
 }
 function restart() {
     start();
-    event("clarity" /* Clarity */, "restart" /* Restart */);
+    event("clarity" /* Constant.Clarity */, "restart" /* Constant.Restart */);
 }
 
 function start$5() {
-    start$x();
+    start$y();
     start$e();
     start$d();
 }
@@ -4325,7 +4414,7 @@ var diagnostic = /*#__PURE__*/Object.freeze({
 });
 
 function start$4() {
-    schedule$1(discover, 1 /* High */).then(function () {
+    schedule$1(discover, 1 /* Priority.High */).then(function () {
         measure(compute$7)();
         measure(compute$6)();
     });
@@ -4337,15 +4426,15 @@ function discover() {
             switch (_a.label) {
                 case 0:
                     ts = time();
-                    timer = { id: id(), cost: 3 /* LayoutCost */ };
-                    start$w(timer);
-                    return [4 /*yield*/, traverse(document, timer, 0 /* Discover */)];
+                    timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
+                    start$x(timer);
+                    return [4 /*yield*/, traverse(document, timer, 0 /* Source.Discover */)];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, encode$4(5 /* Discover */, timer, ts)];
+                    return [4 /*yield*/, encode$4(5 /* Event.Discover */, timer, ts)];
                 case 2:
                     _a.sent();
-                    stop$t(timer);
+                    stop$u(timer);
                     return [2 /*return*/];
             }
         });
@@ -4355,7 +4444,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();
@@ -4371,7 +4460,8 @@ function stop$3() {
 var layout = /*#__PURE__*/Object.freeze({
     __proto__: null,
     start: start$3,
-    stop: stop$3
+    stop: stop$3,
+    hashText: hashText
 });
 
 function encode (type) {
@@ -4381,7 +4471,7 @@ function encode (type) {
             t = time();
             tokens = [t, type];
             switch (type) {
-                case 29 /* Navigation */:
+                case 29 /* Event.Navigation */:
                     tokens.push(data.fetchStart);
                     tokens.push(data.connectStart);
                     tokens.push(data.connectEnd);
@@ -4430,12 +4520,16 @@ function compute(entry) {
         encodedSize: entry.encodedBodySize ? entry.encodedBodySize : 0,
         decodedSize: entry.decodedBodySize ? entry.decodedBodySize : 0
     };
-    encode(29 /* Navigation */);
+    encode(29 /* Event.Navigation */);
 }
 
 var observer;
-var types = ["navigation" /* Navigation */, "resource" /* Resource */, "longtask" /* LongTask */, "first-input" /* FID */, "layout-shift" /* CLS */, "largest-contentful-paint" /* LCP */];
+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.
@@ -4449,7 +4543,7 @@ function start$2() {
         }
     }
     else {
-        log$1(3 /* PerformanceObserver */, 0 /* Info */);
+        log$1(3 /* Code.PerformanceObserver */, 0 /* Severity.Info */);
     }
 }
 function observe() {
@@ -4469,15 +4563,15 @@ function observe() {
             if (PerformanceObserver.supportedEntryTypes.indexOf(x) >= 0) {
                 // Initialize CLS with a value of zero. It's possible (and recommended) for sites to not have any cumulative layout shift.
                 // In those cases, we want to still initialize the metric in Clarity
-                if (x === "layout-shift" /* CLS */) {
-                    sum(9 /* CumulativeLayoutShift */, 0);
+                if (x === "layout-shift" /* Constant.CLS */) {
+                    sum(9 /* Metric.CumulativeLayoutShift */, 0);
                 }
                 observer.observe({ type: x, buffered: true });
             }
         }
     }
     catch (_a) {
-        log$1(3 /* PerformanceObserver */, 1 /* Warning */);
+        log$1(3 /* Code.PerformanceObserver */, 1 /* Severity.Warning */);
     }
 }
 function handle(entries) {
@@ -4488,41 +4582,41 @@ function process(entries) {
     for (var i = 0; i < entries.length; i++) {
         var entry = entries[i];
         switch (entry.entryType) {
-            case "navigation" /* Navigation */:
+            case "navigation" /* Constant.Navigation */:
                 compute(entry);
                 break;
-            case "resource" /* Resource */:
+            case "resource" /* Constant.Resource */:
                 var name_1 = entry.name;
-                log(4 /* NetworkHosts */, host(name_1));
+                log(4 /* Dimension.NetworkHosts */, host(name_1));
                 if (name_1 === config$1.upload || name_1 === config$1.fallback) {
-                    max(28 /* UploadTime */, entry.duration);
+                    max(28 /* Metric.UploadTime */, entry.duration);
                 }
                 break;
-            case "longtask" /* LongTask */:
-                count$1(7 /* LongTaskCount */);
+            case "longtask" /* Constant.LongTask */:
+                count$1(7 /* Metric.LongTaskCount */);
                 break;
-            case "first-input" /* FID */:
+            case "first-input" /* Constant.FID */:
                 if (visible) {
-                    max(10 /* FirstInputDelay */, entry["processingStart"] - entry.startTime);
+                    max(10 /* Metric.FirstInputDelay */, entry["processingStart"] - entry.startTime);
                 }
                 break;
-            case "layout-shift" /* CLS */:
+            case "layout-shift" /* Constant.CLS */:
                 // Scale the value to avoid sending back floating point number
                 if (visible && !entry["hadRecentInput"]) {
-                    sum(9 /* CumulativeLayoutShift */, entry["value"] * 1000);
+                    sum(9 /* Metric.CumulativeLayoutShift */, entry["value"] * 1000);
                 }
                 break;
-            case "largest-contentful-paint" /* LCP */:
+            case "largest-contentful-paint" /* Constant.LCP */:
                 if (visible) {
-                    max(8 /* LargestPaint */, entry.startTime);
+                    max(8 /* Metric.LargestPaint */, entry.startTime);
                 }
                 break;
         }
     }
-    if (performance && "memory" /* Memory */ in performance && performance["memory" /* Memory */].usedJSHeapSize) {
+    if (performance && "memory" /* Constant.Memory */ in performance && performance["memory" /* Constant.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 */));
+        max(30 /* Metric.UsedMemory */, Math.abs(performance["memory" /* Constant.Memory */].usedJSHeapSize / 1048576 /* Setting.MegaByte */));
     }
 }
 function stop$2() {
@@ -4559,7 +4653,7 @@ function start(config$1) {
     if (check()) {
         config(config$1);
         start$6();
-        start$y();
+        start$z();
         modules.forEach(function (x) { return measure(x.start)(); });
     }
 }
@@ -4570,7 +4664,7 @@ function start(config$1) {
 // performance impact even further. For reference, we are talking single digit milliseconds optimization here, not seconds.
 function pause() {
     if (active()) {
-        event("clarity" /* Clarity */, "pause" /* Pause */);
+        event("clarity" /* Constant.Clarity */, "pause" /* Constant.Pause */);
         pause$1();
     }
 }
@@ -4578,14 +4672,14 @@ function pause() {
 function resume() {
     if (active()) {
         resume$1();
-        event("clarity" /* Clarity */, "resume" /* Resume */);
+        event("clarity" /* Constant.Clarity */, "resume" /* Constant.Resume */);
     }
 }
 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();
     }
 }
@@ -4602,7 +4696,8 @@ var clarity = /*#__PURE__*/Object.freeze({
     identify: identify,
     set: set,
     upgrade: upgrade,
-    metadata: metadata
+    metadata: metadata,
+    hashText: hashText
 });
 
 var helper = { hash: hash, selector: selector, get: get, getNode: getNode, lookup: lookup };