clarity-js 0.6.40 → 0.6.42

package/build/clarity.module.js

@@ -75,7 +75,7 @@ var envelope$1 = /*#__PURE__*/Object.freeze({
 
 var config$1 = {
     projectId: null,
-    delay: 1 * 1000 /* Time.Second */,
+    delay: 1 * 1000 /* Second */,
     lean: false,
     track: true,
     content: true,
@@ -88,14 +88,15 @@ var config$1 = {
     report: null,
     upload: null,
     fallback: null,
-    upgrade: null
+    upgrade: null,
+    action: null
 };
 
 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" /* Constant.Zone */] && "__symbol__" /* Constant.Symbol */ in window["Zone" /* Constant.Zone */] ? window["Zone" /* Constant.Zone */]["__symbol__" /* Constant.Symbol */](method) : method;
+    return window["Zone" /* Zone */] && "__symbol__" /* Symbol */ in window["Zone" /* Zone */] ? window["Zone" /* Zone */]["__symbol__" /* Symbol */](method) : method;
 }
 
 var startTime = 0;
@@ -111,7 +112,7 @@ function stop$B() {
     startTime = 0;
 }
 
-var version$1 = "0.6.40";
+var version$1 = "0.6.42";
 
 // tslint:disable: no-bitwise
 function hash (input) {
@@ -144,7 +145,7 @@ function reset$p() {
     // Baseline state holds the previous values - if it is updated in the current payload,
     // reset the state to current value after sending the previous state
     if (update$2) {
-        state$9 = { time: time(), event: 4 /* Event.Baseline */, data: {
+        state$9 = { time: time(), event: 4 /* Baseline */, data: {
                 visible: buffer.visible,
                 docWidth: buffer.docWidth,
                 docHeight: buffer.docHeight,
@@ -159,7 +160,7 @@ function reset$p() {
         };
     }
     buffer = buffer ? buffer : {
-        visible: 1 /* BooleanFlag.True */,
+        visible: 1 /* True */,
         docWidth: 0,
         docHeight: 0,
         screenWidth: 0,
@@ -173,15 +174,15 @@ function reset$p() {
 }
 function track$7(event, x, y) {
     switch (event) {
-        case 8 /* Event.Document */:
+        case 8 /* Document */:
             buffer.docWidth = x;
             buffer.docHeight = y;
             break;
-        case 11 /* Event.Resize */:
+        case 11 /* Resize */:
             buffer.screenWidth = x;
             buffer.screenHeight = y;
             break;
-        case 10 /* Event.Scroll */:
+        case 10 /* Scroll */:
             buffer.scrollX = x;
             buffer.scrollY = y;
             break;
@@ -196,7 +197,7 @@ function activity(t) {
     buffer.activityTime = t;
 }
 function visibility(t, visible) {
-    buffer.visible = visible === "visible" ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */;
+    buffer.visible = visible === "visible" ? 1 /* True */ : 0 /* False */;
     if (!buffer.visible) {
         activity(t);
     }
@@ -204,7 +205,7 @@ function visibility(t, visible) {
 }
 function compute$c() {
     if (update$2) {
-        encode$1(4 /* Event.Baseline */);
+        encode$1(4 /* Baseline */);
     }
 }
 function stop$A() {
@@ -228,12 +229,12 @@ function event(key, value) {
     if (active() &&
         key &&
         value &&
-        typeof key === "string" /* Constant.String */ &&
-        typeof value === "string" /* Constant.String */ &&
+        typeof key === "string" /* String */ &&
+        typeof value === "string" /* String */ &&
         key.length < 255 &&
         value.length < 255) {
         data$j = { key: key, value: value };
-        encode$1(24 /* Event.Custom */);
+        encode$1(24 /* Custom */);
     }
 }
 
@@ -242,7 +243,7 @@ var updates$3 = null;
 function start$D() {
     data$i = {};
     updates$3 = {};
-    count$1(5 /* Metric.InvokeCount */);
+    count$1(5 /* InvokeCount */);
 }
 function stop$z() {
     data$i = {};
@@ -283,7 +284,7 @@ function max(metric, value) {
     }
 }
 function compute$b() {
-    encode$1(0 /* Event.Metric */);
+    encode$1(0 /* Metric */);
 }
 function reset$o() {
     updates$3 = {};
@@ -301,7 +302,7 @@ var last = 0;
 var interval = 0;
 var timeout$6 = null;
 function start$C() {
-    interval = 60000 /* Setting.PingInterval */;
+    interval = 60000 /* PingInterval */;
     last = 0;
 }
 function reset$n() {
@@ -314,8 +315,8 @@ function reset$n() {
 function ping() {
     var now = time();
     data$h = { gap: now - last };
-    encode$1(25 /* Event.Ping */);
-    if (data$h.gap < 300000 /* Setting.PingTimeout */) {
+    encode$1(25 /* Ping */);
+    if (data$h.gap < 300000 /* PingTimeout */) {
         timeout$6 = setTimeout(ping, interval);
     }
     else {
@@ -352,7 +353,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 /* Setting.SummaryInterval */) {
+        if (time - last[0] > 100 /* SummaryInterval */) {
             data$g[event].push([time, 0]);
         }
         else {
@@ -361,7 +362,7 @@ function track$6(event, time) {
     }
 }
 function compute$a() {
-    encode$1(36 /* Event.Summary */);
+    encode$1(36 /* Summary */);
 }
 function reset$m() {
     data$g = {};
@@ -380,7 +381,7 @@ var summary = /*#__PURE__*/Object.freeze({
 var data$f = null;
 function start$A() {
     if (!config$1.lean && config$1.upgrade) {
-        config$1.upgrade("Config" /* Constant.Config */);
+        config$1.upgrade("Config" /* Config */);
     }
     data$f = null;
 }
@@ -399,7 +400,7 @@ function upgrade(key) {
         if (config$1.upgrade) {
             config$1.upgrade(key);
         }
-        encode$1(3 /* Event.Upgrade */);
+        encode$1(3 /* Upgrade */);
     }
 }
 function stop$w() {
@@ -419,25 +420,25 @@ function start$z() {
     reset$l();
 }
 function set(variable, value) {
-    var values = typeof value === "string" /* Constant.String */ ? [value] : value;
+    var values = typeof value === "string" /* 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" /* Constant.UserId */, [userId]);
-    log$2("sessionId" /* Constant.SessionId */, [sessionId]);
-    log$2("pageId" /* Constant.PageId */, [pageId]);
+    log$2("userId" /* UserId */, [userId]);
+    log$2("sessionId" /* SessionId */, [sessionId]);
+    log$2("pageId" /* PageId */, [pageId]);
 }
 function log$2(variable, value) {
     if (active() &&
         variable &&
         value &&
-        typeof variable === "string" /* Constant.String */ &&
+        typeof variable === "string" /* 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" /* Constant.String */ && value[i].length < 255) {
+            if (typeof value[i] === "string" /* String */ && value[i].length < 255) {
                 validValues.push(value[i]);
             }
         }
@@ -445,7 +446,7 @@ function log$2(variable, value) {
     }
 }
 function compute$9() {
-    encode$1(34 /* Event.Variable */);
+    encode$1(34 /* Variable */);
 }
 function reset$l() {
     data$e = {};
@@ -465,7 +466,7 @@ var variable = /*#__PURE__*/Object.freeze({
     stop: stop$v
 });
 
-/******************************************************************************
+/*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -518,7 +519,7 @@ function __generator(thisArg, body) {
     }
 }
 
-var supported$1 = "CompressionStream" /* Constant.CompressionStream */ in window;
+var supported$1 = "CompressionStream" /* CompressionStream */ in window;
 function compress (input) {
     return __awaiter(this, void 0, void 0, function () {
         var stream, _a;
@@ -535,7 +536,7 @@ function compress (input) {
                                     return [2 /*return*/];
                                 });
                             });
-                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* Constant.CompressionStream */]("gzip"));
+                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* CompressionStream */]("gzip"));
                     _a = Uint8Array.bind;
                     return [4 /*yield*/, read(stream)];
                 case 1: return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _c.sent()]))()];
@@ -609,11 +610,11 @@ function scrub (value, hint, privacy, mangle) {
     if (mangle === void 0) { mangle = false; }
     if (value) {
         switch (privacy) {
-            case 0 /* Privacy.None */:
+            case 0 /* None */:
                 return value;
-            case 1 /* Privacy.Sensitive */:
+            case 1 /* Sensitive */:
                 switch (hint) {
-                    case "*T" /* Layout.Constant.TextTag */:
+                    case "*T" /* TextTag */:
                     case "value":
                     case "placeholder":
                     case "click":
@@ -621,16 +622,16 @@ function scrub (value, hint, privacy, mangle) {
                         return redact(value);
                 }
                 return value;
-            case 2 /* Privacy.Text */:
-            case 3 /* Privacy.TextImage */:
+            case 2 /* Text */:
+            case 3 /* TextImage */:
                 switch (hint) {
-                    case "*T" /* Layout.Constant.TextTag */:
+                    case "*T" /* TextTag */:
                         return mangle ? mangleText(value) : mask(value);
                     case "src":
                     case "srcset":
                     case "title":
                     case "alt":
-                        return privacy === 3 /* Privacy.TextImage */ ? "" /* Data.Constant.Empty */ : value;
+                        return privacy === 3 /* TextImage */ ? "" /* Empty */ : value;
                     case "value":
                     case "click":
                     case "input":
@@ -650,18 +651,18 @@ function mangleText(value) {
         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 "" + prefix + trimmed.length.toString(36) + suffix;
     }
     return value;
 }
 function mask(value) {
-    return value.replace(catchallRegex, "\u2022" /* Data.Constant.Mask */);
+    return value.replace(catchallRegex, "\u2022" /* Mask */);
 }
 function mangleToken(value) {
-    var length = ((Math.floor(value.length / 5 /* Data.Setting.WordLength */) + 1) * 5 /* Data.Setting.WordLength */);
-    var output = "" /* Layout.Constant.Empty */;
+    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 /* Data.Setting.WordLength */ === 0 ? " " /* Data.Constant.Space */ : "\u2022" /* Data.Constant.Mask */;
+        output += i > 0 && i % 5 /* WordLength */ === 0 ? " " /* Space */ : "\u2022" /* Mask */;
     }
     return output;
 }
@@ -686,22 +687,22 @@ function redact(value) {
     }
     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 */;
+        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("" /* Data.Constant.Empty */);
+                    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, "\u2022" /* Data.Constant.Letter */).replace(digitRegex, "\u2022" /* Data.Constant.Digit */);
+                    token = token.match(currencyRegex) ? token : token.replace(letterRegex, "\u25AA" /* Letter */).replace(digitRegex, "\u25AB" /* Digit */);
                 }
                 else {
                     token = mask(token);
@@ -718,28 +719,28 @@ function redact(value) {
             }
         }
     }
-    return array ? array.join("" /* Data.Constant.Empty */) : value;
+    return array ? array.join("" /* Empty */) : value;
 }
 
 var history$5 = [];
 var data$d;
 function start$x() {
     history$5 = [];
-    max(26 /* Metric.Automation */, navigator.webdriver ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */);
+    max(26 /* Automation */, navigator.webdriver ? 1 /* True */ : 0 /* False */);
 }
 function check$4(id, target, input) {
     // Compute hash for fraud detection. Hash is computed only if input meets the minimum length criteria
-    if (id !== null && input && input.length >= 5 /* Setting.WordLength */) {
+    if (id !== null && input && input.length >= 5 /* WordLength */) {
         data$d = { id: id, target: target, hash: hash(input) };
         // Only encode this event if we haven't already reported this hash
         if (history$5.indexOf(data$d.hash) < 0) {
             history$5.push(data$d.hash);
-            encode$2(41 /* Event.Fraud */);
+            encode$2(41 /* Fraud */);
         }
     }
 }
 
-var excludeClassNames = "load,active,fixed,visible,focus,show,collaps,animat" /* Constant.ExcludeClassNames */.split("," /* Constant.Comma */);
+var excludeClassNames = "load,active,fixed,visible,focus,show,collaps,animat" /* ExcludeClassNames */.split("," /* Comma */);
 var selectorMap = {};
 function reset$k() {
     selectorMap = {};
@@ -747,68 +748,68 @@ function reset$k() {
 function get$1(input, type) {
     var a = input.attributes;
     var prefix = input.prefix ? input.prefix[type] : null;
-    var suffix = type === 0 /* Selector.Alpha */ ? "".concat("~" /* Constant.Tilde */).concat(input.position - 1) : ":nth-of-type(".concat(input.position, ")");
+    var suffix = type === 0 /* Alpha */ ? "" + "~" /* Tilde */ + (input.position - 1) : ":nth-of-type(" + input.position + ")";
     switch (input.tag) {
         case "STYLE":
         case "TITLE":
         case "LINK":
         case "META":
-        case "*T" /* Constant.TextTag */:
-        case "*D" /* Constant.DocumentTag */:
-            return "" /* Constant.Empty */;
+        case "*T" /* TextTag */:
+        case "*D" /* DocumentTag */:
+            return "" /* Empty */;
         case "HTML":
-            return "HTML" /* Constant.HTML */;
+            return "HTML" /* HTML */;
         default:
             if (prefix === null) {
-                return "" /* Constant.Empty */;
+                return "" /* Empty */;
             }
-            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;
+            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;
             if (classes && classes.length > 0) {
-                if (type === 0 /* Selector.Alpha */) {
+                if (type === 0 /* 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 = "".concat(getDomPath(prefix)).concat(input.tag).concat("." /* Constant.Dot */).concat(classes);
+                    var key = "" + getDomPath(prefix) + input.tag + "." /* Dot */ + classes;
                     if (!(key in selectorMap)) {
                         selectorMap[key] = [];
                     }
                     if (selectorMap[key].indexOf(input.id) < 0) {
                         selectorMap[key].push(input.id);
                     }
-                    selector = "".concat(key).concat("~" /* Constant.Tilde */).concat(selectorMap[key].indexOf(input.id));
+                    selector = "" + key + "~" /* Tilde */ + selectorMap[key].indexOf(input.id);
                 }
                 else {
                     // In Beta mode, we continue to look at query selectors in context of the full page
-                    selector = "".concat(prefix).concat(input.tag, ".").concat(classes).concat(suffix);
+                    selector = "" + prefix + input.tag + "." + classes + 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) ? "".concat(getDomPrefix(prefix)).concat("#" /* Constant.Hash */).concat(id) : selector;
+            selector = id && filter(id) ? "" + getDomPrefix(prefix) + "#" /* Hash */ + id : selector;
             return selector;
     }
 }
 function getDomPrefix(prefix) {
-    var shadowDomStart = prefix.lastIndexOf("*S" /* Constant.ShadowDomTag */);
-    var iframeDomStart = prefix.lastIndexOf("".concat("iframe:" /* Constant.IFramePrefix */).concat("HTML" /* Constant.HTML */));
+    var shadowDomStart = prefix.lastIndexOf("*S" /* ShadowDomTag */);
+    var iframeDomStart = prefix.lastIndexOf("" + "iframe:" /* IFramePrefix */ + "HTML" /* HTML */);
     var domStart = Math.max(shadowDomStart, iframeDomStart);
     if (domStart < 0) {
-        return "" /* Constant.Empty */;
+        return "" /* Empty */;
     }
-    return prefix.substring(0, prefix.indexOf(">" /* Constant.Separator */, domStart) + 1);
+    return prefix.substring(0, prefix.indexOf(">" /* Separator */, domStart) + 1);
 }
 function getDomPath(input) {
-    var parts = input.split(">" /* Constant.Separator */);
+    var parts = input.split(">" /* Separator */);
     for (var i = 0; i < parts.length; i++) {
-        var tIndex = parts[i].indexOf("~" /* Constant.Tilde */);
-        var dIndex = parts[i].indexOf("." /* Constant.Dot */);
+        var tIndex = parts[i].indexOf("~" /* Tilde */);
+        var dIndex = parts[i].indexOf("." /* Dot */);
         parts[i] = parts[i].substring(0, dIndex > 0 ? dIndex : (tIndex > 0 ? tIndex : parts[i].length));
     }
-    return parts.join(">" /* Constant.Separator */);
+    return parts.join(">" /* Separator */);
 }
 // Check if the given input string has digits or excluded class names
 function filter(value) {
@@ -820,7 +821,7 @@ function filter(value) {
     }
     for (var i = 0; i < value.length; i++) {
         var c = value.charCodeAt(i);
-        if (c >= 48 /* Character.Zero */ && c <= 57 /* Character.Nine */) {
+        if (c >= 48 /* Zero */ && c <= 57 /* Nine */) {
             return false;
         }
     }
@@ -863,7 +864,7 @@ function reset$j() {
     pauseTask = null;
 }
 function schedule$1(task, priority) {
-    if (priority === void 0) { priority = 0 /* Priority.Normal */; }
+    if (priority === void 0) { priority = 0 /* Normal */; }
     return __awaiter(this, void 0, void 0, function () {
         var _i, queuedTasks_1, q, promise;
         return __generator(this, function (_a) {
@@ -875,7 +876,7 @@ function schedule$1(task, priority) {
                 }
             }
             promise = new Promise(function (resolve) {
-                var insert = priority === 1 /* Priority.High */ ? "unshift" : "push";
+                var insert = priority === 1 /* High */ ? "unshift" : "push";
                 // Queue this task for asynchronous execution later
                 // We also store a unique page identifier (id) along with the task to ensure
                 // ensure that we do not accidentally execute this task in context of a different page
@@ -910,7 +911,7 @@ function run() {
                 return;
             }
             if (error) {
-                log$1(0 /* Code.RunTask */, 1 /* Severity.Warning */, error.name, error.message, error.stack);
+                log$1(0 /* RunTask */, 1 /* Warning */, error.name, error.message, error.stack);
             }
             activeTask = null;
             run();
@@ -921,13 +922,13 @@ function state$8(timer) {
     var id = key(timer);
     if (id in tracker) {
         var elapsed = performance.now() - tracker[id].start;
-        return (elapsed > tracker[id].yield) ? 0 /* Task.Wait */ : 1 /* Task.Run */;
+        return (elapsed > tracker[id].yield) ? 0 /* Wait */ : 1 /* Run */;
     }
     // If this task is no longer being tracked, send stop message to the caller
-    return 2 /* Task.Stop */;
+    return 2 /* Stop */;
 }
 function start$w(timer) {
-    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* Setting.LongTask */ };
+    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
 }
 function restart$2(timer) {
     var id = key(timer);
@@ -944,11 +945,11 @@ function stop$t(timer) {
     var id = key(timer);
     var duration = end - tracker[id].start;
     sum(timer.cost, duration);
-    count$1(5 /* Metric.InvokeCount */);
+    count$1(5 /* InvokeCount */);
     // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
     // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
     if (tracker[id].calls > 0) {
-        sum(4 /* Metric.TotalCost */, duration);
+        sum(4 /* TotalCost */, duration);
     }
 }
 function suspend$1(timer) {
@@ -969,13 +970,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 /* Task.Run */ : 2 /* Task.Stop */];
+                return [2 /*return*/, id in tracker ? 1 /* Run */ : 2 /* Stop */];
             }
         });
     });
 }
 function key(timer) {
-    return "".concat(timer.id, ".").concat(timer.cost);
+    return timer.id + "." + timer.cost;
 }
 function wait() {
     return __awaiter(this, void 0, void 0, function () {
@@ -1013,14 +1014,14 @@ function requestIdleCallbackPolyfill(callback, options) {
         var currentTime = performance.now();
         var elapsed = currentTime - startTime;
         var duration = currentTime - event.data;
-        if (duration > 30 /* Setting.LongTask */ && elapsed < options.timeout) {
+        if (duration > 30 /* LongTask */ && elapsed < options.timeout) {
             requestAnimationFrame(function () { outgoing.postMessage(currentTime); });
         }
         else {
             var didTimeout_1 = elapsed > options.timeout;
             callback({
                 didTimeout: didTimeout_1,
-                timeRemaining: function () { return didTimeout_1 ? 30 /* Setting.LongTask */ : Math.max(0, 30 /* Setting.LongTask */ - duration); }
+                timeRemaining: function () { return didTimeout_1 ? 30 /* LongTask */ : Math.max(0, 30 /* LongTask */ - duration); }
             });
         }
     };
@@ -1041,7 +1042,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" /* Constant.String */) {
+        if (typeof tokens[i] === "string" /* String */) {
             var token = tokens[i];
             var index = lookup[token] || -1;
             if (index >= 0) {
@@ -1083,10 +1084,10 @@ function encode$4 (type, timer, ts) {
                     tokens = [eventTime, type];
                     _a = type;
                     switch (_a) {
-                        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];
+                        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];
                     }
                     return [3 /*break*/, 10];
                 case 1:
@@ -1099,7 +1100,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 /* Event.Region */];
+                        tokens = [r.time, 7 /* Region */];
                         tokens.push(r.data.id);
                         tokens.push(r.data.interaction);
                         tokens.push(r.data.visibility);
@@ -1110,7 +1111,7 @@ function encode$4 (type, timer, ts) {
                     return [3 /*break*/, 10];
                 case 3:
                     // Check if we are operating within the context of the current page
-                    if (state$8(timer) === 2 /* Task.Stop */) {
+                    if (state$8(timer) === 2 /* Stop */) {
                         return [3 /*break*/, 10];
                     }
                     values = updates$2();
@@ -1121,13 +1122,13 @@ function encode$4 (type, timer, ts) {
                     if (!(_c < values_1.length)) return [3 /*break*/, 8];
                     value = values_1[_c];
                     state = state$8(timer);
-                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 6];
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 6];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 5:
                     state = _e.sent();
                     _e.label = 6;
                 case 6:
-                    if (state === 2 /* Task.Stop */) {
+                    if (state === 2 /* Stop */) {
                         return [3 /*break*/, 8];
                     }
                     data = value.data;
@@ -1150,9 +1151,9 @@ function encode$4 (type, timer, ts) {
                                     if (value.previous && active) {
                                         tokens.push(value.previous);
                                     }
-                                    tokens.push(suspend ? "*M" /* Constant.SuspendMutationTag */ : data[key]);
+                                    tokens.push(suspend ? "*M" /* SuspendMutationTag */ : data[key]);
                                     if (box && box.length === 2) {
-                                        tokens.push("".concat("#" /* Constant.Hash */).concat(str$1(box[0]), ".").concat(str$1(box[1])));
+                                        tokens.push("" + "#" /* Hash */ + str$1(box[0]) + "." + str$1(box[1]));
                                     }
                                     break;
                                 case "attributes":
@@ -1174,7 +1175,7 @@ function encode$4 (type, timer, ts) {
                     _c++;
                     return [3 /*break*/, 4];
                 case 8:
-                    if (type === 6 /* Event.Mutation */) {
+                    if (type === 6 /* Mutation */) {
                         activity(eventTime);
                     }
                     queue(tokenize(tokens), !config$1.lean);
@@ -1187,13 +1188,13 @@ function encode$4 (type, timer, ts) {
 }
 function shouldMangle(value) {
     var privacy = value.metadata.privacy;
-    return value.data.tag === "*T" /* Constant.TextTag */ && !(privacy === 0 /* Privacy.None */ || privacy === 1 /* Privacy.Sensitive */);
+    return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
 }
 function size$1(value) {
     if (value.metadata.size !== null && value.metadata.size.length === 0) {
         var img = getNode(value.id);
         if (img) {
-            return [Math.floor(img.offsetWidth * 100 /* Setting.BoxPrecision */), Math.floor(img.offsetHeight * 100 /* Setting.BoxPrecision */)];
+            return [Math.floor(img.offsetWidth * 100 /* BoxPrecision */), Math.floor(img.offsetHeight * 100 /* BoxPrecision */)];
         }
     }
     return value.metadata.size;
@@ -1202,7 +1203,7 @@ function str$1(input) {
     return input.toString(36);
 }
 function attribute(key, value, privacy) {
-    return "".concat(key, "=").concat(scrub(value, key, privacy));
+    return key + "=" + scrub(value, key, privacy);
 }
 
 var data$c;
@@ -1233,7 +1234,7 @@ 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 /* Event.Document */);
+        encode$4(8 /* Document */);
     }
 }
 function end() {
@@ -1262,7 +1263,7 @@ function start$u() {
     reset$h();
 }
 function observe$b(root) {
-    bind(root, "click", handler$3.bind(this, 9 /* Event.Click */, root), true);
+    bind(root, "click", handler$3.bind(this, 9 /* Click */, root), true);
 }
 function handler$3(event, root, evt) {
     var frame = iframe(root);
@@ -1288,14 +1289,13 @@ 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 /* Setting.ClickPrecision */), 0) : 0;
-    var eY = l ? Math.max(Math.floor(((y - l.y) / l.h) * 32767 /* Setting.ClickPrecision */), 0) : 0;
+    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;
     // Check for null values before processing this event
     if (x !== null && y !== null) {
         state$7.push({
             time: time(),
-            event: event,
-            data: {
+            event: event, data: {
                 target: t,
                 x: x,
                 y: y,
@@ -1307,7 +1307,7 @@ function handler$3(event, root, evt) {
                 text: text(t),
                 link: a ? a.href : null,
                 hash: null,
-                trust: evt.isTrusted ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */
+                trust: evt.isTrusted ? 1 /* True */ : 0 /* False */
             }
         });
         schedule$1(encode$3.bind(this, event));
@@ -1322,7 +1322,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, " " /* Constant.Space */).substr(0, 25 /* Setting.ClickText */);
+            output = t.trim().replace(/\s+/g, " " /* Space */).substr(0, 25 /* ClickText */);
         }
     }
     return output;
@@ -1331,10 +1331,10 @@ function reaction(element) {
     if (element.nodeType === Node.ELEMENT_NODE) {
         var tag = element.tagName.toLowerCase();
         if (UserInputTags.indexOf(tag) >= 0) {
-            return 0 /* BooleanFlag.False */;
+            return 0 /* False */;
         }
     }
-    return 1 /* BooleanFlag.True */;
+    return 1 /* True */;
 }
 function layout$1(element) {
     var box = null;
@@ -1358,14 +1358,14 @@ function layout$1(element) {
     return box;
 }
 function context(a) {
-    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 */;
+    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 */;
         }
     }
-    return 0 /* BrowsingContext.Self */;
+    return 0 /* Self */;
 }
 function reset$h() {
     state$7 = [];
@@ -1379,13 +1379,13 @@ function start$t() {
     reset$g();
 }
 function observe$a(root) {
-    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);
+    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);
 }
 function recompute$7(action, evt) {
-    state$6.push({ time: time(), event: 38 /* Event.Clipboard */, data: { target: target(evt), action: action } });
-    schedule$1(encode$3.bind(this, 38 /* Event.Clipboard */));
+    state$6.push({ time: time(), event: 38 /* Clipboard */, data: { target: target(evt), action: action } });
+    schedule$1(encode$3.bind(this, 38 /* Clipboard */));
 }
 function reset$g() {
     state$6 = [];
@@ -1418,9 +1418,9 @@ function recompute$6(evt) {
         if (state$5.length > 0 && (state$5[state$5.length - 1].data.target === data.target)) {
             state$5.pop();
         }
-        state$5.push({ time: time(), event: 27 /* Event.Input */, data: data });
+        state$5.push({ time: time(), event: 27 /* Input */, data: data });
         clearTimeout(timeout$5);
-        timeout$5 = setTimeout(process$6, 500 /* Setting.LookAhead */, 27 /* Event.Input */);
+        timeout$5 = setTimeout(process$6, 500 /* LookAhead */, 27 /* Input */);
     }
 }
 function process$6(event) {
@@ -1440,15 +1440,15 @@ function start$r() {
     reset$e();
 }
 function observe$8(root) {
-    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);
+    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);
 }
 function mouse(event, root, evt) {
     var frame = iframe(root);
@@ -1487,9 +1487,9 @@ function touch(event, root, evt) {
 }
 function handler$2(current) {
     switch (current.event) {
-        case 12 /* Event.MouseMove */:
-        case 15 /* Event.MouseWheel */:
-        case 19 /* Event.TouchMove */:
+        case 12 /* MouseMove */:
+        case 15 /* MouseWheel */:
+        case 19 /* TouchMove */:
             var length_1 = state$4.length;
             var last = length_1 > 1 ? state$4[length_1 - 2] : null;
             if (last && similar$1(last, current)) {
@@ -1497,7 +1497,7 @@ function handler$2(current) {
             }
             state$4.push(current);
             clearTimeout(timeout$4);
-            timeout$4 = setTimeout(process$5, 500 /* Setting.LookAhead */, current.event);
+            timeout$4 = setTimeout(process$5, 500 /* LookAhead */, current.event);
             break;
         default:
             state$4.push(current);
@@ -1517,7 +1517,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 /* Setting.Distance */ && gap < 25 /* Setting.Interval */;
+    return current.event === last.event && match && distance < 20 /* Distance */ && gap < 25 /* Interval */;
 }
 function stop$p() {
     clearTimeout(timeout$4);
@@ -1540,7 +1540,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 /* Event.Resize */);
+    encode$3(11 /* Resize */);
 }
 function reset$d() {
     data$b = null;
@@ -1576,7 +1576,7 @@ function recompute$4(event) {
     // And, if for some reason that is not available, fall back to looking up scrollTop on document.documentElement.
     var x = element === de && "pageXOffset" in w ? Math.round(w.pageXOffset) : Math.round(element.scrollLeft);
     var y = element === de && "pageYOffset" in w ? Math.round(w.pageYOffset) : Math.round(element.scrollTop);
-    var current = { time: time(), event: 10 /* Event.Scroll */, data: { target: element, x: x, y: y } };
+    var current = { time: time(), event: 10 /* 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;
@@ -1588,7 +1588,7 @@ function recompute$4(event) {
     }
     state$3.push(current);
     clearTimeout(timeout$3);
-    timeout$3 = setTimeout(process$4, 500 /* Setting.LookAhead */, 10 /* Event.Scroll */);
+    timeout$3 = setTimeout(process$4, 500 /* LookAhead */, 10 /* Scroll */);
 }
 function reset$c() {
     state$3 = [];
@@ -1599,7 +1599,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 /* Setting.Distance */ * 20 /* Setting.Distance */) && (current.time - last.time < 25 /* Setting.Interval */);
+    return (dx * dx + dy * dy < 20 /* Distance */ * 20 /* Distance */) && (current.time - last.time < 25 /* Interval */);
 }
 function stop$n() {
     clearTimeout(timeout$3);
@@ -1634,7 +1634,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 /* Event.Selection */);
+        process$3(21 /* Selection */);
     }
     data$a = {
         start: current.anchorNode,
@@ -1644,7 +1644,7 @@ function recompute$3(root) {
     };
     previous = current;
     clearTimeout(timeout$2);
-    timeout$2 = setTimeout(process$3, 500 /* Setting.LookAhead */, 21 /* Event.Selection */);
+    timeout$2 = setTimeout(process$3, 500 /* LookAhead */, 21 /* Selection */);
 }
 function process$3(event) {
     schedule$1(encode$3.bind(this, event));
@@ -1666,8 +1666,8 @@ function observe$5(root) {
     bind(root, "submit", recompute$2, true);
 }
 function recompute$2(evt) {
-    state$2.push({ time: time(), event: 39 /* Event.Submit */, data: { target: target(evt) } });
-    schedule$1(encode$3.bind(this, 39 /* Event.Submit */));
+    state$2.push({ time: time(), event: 39 /* Submit */, data: { target: target(evt) } });
+    schedule$1(encode$3.bind(this, 39 /* Submit */));
 }
 function reset$a() {
     state$2 = [];
@@ -1682,7 +1682,7 @@ function start$m() {
 }
 function recompute$1(evt) {
     data$9 = { name: evt.type };
-    encode$3(26 /* Event.Unload */);
+    encode$3(26 /* Unload */);
     stop();
 }
 function reset$9() {
@@ -1699,7 +1699,7 @@ function start$l() {
 }
 function recompute() {
     data$8 = { visible: "visibilityState" in document ? document.visibilityState : "default" };
-    encode$3(28 /* Event.Visibility */);
+    encode$3(28 /* Visibility */);
 }
 function reset$8() {
     data$8 = null;
@@ -1761,51 +1761,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" /* JsonLD.Type */ && typeof value === "string") {
+        if (key === "@type" /* Type */ && typeof value === "string") {
             value = value.toLowerCase();
             /* Normalizations */
-            value = value.indexOf("article" /* JsonLD.Article */) >= 0 || value.indexOf("posting" /* JsonLD.Posting */) >= 0 ? "article" /* JsonLD.Article */ : value;
+            value = value.indexOf("article" /* Article */) >= 0 || value.indexOf("posting" /* Posting */) >= 0 ? "article" /* Article */ : value;
             switch (value) {
-                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 */]);
+                case "article" /* Article */:
+                case "recipe" /* Recipe */:
+                    log(5 /* SchemaType */, json[key]);
+                    log(8 /* AuthorName */, json["creator" /* Creator */]);
+                    log(18 /* Headline */, json["headline" /* Headline */]);
                     break;
-                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 */]);
+                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 */]);
                     }
                     break;
-                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 */]));
+                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 */]));
                     }
-                    max(12 /* Metric.RatingCount */, num$1(json["ratingCount" /* JsonLD.RatingCount */]));
-                    max(17 /* Metric.ReviewCount */, num$1(json["reviewCount" /* JsonLD.ReviewCount */]));
+                    max(12 /* RatingCount */, num$1(json["ratingCount" /* RatingCount */]));
+                    max(17 /* ReviewCount */, num$1(json["reviewCount" /* ReviewCount */]));
                     break;
-                case "person" /* JsonLD.Author */:
-                    log(8 /* Dimension.AuthorName */, json["name" /* JsonLD.Name */]);
+                case "person" /* Author */:
+                    log(8 /* AuthorName */, json["name" /* Name */]);
                     break;
-                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 */]));
+                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 */]));
                     break;
-                case "brand" /* JsonLD.Brand */:
-                    log(6 /* Dimension.ProductBrand */, json["name" /* JsonLD.Name */]);
+                case "brand" /* Brand */:
+                    log(6 /* ProductBrand */, json["name" /* Name */]);
                     break;
             }
         }
         // Continue parsing nested objects
-        if (value !== null && typeof (value) === "object" /* Constant.Object */) {
+        if (value !== null && typeof (value) === "object" /* Object */) {
             ld(value);
         }
     }
@@ -1814,8 +1814,8 @@ function num$1(input, scale) {
     if (scale === void 0) { scale = 1; }
     if (input !== null) {
         switch (typeof input) {
-            case "number" /* Constant.Number */: return Math.round(input * scale);
-            case "string" /* Constant.String */: return Math.round(parseFloat(input.replace(digitsRegex, "" /* Constant.Empty */)) * scale);
+            case "number" /* Number */: return Math.round(input * scale);
+            case "string" /* String */: return Math.round(parseFloat(input.replace(digitsRegex, "" /* Empty */)) * scale);
         }
     }
     return null;
@@ -1826,11 +1826,11 @@ var newlineRegex = /[\r\n]+/g;
 function processNode (node, source) {
     var child = null;
     // Do not track this change if we are attempting to remove a node before discovering it
-    if (source === 2 /* Source.ChildListRemove */ && has(node) === false) {
+    if (source === 2 /* ChildListRemove */ && has(node) === false) {
         return child;
     }
     // Special handling for text nodes that belong to style nodes
-    if (source !== 0 /* Source.Discover */ &&
+    if (source !== 0 /* Discover */ &&
         node.nodeType === Node.TEXT_NODE &&
         node.parentElement &&
         node.parentElement.tagName === "STYLE") {
@@ -1843,10 +1843,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:" /* Constant.IFramePrefix */ : "" /* Constant.Empty */;
+            var docTypePrefix = insideFrame ? "iframe:" /* IFramePrefix */ : "" /* Empty */;
             var doctype = node;
             var docAttributes = { name: doctype.name, publicId: doctype.publicId, systemId: doctype.systemId };
-            var docData = { tag: docTypePrefix + "*D" /* Constant.DocumentTag */, attributes: docAttributes };
+            var docData = { tag: docTypePrefix + "*D" /* DocumentTag */, attributes: docAttributes };
             dom[call](node, parent, docData, source);
             break;
         case Node.DOCUMENT_NODE:
@@ -1861,26 +1861,26 @@ function processNode (node, source) {
             if (shadowRoot.host) {
                 parse$1(shadowRoot);
                 var type = typeof (shadowRoot.constructor);
-                if (type === "function" /* Constant.Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* Constant.NativeCode */) >= 0) {
+                if (type === "function" /* Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* 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 = "" /* Constant.Empty */;
+                    var style = "" /* 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" /* Constant.ShadowDomTag */, attributes: { style: style } };
+                    var fragementData = { tag: "*S" /* 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" /* Constant.PolyfillShadowDomTag */, attributes: {} }, source);
+                    dom[call](node, shadowRoot.host, { tag: "*P" /* PolyfillShadowDomTag */, attributes: {} }, source);
                 }
             }
             break;
@@ -1893,7 +1893,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" /* Constant.TextTag */, value: node.nodeValue };
+                var textData = { tag: "*T" /* TextTag */, value: node.nodeValue };
                 dom[call](node, parent, textData, source);
             }
             break;
@@ -1905,20 +1905,20 @@ 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" /* Constant.SvgNamespace */) {
-                tag = "svg:" /* Constant.SvgPrefix */ + tag;
+            if (element.namespaceURI === "http://www.w3.org/2000/svg" /* SvgNamespace */) {
+                tag = "svg:" /* SvgPrefix */ + tag;
             }
             switch (tag) {
                 case "HTML":
                     parent = insideFrame && parent ? iframe(parent) : null;
-                    var htmlPrefix = insideFrame ? "iframe:" /* Constant.IFramePrefix */ : "" /* Constant.Empty */;
+                    var htmlPrefix = insideFrame ? "iframe:" /* IFramePrefix */ : "" /* Empty */;
                     var htmlData = { tag: htmlPrefix + tag, attributes: attributes };
                     dom[call](node, parent, htmlData, source);
                     break;
                 case "SCRIPT":
-                    if ("type" /* Constant.Type */ in attributes && attributes["type" /* Constant.Type */] === "application/ld+json" /* Constant.JsonLD */) {
+                    if ("type" /* Type */ in attributes && attributes["type" /* Type */] === "application/ld+json" /* JsonLD */) {
                         try {
-                            ld(JSON.parse(element.text.replace(newlineRegex, "" /* Constant.Empty */)));
+                            ld(JSON.parse(element.text.replace(newlineRegex, "" /* Empty */)));
                         }
                         catch ( /* do nothing */_a) { /* do nothing */ }
                     }
@@ -1926,20 +1926,20 @@ function processNode (node, source) {
                 case "NOSCRIPT":
                     break;
                 case "META":
-                    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 */];
+                    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 */];
                         switch (attributes[key]) {
-                            case "og:title" /* Constant.ogTitle */:
-                                log(20 /* Dimension.MetaTitle */, content);
+                            case "og:title" /* ogTitle */:
+                                log(20 /* MetaTitle */, content);
                                 break;
-                            case "og:type" /* Constant.ogType */:
-                                log(19 /* Dimension.MetaType */, content);
+                            case "og:type" /* ogType */:
+                                log(19 /* MetaType */, content);
                                 break;
-                            case "generator" /* Constant.Generator */:
-                                log(21 /* Dimension.Generator */, content);
+                            case "generator" /* Generator */:
+                                log(21 /* Generator */, content);
                                 break;
                         }
                     }
@@ -1947,7 +1947,7 @@ function processNode (node, source) {
                 case "HEAD":
                     var head = { tag: tag, attributes: attributes };
                     if (location) {
-                        head.attributes["*B" /* Constant.Base */] = location.protocol + "//" + location.hostname;
+                        head.attributes["*B" /* Base */] = location.protocol + "//" + location.hostname;
                     }
                     dom[call](node, parent, head, source);
                     break;
@@ -1960,7 +1960,7 @@ function processNode (node, source) {
                     var frameData = { tag: tag, attributes: attributes };
                     if (sameorigin(iframe$1)) {
                         monitor(iframe$1);
-                        frameData.attributes["*O" /* Constant.SameOrigin */] = "true";
+                        frameData.attributes["*O" /* SameOrigin */] = "true";
                         if (iframe$1.contentDocument && iframe$1.contentWindow && iframe$1.contentDocument.readyState !== "loading") {
                             child = iframe$1.contentDocument;
                         }
@@ -1989,7 +1989,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() : "" /* Constant.Empty */;
+    var value = style.textContent ? style.textContent.trim() : "" /* Empty */;
     var dataset = style.dataset ? Object.keys(style.dataset).length : 0;
     if (value.length === 0 || dataset > 0) {
         value = getCssRules(style.sheet);
@@ -1997,14 +1997,14 @@ function getStyleValue(style) {
     return value;
 }
 function getCssRules(sheet) {
-    var value = "" /* Constant.Empty */;
+    var value = "" /* 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 /* Code.CssRules */, 1 /* Severity.Warning */, e ? e.name : null);
+        log$1(1 /* CssRules */, 1 /* Warning */, e ? e.name : null);
         if (e && e.name !== "SecurityError") {
             throw e;
         }
@@ -2028,8 +2028,8 @@ function getAttributes(element) {
         }
     }
     // For INPUT tags read the dynamic "value" property if an explicit "value" attribute is not set
-    if (element.tagName === "INPUT" /* Constant.InputTag */ && !("value" /* Constant.Value */ in output) && element.value) {
-        output["value" /* Constant.Value */] = element.value;
+    if (element.tagName === "INPUT" /* InputTag */ && !("value" /* Value */ in output) && element.value) {
+        output["value" /* Value */] = element.value;
     }
     return output;
 }
@@ -2051,13 +2051,13 @@ function traverse (root, timer, source) {
                         next = next.nextSibling;
                     }
                     state = state$8(timer);
-                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 3];
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 3];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 2:
                     state = _a.sent();
                     _a.label = 3;
                 case 3:
-                    if (state === 2 /* Task.Stop */) {
+                    if (state === 2 /* Stop */) {
                         return [3 /*break*/, 4];
                     }
                     subnode = processNode(node, source);
@@ -2134,7 +2134,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" /* Constant.MutationObserver */);
+        var m = api("MutationObserver" /* 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 });
@@ -2142,7 +2142,7 @@ function observe$2(node) {
         }
     }
     catch (e) {
-        log$1(2 /* Code.MutationObserver */, 0 /* Severity.Info */, e ? e.name : null);
+        log$1(2 /* MutationObserver */, 0 /* Info */, e ? e.name : null);
     }
 }
 function monitor(frame) {
@@ -2150,7 +2150,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" /* Constant.LoadEvent */, generate.bind(this, frame, "childList" /* Constant.ChildList */), true);
+        bind(frame, "load" /* LoadEvent */, generate.bind(this, frame, "childList" /* ChildList */), true);
     }
 }
 function stop$h() {
@@ -2168,14 +2168,14 @@ function stop$h() {
     timeout$1 = null;
 }
 function active$2() {
-    activePeriod = time() + 3000 /* Setting.MutationActivePeriod */;
+    activePeriod = time() + 3000 /* MutationActivePeriod */;
 }
 function handle$1(m) {
     // Queue up mutation records for asynchronous processing
     var now = time();
-    track$6(6 /* Event.Mutation */, now);
+    track$6(6 /* Mutation */, now);
     mutations.push({ time: now, mutations: m });
-    schedule$1(process$2, 1 /* Priority.High */).then(function () {
+    schedule$1(process$2, 1 /* High */).then(function () {
         setTimeout(compute$7);
         measure(compute$6)();
     });
@@ -2186,7 +2186,7 @@ function process$2() {
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
+                    timer = { id: id(), cost: 3 /* LayoutCost */ };
                     start$w(timer);
                     _b.label = 1;
                 case 1:
@@ -2198,13 +2198,13 @@ function process$2() {
                     if (!(_i < _a.length)) return [3 /*break*/, 6];
                     mutation = _a[_i];
                     state = state$8(timer);
-                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
                     state = _b.sent();
                     _b.label = 4;
                 case 4:
-                    if (state === 2 /* Task.Stop */) {
+                    if (state === 2 /* Stop */) {
                         return [3 /*break*/, 6];
                     }
                     target = mutation.target;
@@ -2216,17 +2216,17 @@ function process$2() {
                         parse$1(target);
                     }
                     switch (type) {
-                        case "attributes" /* Constant.Attributes */:
-                            processNode(target, 3 /* Source.Attributes */);
+                        case "attributes" /* Attributes */:
+                            processNode(target, 3 /* Attributes */);
                             break;
-                        case "characterData" /* Constant.CharacterData */:
-                            processNode(target, 4 /* Source.CharacterData */);
+                        case "characterData" /* CharacterData */:
+                            processNode(target, 4 /* CharacterData */);
                             break;
-                        case "childList" /* Constant.ChildList */:
-                            processNodeList(mutation.addedNodes, 1 /* Source.ChildListAdd */, timer);
-                            processNodeList(mutation.removedNodes, 2 /* Source.ChildListRemove */, timer);
+                        case "childList" /* ChildList */:
+                            processNodeList(mutation.addedNodes, 1 /* ChildListAdd */, timer);
+                            processNodeList(mutation.removedNodes, 2 /* ChildListRemove */, timer);
                             break;
-                        case "suspend" /* Constant.Suspend */:
+                        case "suspend" /* Suspend */:
                             value = get(target);
                             if (value) {
                                 value.metadata.suspend = true;
@@ -2237,7 +2237,7 @@ function process$2() {
                 case 5:
                     _i++;
                     return [3 /*break*/, 2];
-                case 6: return [4 /*yield*/, encode$4(6 /* Event.Mutation */, timer, record.time)];
+                case 6: return [4 /*yield*/, encode$4(6 /* Mutation */, timer, record.time)];
                 case 7:
                     _b.sent();
                     return [3 /*break*/, 1];
@@ -2251,11 +2251,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" /* Constant.HTML */) {
+    if (value && value.data.tag !== "HTML" /* 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() : "" /* Constant.Empty */;
+        var parent_1 = value.selector ? value.selector.join() : "" /* 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
@@ -2264,20 +2264,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 /* Setting.MutationSuspendThreshold */) {
-            processNodeList(h[1], 2 /* Source.ChildListRemove */, timer);
+        if (inactive === false && h[0] >= 10 /* MutationSuspendThreshold */) {
+            processNodeList(h[1], 2 /* 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 /* Setting.MutationSuspendThreshold */) {
+        if (h[0] === 10 /* 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" /* Constant.Suspend */;
+            return "suspend" /* Suspend */;
         }
-        else if (h[0] > 10 /* Setting.MutationSuspendThreshold */) {
-            return "" /* Constant.Empty */;
+        else if (h[0] > 10 /* MutationSuspendThreshold */) {
+            return "" /* Empty */;
         }
     }
     return m.type;
@@ -2300,18 +2300,18 @@ function processNodeList(list, source, timer) {
                     _a.label = 1;
                 case 1:
                     if (!(i < length)) return [3 /*break*/, 6];
-                    if (!(source === 1 /* Source.ChildListAdd */)) return [3 /*break*/, 2];
+                    if (!(source === 1 /* ChildListAdd */)) return [3 /*break*/, 2];
                     traverse(list[i], timer, source);
                     return [3 /*break*/, 5];
                 case 2:
                     state = state$8(timer);
-                    if (!(state === 0 /* Task.Wait */)) return [3 /*break*/, 4];
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 4];
                     return [4 /*yield*/, suspend$1(timer)];
                 case 3:
                     state = _a.sent();
                     _a.label = 4;
                 case 4:
-                    if (state === 2 /* Task.Stop */) {
+                    if (state === 2 /* Stop */) {
                         return [3 /*break*/, 6];
                     }
                     processNode(list[i], source);
@@ -2336,7 +2336,7 @@ function schedule(node, fragment) {
     if (timeout$1) {
         clearTimeout(timeout$1);
     }
-    timeout$1 = setTimeout(function () { trigger$1(fragment); }, 33 /* Setting.LookAhead */);
+    timeout$1 = setTimeout(function () { trigger$1(fragment); }, 33 /* LookAhead */);
     return node;
 }
 function trigger$1(fragment) {
@@ -2349,7 +2349,7 @@ function trigger$1(fragment) {
             if (shadowRoot && has(node)) {
                 continue;
             }
-            generate(node, shadowRoot || fragment ? "childList" /* Constant.ChildList */ : "characterData" /* Constant.CharacterData */);
+            generate(node, shadowRoot || fragment ? "childList" /* ChildList */ : "characterData" /* CharacterData */);
         }
     }
     queue$2 = [];
@@ -2399,9 +2399,9 @@ function reset$7() {
     hashMap = {};
     override = [];
     unmask = [];
-    maskText = "address,password,contact" /* Mask.Text */.split("," /* Constant.Comma */);
-    maskInput = "password,secret,pass,social,ssn,name,code,dob,cell,mob,contact,hidden,account,cvv,ccv,email,tel,phone,address,addr,card,zip" /* Mask.Input */.split("," /* Constant.Comma */);
-    maskDisable = "radio,checkbox,range,button,reset,submit" /* Mask.Disable */.split("," /* Constant.Comma */);
+    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 */);
     idMap = new WeakMap();
     iframeMap = new WeakMap();
     privacyMap = new WeakMap();
@@ -2417,19 +2417,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("!" /* Constant.Bang */) < 0 ? unmask.push(x) : override.push(x.substr(1)); });
+            config$1.unmask.forEach(function (x) { return x.indexOf("!" /* Bang */) < 0 ? unmask.push(x) : override.push(x.substr(1)); });
         }
         // Since mutations may happen on leaf nodes too, e.g. text nodes, which may not support all selector APIs.
         // We ensure that the root note supports querySelectorAll API before executing the code below to identify new regions.
         if ("querySelectorAll" in root) {
-            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.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 /* Privacy.None */); }); }); // Unmasked Elements
+            unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* None */); }); }); // Unmasked Elements
         }
     }
     catch (e) {
-        log$1(5 /* Code.Selector */, 1 /* Severity.Warning */, e ? e.name : null);
+        log$1(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
     }
 }
 function getId(node, autogen) {
@@ -2452,7 +2452,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 /* Privacy.Sensitive */ : 2 /* Privacy.Text */;
+    var privacyId = config$1.content ? 1 /* Sensitive */ : 3 /* TextImage */;
     if (parentId >= 0 && values[parentId]) {
         parentValue = values[parentId];
         parentValue.children.push(id);
@@ -2462,8 +2462,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" /* Constant.RegionData */ in data.attributes) {
-        observe$1(node, data.attributes["data-clarity-region" /* Constant.RegionData */]);
+    if (data.attributes && "data-clarity-region" /* RegionData */ in data.attributes) {
+        observe$1(node, data.attributes["data-clarity-region" /* RegionData */]);
         regionId = id;
     }
     nodes[id] = node;
@@ -2541,7 +2541,7 @@ function update$1(node, parent, data, source) {
 }
 function sameorigin(node) {
     var output = false;
-    if (node.nodeType === Node.ELEMENT_NODE && node.tagName === "IFRAME" /* Constant.IFrameTag */) {
+    if (node.nodeType === Node.ELEMENT_NODE && node.tagName === "IFRAME" /* 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.
@@ -2568,11 +2568,11 @@ function privacy(node, value, parent) {
     var attributes = data.attributes || {};
     var tag = data.tag.toUpperCase();
     switch (true) {
-        case "data-clarity-mask" /* Constant.MaskData */ in attributes:
-            metadata.privacy = 3 /* Privacy.TextImage */;
+        case "data-clarity-mask" /* MaskData */ in attributes:
+            metadata.privacy = 3 /* TextImage */;
             break;
-        case "data-clarity-unmask" /* Constant.UnmaskData */ in attributes:
-            metadata.privacy = 0 /* Privacy.None */;
+        case "data-clarity-unmask" /* UnmaskData */ in attributes:
+            metadata.privacy = 0 /* None */;
             break;
         case privacyMap.has(node):
             // If this node was explicitly configured to contain sensitive content, honor that privacy setting
@@ -2580,40 +2580,38 @@ 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 /* Privacy.Text */;
+            metadata.privacy = 2 /* Text */;
             break;
-        case tag === "*T" /* Constant.TextTag */:
+        case tag === "*T" /* TextTag */:
             // If it's a text node belonging to a STYLE or TITLE tag or one of scrub exceptions, then capture content
-            var pTag = parent && parent.data ? parent.data.tag : "" /* 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;
+            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 "type" /* Constant.Type */ in attributes:
-            // If this node has an explicit type assigned to it, go through masking rules to determine right privacy setting
-            metadata.privacy = inspect(attributes["type" /* Constant.Type */], maskInput, metadata);
-            break;
-        case tag === "INPUT" /* Constant.InputTag */ && current === 0 /* Privacy.None */:
+        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 = "" /* Constant.Empty */;
+            var field_1 = "" /* Empty */;
             Object.keys(attributes).forEach(function (x) { return field_1 += attributes[x].toLowerCase(); });
             metadata.privacy = inspect(field_1, maskInput, metadata);
             break;
-        case current === 1 /* Privacy.Sensitive */ && tag === "INPUT" /* Constant.InputTag */:
+        case tag === "INPUT" /* InputTag */ && current === 1 /* Sensitive */:
             // Look through class names to aggressively mask content
-            metadata.privacy = inspect(attributes["class" /* Constant.Class */], maskText, metadata);
-            // If it's a button or an input option, make an exception to disable masking
-            metadata.privacy = maskDisable.indexOf(attributes["type" /* Constant.Type */]) >= 0 ? 0 /* Privacy.None */ : current;
+            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 /* Privacy.Sensitive */:
+        case current === 1 /* Sensitive */:
             // In a mode where we mask sensitive information by default, look through class names to aggressively mask content
-            metadata.privacy = inspect(attributes["class" /* Constant.Class */], maskText, metadata);
+            metadata.privacy = inspect(attributes["class" /* Class */], maskText, metadata);
             break;
     }
 }
 function inspect(input, lookup, metadata) {
     if (input && lookup.some(function (x) { return input.indexOf(x) >= 0; })) {
-        return 2 /* Privacy.Text */;
+        return 2 /* Text */;
     }
     return metadata.privacy;
 }
@@ -2651,7 +2649,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 /* Selector.Alpha */), get$1(s, 1 /* Selector.Beta */)];
+    value.selector = [get$1(s, 0 /* Alpha */), get$1(s, 1 /* 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
@@ -2706,7 +2704,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" /* Constant.ImageTag */ && value.metadata.privacy === 3 /* Privacy.TextImage */) {
+    if (value.data.tag === "IMG" /* ImageTag */ && value.metadata.privacy === 3 /* TextImage */) {
         value.metadata.size = [];
     }
 }
@@ -2741,7 +2739,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 /* Source.ChildListAdd */ && parentChanged) {
+    if (uIndex >= 0 && source === 1 /* ChildListAdd */ && parentChanged) {
         updateMap.splice(uIndex, 1);
         updateMap.push(id);
     }
@@ -2787,15 +2785,15 @@ function exists(node) {
 }
 function track$3(id, event) {
     var node = getNode(id);
-    var data = id in regions ? regions[id] : { id: id, visibility: 0 /* RegionVisibility.Rendered */, interaction: 16 /* InteractionState.None */, name: regionMap.get(node) };
+    var data = id in regions ? regions[id] : { id: id, visibility: 0 /* Rendered */, interaction: 16 /* None */, name: regionMap.get(node) };
     // Determine the interaction state based on incoming event
-    var interaction = 16 /* InteractionState.None */;
+    var interaction = 16 /* None */;
     switch (event) {
-        case 9 /* Event.Click */:
-            interaction = 20 /* InteractionState.Clicked */;
+        case 9 /* Click */:
+            interaction = 20 /* Clicked */;
             break;
-        case 27 /* Event.Input */:
-            interaction = 30 /* InteractionState.Input */;
+        case 27 /* Input */:
+            interaction = 30 /* Input */;
             break;
     }
     // Process updates to this region, if applicable
@@ -2823,7 +2821,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 /* Event.Region */);
+        encode$4(7 /* Region */);
     }
 }
 function handler$1(entries) {
@@ -2839,27 +2837,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 /* InteractionState.None */, visibility: 0 /* RegionVisibility.Rendered */ };
+            var data = id in regions ? regions[id] : { id: id, name: regionMap.get(target), interaction: 16 /* None */, visibility: 0 /* 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 /* Setting.ViewportIntersectionRatio */ || entry.intersectionRatio > 0.8 /* Setting.IntersectionRatio */;
+            var visible = viewportRatio > 0.05 /* ViewportIntersectionRatio */ || entry.intersectionRatio > 0.8 /* 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 /* RegionVisibility.Visible */) && Math.abs(rect.top) + viewport.height > rect.height;
+            var scrolledToEnd = (visible || data.visibility == 10 /* Visible */) && Math.abs(rect.top) + viewport.height > rect.height;
             // Process updates to this region, if applicable
             process$1(target, data, data.interaction, (scrolledToEnd ?
-                13 /* RegionVisibility.ScrolledToEnd */ :
-                (visible ? 10 /* RegionVisibility.Visible */ : 0 /* RegionVisibility.Rendered */)));
+                13 /* ScrolledToEnd */ :
+                (visible ? 10 /* Visible */ : 0 /* Rendered */)));
             // Stop observing this element now that we have already received scrolled signal
-            if (data.visibility >= 13 /* RegionVisibility.ScrolledToEnd */ && observer$1) {
+            if (data.visibility >= 13 /* ScrolledToEnd */ && observer$1) {
                 observer$1.unobserve(target);
             }
         }
     }
     if (state$1.length > 0) {
-        encode$4(7 /* Event.Region */);
+        encode$4(7 /* Region */);
     }
 }
 function process$1(n, d, s, v) {
@@ -2918,7 +2916,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 /* Privacy.Text */, node: node };
+    var output = { id: 0, hash: null, privacy: 2 /* Text */, node: node };
     if (node) {
         var value = get(node);
         if (value !== null) {
@@ -2944,15 +2942,15 @@ function encode$3 (type) {
             t = time();
             tokens = [t, type];
             switch (type) {
-                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 */:
+                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 */:
                     for (_i = 0, _a = state$4; _i < _a.length; _i++) {
                         entry = _a[_i];
                         pTarget = metadata$2(entry.data.target, entry.event);
@@ -2967,12 +2965,12 @@ function encode$3 (type) {
                     }
                     reset$e();
                     break;
-                case 9 /* Event.Click */:
+                case 9 /* 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("." /* Constant.Dot */);
+                        cHash = cTarget.hash.join("." /* Dot */);
                         tokens.push(cTarget.id);
                         tokens.push(entry.data.x);
                         tokens.push(entry.data.y);
@@ -2990,7 +2988,7 @@ function encode$3 (type) {
                     }
                     reset$h();
                     break;
-                case 38 /* Event.Clipboard */:
+                case 38 /* Clipboard */:
                     for (_d = 0, _e = state$6; _d < _e.length; _d++) {
                         entry = _e[_d];
                         tokens = [entry.time, entry.event];
@@ -3003,7 +3001,7 @@ function encode$3 (type) {
                     }
                     reset$g();
                     break;
-                case 11 /* Event.Resize */:
+                case 11 /* Resize */:
                     r = data$b;
                     tokens.push(r.width);
                     tokens.push(r.height);
@@ -3011,13 +3009,13 @@ function encode$3 (type) {
                     reset$d();
                     queue(tokens);
                     break;
-                case 26 /* Event.Unload */:
+                case 26 /* Unload */:
                     u = data$9;
                     tokens.push(u.name);
                     reset$9();
                     queue(tokens);
                     break;
-                case 27 /* Event.Input */:
+                case 27 /* 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);
@@ -3028,7 +3026,7 @@ function encode$3 (type) {
                     }
                     reset$f();
                     break;
-                case 21 /* Event.Selection */:
+                case 21 /* Selection */:
                     s = data$a;
                     if (s) {
                         startTarget = metadata$2(s.start, type);
@@ -3041,7 +3039,7 @@ function encode$3 (type) {
                         queue(tokens);
                     }
                     break;
-                case 10 /* Event.Scroll */:
+                case 10 /* Scroll */:
                     for (_h = 0, _j = state$3; _h < _j.length; _h++) {
                         entry = _j[_h];
                         sTarget = metadata$2(entry.data.target, entry.event);
@@ -3056,7 +3054,7 @@ function encode$3 (type) {
                     }
                     reset$c();
                     break;
-                case 39 /* Event.Submit */:
+                case 39 /* Submit */:
                     for (_k = 0, _l = state$2; _k < _l.length; _k++) {
                         entry = _l[_k];
                         tokens = [entry.time, entry.event];
@@ -3068,7 +3066,7 @@ function encode$3 (type) {
                     }
                     reset$a();
                     break;
-                case 22 /* Event.Timeline */:
+                case 22 /* Timeline */:
                     for (_m = 0, _o = updates$1; _m < _o.length; _m++) {
                         entry = _o[_m];
                         tokens = [entry.time, entry.event];
@@ -3082,7 +3080,7 @@ function encode$3 (type) {
                     }
                     reset$5();
                     break;
-                case 28 /* Event.Visibility */:
+                case 28 /* Visibility */:
                     v = data$8;
                     tokens.push(v.visible);
                     queue(tokens);
@@ -3105,11 +3103,11 @@ function reset$5() {
     updates$1 = [];
 }
 function track$2(time, event, hash, x, y, reaction, context) {
-    if (reaction === void 0) { reaction = 1 /* BooleanFlag.True */; }
-    if (context === void 0) { context = 0 /* BrowsingContext.Self */; }
+    if (reaction === void 0) { reaction = 1 /* True */; }
+    if (context === void 0) { context = 0 /* Self */; }
     state.push({
         time: time,
-        event: 22 /* Event.Timeline */,
+        event: 22 /* Timeline */,
         data: {
             type: event,
             hash: hash,
@@ -3128,7 +3126,7 @@ function compute$5() {
     var temp = [];
     updates$1 = [];
     var max = data$1.start + data$1.duration;
-    var min = Math.max(max - 2000 /* Setting.TimelineSpan */, 0);
+    var min = Math.max(max - 2000 /* TimelineSpan */, 0);
     for (var _i = 0, state_1 = state; _i < state_1.length; _i++) {
         var s = state_1[_i];
         if (s.time >= min) {
@@ -3139,7 +3137,7 @@ function compute$5() {
         }
     }
     state = temp; // Drop events less than the min time
-    encode$3(22 /* Event.Timeline */);
+    encode$3(22 /* Timeline */);
 }
 function stop$e() {
     state = [];
@@ -3172,10 +3170,10 @@ function queue(tokens, transmit) {
         var type = tokens.length > 1 ? tokens[1] : null;
         var event_1 = JSON.stringify(tokens);
         switch (type) {
-            case 5 /* Event.Discover */:
+            case 5 /* Discover */:
                 discoverBytes += event_1.length;
-            case 37 /* Event.Box */:
-            case 6 /* Event.Mutation */:
+            case 37 /* Box */:
+            case 6 /* Mutation */:
                 playbackBytes += event_1.length;
                 playback.push(event_1);
                 break;
@@ -3184,7 +3182,7 @@ function queue(tokens, transmit) {
                 break;
         }
         // Increment event count metric
-        count$1(25 /* Metric.EventCount */);
+        count$1(25 /* 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.
@@ -3197,7 +3195,7 @@ 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 /* Event.Ping */) {
+            if (type !== 25 /* Ping */) {
                 reset$n();
             }
             timeout = setTimeout(upload, gap);
@@ -3226,9 +3224,9 @@ function upload(final) {
             switch (_b.label) {
                 case 0:
                     timeout = null;
-                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* Setting.MaxFirstPayloadBytes */ || data$1.sequence > 0);
+                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* MaxFirstPayloadBytes */ || data$1.sequence > 0);
                     if (sendPlaybackBytes) {
-                        max(1 /* Metric.Playback */, 1 /* BooleanFlag.True */);
+                        max(1 /* Playback */, 1 /* True */);
                     }
                     // CAUTION: Ensure "transmit" is set to false in the queue function for following events
                     // Otherwise you run a risk of infinite loop.
@@ -3237,8 +3235,8 @@ function upload(final) {
                     compute$8();
                     last = final === true;
                     e = JSON.stringify(envelope(last));
-                    a = "[".concat(analysis.join(), "]");
-                    p = sendPlaybackBytes ? "[".concat(playback.join(), "]") : "" /* Constant.Empty */;
+                    a = "[" + analysis.join() + "]";
+                    p = sendPlaybackBytes ? "[" + playback.join() + "]" : "" /* Empty */;
                     encoded = { e: e, a: a, p: p };
                     payload = stringify(encoded);
                     if (!last) return [3 /*break*/, 1];
@@ -3250,7 +3248,7 @@ function upload(final) {
                     _b.label = 3;
                 case 3:
                     zipped = _a;
-                    sum(2 /* Metric.TotalBytes */, zipped ? zipped.length : payload.length);
+                    sum(2 /* TotalBytes */, zipped ? zipped.length : payload.length);
                     send(payload, zipped, data$1.sequence, last);
                     // Clear out events now that payload has been dispatched
                     analysis = [];
@@ -3265,12 +3263,12 @@ function upload(final) {
     });
 }
 function stringify(encoded) {
-    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, "}");
+    return encoded.p.length > 0 ? "{\"e\":" + encoded.e + ",\"a\":" + encoded.a + ",\"p\":" + encoded.p + "}" : "{\"e\":" + encoded.e + ",\"a\":" + 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" /* Constant.String */) {
+    if (typeof config$1.upload === "string" /* String */) {
         var url = config$1.upload;
         var dispatched = false;
         // If it's the last payload, attempt to upload using sendBeacon first.
@@ -3309,7 +3307,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" /* Constant.Accept */, "application/x-clarity-gzip" /* Constant.ClarityGzip */);
+                xhr_1.setRequestHeader("Accept" /* Accept */, "application/x-clarity-gzip" /* ClarityGzip */);
                 xhr_1.send(zipped);
             }
             else {
@@ -3326,13 +3324,13 @@ function send(payload, zipped, sequence, beacon) {
 }
 function check$3(xhr, sequence) {
     var transitData = transit[sequence];
-    if (xhr && xhr.readyState === 4 /* XMLReadyState.Done */ && transitData) {
+    if (xhr && xhr.readyState === 4 /* Done */ && transitData) {
         // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
-        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* Setting.RetryLimit */) {
+        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* RetryLimit */) {
             // We re-attempt in all cases except when server explicitly rejects our request with 4XX error
             if (xhr.status >= 400 && xhr.status < 500) {
                 // In case of a 4XX response from the server, we bail out instead of trying again
-                trigger(6 /* Check.Server */);
+                trigger(6 /* Server */);
             }
             else {
                 // Browser will send status = 0 when it refuses to put network request over the wire
@@ -3353,7 +3351,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 /* Event.Upload */);
+                encode$1(2 /* Upload */);
             }
             // Handle response if it was a 200 response with a valid body
             if (xhr.status === 200 && xhr.responseText) {
@@ -3364,7 +3362,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 /* Check.Retry */);
+                trigger(3 /* Retry */);
             }
             // Signal that this request completed successfully
             if (xhr.status >= 200 && xhr.status <= 208) {
@@ -3384,19 +3382,25 @@ 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 /* 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;
+    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* MinUploadDelay */ : data$1.sequence * config$1.delay;
+    return typeof config$1.upload === "string" /* String */ ? Math.max(Math.min(gap, 30000 /* MaxUploadDelay */), 100 /* MinUploadDelay */) : config$1.delay;
 }
 function response(payload) {
-    var key = payload && payload.length > 0 ? payload.split(" ")[0] : "" /* Constant.Empty */;
-    switch (key) {
-        case "END" /* Constant.End */:
+    var parts = payload && payload.length > 0 ? payload.split(" ") : ["" /* Empty */];
+    switch (parts[0]) {
+        case "END" /* End */:
             // Clear out session storage and end the session so we can start fresh the next time
-            trigger(6 /* Check.Server */);
+            trigger(6 /* Server */);
             break;
-        case "UPGRADE" /* Constant.Upgrade */:
+        case "UPGRADE" /* Upgrade */:
             // Upgrade current session to send back playback information
-            upgrade("Auto" /* Constant.Auto */);
+            upgrade("Auto" /* Auto */);
+            break;
+        case "ACTION" /* Action */:
+            // Invoke action callback, if configured and has a valid value
+            if (config$1.action && parts.length > 1) {
+                config$1.action(parts[1]);
+            }
             break;
     }
 }
@@ -3414,7 +3418,7 @@ function handler(error) {
     if (!(e.message in history$3)) {
         history$3[e.message] = 0;
     }
-    if (history$3[e.message]++ >= 5 /* Setting.ScriptErrorLimit */) {
+    if (history$3[e.message]++ >= 5 /* ScriptErrorLimit */) {
         return true;
     }
     // Send back information only if the handled error has valid information
@@ -3426,7 +3430,7 @@ function handler(error) {
             stack: e.stack,
             source: error["filename"]
         };
-        encode$2(31 /* Event.ScriptError */);
+        encode$2(31 /* ScriptError */);
     }
     return true;
 }
@@ -3437,7 +3441,7 @@ function encode$2 (type) {
         return __generator(this, function (_a) {
             tokens = [time(), type];
             switch (type) {
-                case 31 /* Event.ScriptError */:
+                case 31 /* ScriptError */:
                     tokens.push(data$7.message);
                     tokens.push(data$7.line);
                     tokens.push(data$7.column);
@@ -3445,7 +3449,7 @@ function encode$2 (type) {
                     tokens.push(data$7.source);
                     queue(tokens);
                     break;
-                case 33 /* Event.Log */:
+                case 33 /* Log */:
                     if (data$6) {
                         tokens.push(data$6.code);
                         tokens.push(data$6.name);
@@ -3455,7 +3459,7 @@ function encode$2 (type) {
                         queue(tokens, false);
                     }
                     break;
-                case 41 /* Event.Fraud */:
+                case 41 /* Fraud */:
                     if (data$d) {
                         tokens.push(data$d.id);
                         tokens.push(data$d.target);
@@ -3478,7 +3482,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 ? "".concat(name, "|").concat(message) : "";
+    var key = name ? name + "|" + message : "";
     // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
     // In those cases, we only want to log the failure once and not spam logs with redundant information.
     if (code in history$2 && history$2[code].indexOf(key) >= 0) {
@@ -3492,7 +3496,7 @@ function log$1(code, severity, name, message, stack) {
     else {
         history$2[code] = [key];
     }
-    encode$2(33 /* Event.Log */);
+    encode$2(33 /* Log */);
 }
 function stop$c() {
     history$2 = {};
@@ -3513,25 +3517,25 @@ function start$c() {
             var source = e[i];
             var key = e[i + 1];
             switch (source) {
-                case 0 /* ExtractSource.Javascript */:
+                case 0 /* Javascript */:
                     var variable = e[i + 2];
                     variables[key] = parse(variable);
                     break;
-                case 1 /* ExtractSource.Cookie */:
+                case 1 /* Cookie */:
                     /*Todo: Add cookie extract logic*/
                     break;
-                case 2 /* ExtractSource.Text */:
+                case 2 /* Text */:
                     var match_1 = e[i + 2];
                     selectors[key] = match_1;
                     break;
-                case 3 /* ExtractSource.Fragment */:
+                case 3 /* Fragment */:
                     fragments = e[i + 2];
                     break;
             }
         }
     }
     catch (e) {
-        log$1(8 /* Code.Config */, 1 /* Severity.Warning */, e ? e.name : null);
+        log$1(8 /* Config */, 1 /* Warning */, e ? e.name : null);
     }
 }
 function clone(v) {
@@ -3553,9 +3557,9 @@ function compute$4() {
         }
     }
     catch (e) {
-        log$1(5 /* Code.Selector */, 1 /* Severity.Warning */, e ? e.name : null);
+        log$1(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
     }
-    encode$1(40 /* Event.Extract */);
+    encode$1(40 /* Extract */);
 }
 function reset$4() {
     keys = [];
@@ -3575,15 +3579,15 @@ function stop$b() {
 }
 function parse(variable) {
     var syntax = [];
-    var parts = variable.split("." /* Constant.Dot */);
+    var parts = variable.split("." /* Dot */);
     while (parts.length > 0) {
         var part = parts.shift();
-        var arrayStart = part.indexOf("[" /* Constant.ArrayStart */);
-        var conditionStart = part.indexOf("{" /* Constant.ConditionStart */);
-        var conditionEnd = part.indexOf("}" /* Constant.ConditionEnd */);
+        var arrayStart = part.indexOf("[" /* ArrayStart */);
+        var conditionStart = part.indexOf("{" /* ConditionStart */);
+        var conditionEnd = part.indexOf("}" /* ConditionEnd */);
         syntax.push({
             name: arrayStart > 0 ? part.substring(0, arrayStart) : (conditionStart > 0 ? part.substring(0, conditionStart) : part),
-            type: arrayStart > 0 ? 1 /* Type.Array */ : (conditionStart > 0 ? 2 /* Type.Object */ : 3 /* Type.Simple */),
+            type: arrayStart > 0 ? 1 /* Array */ : (conditionStart > 0 ? 2 /* Object */ : 3 /* Simple */),
             condition: conditionStart > 0 ? part.substring(conditionStart + 1, conditionEnd) : null
         });
     }
@@ -3601,7 +3605,7 @@ function evaluate(variable, base) {
     var output;
     if (base && base[part.name]) {
         var obj = base[part.name];
-        if (part.type !== 1 /* Type.Array */ && match(obj, part.condition)) {
+        if (part.type !== 1 /* Array */ && match(obj, part.condition)) {
             output = evaluate(variable, obj);
         }
         else if (Array.isArray(obj)) {
@@ -3623,7 +3627,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 /* Setting.ExtractLimit */) : input;
+    return input ? JSON.stringify(input).substring(0, 10000 /* ExtractLimit */) : input;
 }
 function match(base, condition) {
     if (condition) {
@@ -3637,7 +3641,7 @@ function encode$1 (event) {
     var t = time();
     var tokens = [t, event];
     switch (event) {
-        case 4 /* Event.Baseline */:
+        case 4 /* Baseline */:
             var b = state$9;
             if (b) {
                 tokens = [b.time, b.event];
@@ -3655,30 +3659,30 @@ function encode$1 (event) {
             }
             reset$p();
             break;
-        case 25 /* Event.Ping */:
+        case 25 /* Ping */:
             tokens.push(data$h.gap);
             queue(tokens);
             break;
-        case 35 /* Event.Limit */:
+        case 35 /* Limit */:
             tokens.push(data$4.check);
             queue(tokens, false);
             break;
-        case 3 /* Event.Upgrade */:
+        case 3 /* Upgrade */:
             tokens.push(data$f.key);
             queue(tokens);
             break;
-        case 2 /* Event.Upload */:
+        case 2 /* Upload */:
             tokens.push(track$1.sequence);
             tokens.push(track$1.attempts);
             tokens.push(track$1.status);
             queue(tokens, false);
             break;
-        case 24 /* Event.Custom */:
+        case 24 /* Custom */:
             tokens.push(data$j.key);
             tokens.push(data$j.value);
             queue(tokens);
             break;
-        case 34 /* Event.Variable */:
+        case 34 /* Variable */:
             var variableKeys = Object.keys(data$e);
             if (variableKeys.length > 0) {
                 for (var _i = 0, variableKeys_1 = variableKeys; _i < variableKeys_1.length; _i++) {
@@ -3690,7 +3694,7 @@ function encode$1 (event) {
                 queue(tokens, false);
             }
             break;
-        case 0 /* Event.Metric */:
+        case 0 /* Metric */:
             var metricKeys = Object.keys(updates$3);
             if (metricKeys.length > 0) {
                 for (var _a = 0, metricKeys_1 = metricKeys; _a < metricKeys_1.length; _a++) {
@@ -3705,7 +3709,7 @@ function encode$1 (event) {
                 queue(tokens, false);
             }
             break;
-        case 1 /* Event.Dimension */:
+        case 1 /* Dimension */:
             var dimensionKeys = Object.keys(updates);
             if (dimensionKeys.length > 0) {
                 for (var _b = 0, dimensionKeys_1 = dimensionKeys; _b < dimensionKeys_1.length; _b++) {
@@ -3718,7 +3722,7 @@ function encode$1 (event) {
                 queue(tokens, false);
             }
             break;
-        case 36 /* Event.Summary */:
+        case 36 /* Summary */:
             var eventKeys = Object.keys(data$g);
             if (eventKeys.length > 0) {
                 for (var _c = 0, eventKeys_1 = eventKeys; _c < eventKeys_1.length; _c++) {
@@ -3731,7 +3735,7 @@ function encode$1 (event) {
                 queue(tokens, false);
             }
             break;
-        case 40 /* Event.Extract */:
+        case 40 /* Extract */:
             var extractKeys = keys;
             for (var _d = 0, extractKeys_1 = extractKeys; _d < extractKeys_1.length; _d++) {
                 var e = extractKeys_1[_d];
@@ -3745,14 +3749,14 @@ function encode$1 (event) {
 
 var data$4;
 function start$b() {
-    data$4 = { check: 0 /* Check.None */ };
+    data$4 = { check: 0 /* None */ };
 }
 function check$2(bytes) {
-    if (data$4.check === 0 /* Check.None */) {
+    if (data$4.check === 0 /* None */) {
         var reason = data$4.check;
-        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;
+        reason = data$1.sequence >= 128 /* PayloadLimit */ ? 1 /* Payload */ : reason;
+        reason = time() > 7200000 /* ShutdownLimit */ ? 2 /* Shutdown */ : reason;
+        reason = bytes > 10485760 /* PlaybackBytesLimit */ ? 2 /* Shutdown */ : reason;
         if (reason !== data$4.check) {
             trigger(reason);
         }
@@ -3764,8 +3768,8 @@ function trigger(reason) {
     stop();
 }
 function compute$3() {
-    if (data$4.check !== 0 /* Check.None */) {
-        encode$1(35 /* Event.Limit */);
+    if (data$4.check !== 0 /* None */) {
+        encode$1(35 /* Limit */);
     }
 }
 function stop$a() {
@@ -3786,7 +3790,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 = "".concat(value);
+        value = "" + value;
         if (!(dimension in data$3)) {
             data$3[dimension] = [];
         }
@@ -3799,14 +3803,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 /* Setting.CollectionLimit */) {
-                trigger(5 /* Check.Collection */);
+            if (data$3[dimension].length > 128 /* CollectionLimit */) {
+                trigger(5 /* Collection */);
             }
         }
     }
 }
 function compute$2() {
-    encode$1(1 /* Event.Dimension */);
+    encode$1(1 /* Dimension */);
 }
 function reset$3() {
     updates = {};
@@ -3817,8 +3821,8 @@ var callbacks = [];
 var rootDomain = null;
 function start$9() {
     rootDomain = null;
-    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Constant.Empty */;
-    var title = document && document.title ? document.title : "" /* Constant.Empty */;
+    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Empty */;
+    var title = document && document.title ? document.title : "" /* Empty */;
     // Populate ids for this page
     var s = session();
     var u = user();
@@ -3829,27 +3833,27 @@ function start$9() {
         pageNum: s.count
     };
     // Override configuration based on what's in the session storage, unless it is blank (e.g. using upload callback, like in devtools)
-    config$1.lean = config$1.track && s.upgrade !== null ? s.upgrade === 0 /* BooleanFlag.False */ : config$1.lean;
-    config$1.upload = config$1.track && typeof config$1.upload === "string" /* Constant.String */ && s.upload && s.upload.length > "https://" /* Constant.HTTPS */.length ? s.upload : config$1.upload;
+    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 /* Dimension.UserAgent */, ua);
-    log(3 /* Dimension.PageTitle */, title);
-    log(1 /* Dimension.Url */, 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(0 /* UserAgent */, ua);
+    log(3 /* PageTitle */, title);
+    log(1 /* Url */, location.href);
+    log(2 /* Referrer */, document.referrer);
+    log(15 /* TabId */, tab());
+    log(16 /* PageLanguage */, document.documentElement.lang);
+    log(17 /* DocumentDirection */, document.dir);
     if (navigator) {
-        log(9 /* Dimension.Language */, navigator.userLanguage || navigator.language);
+        log(9 /* Language */, navigator.userLanguage || navigator.language);
         userAgentData();
     }
     // Metrics
-    max(0 /* Metric.ClientTimestamp */, s.ts);
-    max(1 /* Metric.Playback */, 0 /* BooleanFlag.False */);
+    max(0 /* ClientTimestamp */, s.ts);
+    max(1 /* Playback */, 0 /* False */);
     if (screen) {
-        max(14 /* Metric.ScreenWidth */, Math.round(screen.width));
-        max(15 /* Metric.ScreenHeight */, Math.round(screen.height));
-        max(16 /* Metric.ColorDepth */, Math.round(screen.colorDepth));
+        max(14 /* ScreenWidth */, Math.round(screen.width));
+        max(15 /* ScreenHeight */, Math.round(screen.height));
+        max(16 /* ColorDepth */, Math.round(screen.colorDepth));
     }
     // Read cookies specified in configuration
     for (var _i = 0, _a = config$1.cookies; _i < _a.length; _i++) {
@@ -3870,13 +3874,13 @@ function userAgentData() {
             "uaFullVersion"])
             .then(function (ua) {
             var _a;
-            log(22 /* Dimension.Platform */, ua.platform);
-            log(23 /* Dimension.PlatformVersion */, ua.platformVersion);
+            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 /* Dimension.Brand */, brand.name + "~" /* Constant.Tilde */ + brand.version);
+                log(24 /* Brand */, brand.name + "~" /* Tilde */ + brand.version);
             });
-            log(25 /* Dimension.Model */, ua.model);
-            max(27 /* Metric.Mobile */, ua.mobile ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */);
+            log(25 /* Model */, ua.model);
+            max(27 /* Mobile */, ua.mobile ? 1 /* True */ : 0 /* False */);
         });
     }
 }
@@ -3893,33 +3897,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("." /* Constant.Dot */) : "" /* Constant.Empty */;
+    return data$2 ? [data$2.userId, data$2.sessionId, data$2.pageNum].join("." /* Dot */) : "" /* Empty */;
 }
 function consent() {
     if (active()) {
         config$1.track = true;
-        track(user(), 1 /* BooleanFlag.True */);
+        track(user(), 1 /* True */);
     }
 }
 function clear() {
     // Clear any stored information in the cookie that tracks session information so we can restart fresh the next time
-    setCookie("_clsk" /* Constant.SessionKey */, "" /* Constant.Empty */, 0);
+    setCookie("_clsk" /* SessionKey */, "" /* Empty */, 0);
 }
 function tab() {
     var id = shortid();
-    if (config$1.track && supported(window, "sessionStorage" /* Constant.SessionStorage */)) {
-        var value = sessionStorage.getItem("_cltk" /* Constant.TabKey */);
+    if (config$1.track && supported(window, "sessionStorage" /* SessionStorage */)) {
+        var value = sessionStorage.getItem("_cltk" /* TabKey */);
         id = value ? value : id;
-        sessionStorage.setItem("_cltk" /* Constant.TabKey */, id);
+        sessionStorage.setItem("_cltk" /* TabKey */, id);
     }
     return id;
 }
 function save() {
     var ts = Math.round(Date.now());
-    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 */;
+    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 */;
     processCallback(upgrade);
-    setCookie("_clsk" /* Constant.SessionKey */, [data$2.sessionId, ts, data$2.pageNum, upgrade, upload].join("|" /* Constant.Pipe */), 1 /* Setting.SessionExpire */);
+    setCookie("_clsk" /* SessionKey */, [data$2.sessionId, ts, data$2.pageNum, upgrade, upload].join("|" /* Pipe */), 1 /* SessionExpire */);
 }
 function processCallback(upgrade) {
     if (callbacks.length > 0) {
@@ -3944,10 +3948,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 /* Setting.Expire */ * 86400000 /* Time.Day */)) / 86400000 /* Time.Day */);
+    var end = Math.ceil((Date.now() + (365 /* Expire */ * 86400000 /* Day */)) / 86400000 /* Day */);
     // To avoid cookie churn, write user id cookie only once every day
-    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* 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 */);
+    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* CookieInterval */ || u.consent !== consent) {
+        setCookie("_clck" /* CookieKey */, [data$2.userId, 1 /* CookieVersion */, end.toString(36), consent].join("|" /* Pipe */), 365 /* Expire */);
     }
 }
 function shortid() {
@@ -3958,17 +3962,17 @@ function shortid() {
     return id.toString(36);
 }
 function session() {
-    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Constant.Empty */ };
-    var value = getCookie("_clsk" /* Constant.SessionKey */);
+    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Empty */ };
+    var value = getCookie("_clsk" /* SessionKey */);
     if (value) {
-        var parts = value.split("|" /* Constant.Pipe */);
+        var parts = value.split("|" /* Pipe */);
         // Making it backward & forward compatible by using greater than comparison (v0.6.21)
         // In future version, we can reduce the parts length to be 5 where the last part contains the full upload URL
-        if (parts.length >= 5 && output.ts - num(parts[1]) < 1800000 /* Setting.SessionTimeout */) {
+        if (parts.length >= 5 && output.ts - num(parts[1]) < 1800000 /* SessionTimeout */) {
             output.session = parts[0];
             output.count = num(parts[2]) + 1;
             output.upgrade = num(parts[3]);
-            output.upload = parts.length >= 6 ? "".concat("https://" /* Constant.HTTPS */).concat(parts[5], "/").concat(parts[4]) : "".concat("https://" /* Constant.HTTPS */).concat(parts[4]);
+            output.upload = parts.length >= 6 ? "" + "https://" /* HTTPS */ + parts[5] + "/" + parts[4] : "" + "https://" /* HTTPS */ + parts[4];
         }
     }
     return output;
@@ -3978,26 +3982,26 @@ function num(string, base) {
     return parseInt(string, base);
 }
 function user() {
-    var output = { id: shortid(), expiry: null, consent: 0 /* BooleanFlag.False */ };
-    var cookie = getCookie("_clck" /* Constant.CookieKey */);
+    var output = { id: shortid(), expiry: null, consent: 0 /* False */ };
+    var cookie = getCookie("_clck" /* CookieKey */);
     if (cookie && cookie.length > 0) {
         // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
-        var parts = cookie.split("|" /* Constant.Pipe */);
+        var parts = cookie.split("|" /* Pipe */);
         // For backward compatibility introduced in v0.6.18; following code can be removed with future iterations
         // Count number of times Clarity's user cookie crumb appears in document.cookie (could be on different sub-domains e.g. www.domain.com and .domain.com)
         var count = 0;
-        for (var _i = 0, _a = document.cookie.split(";" /* Constant.Semicolon */); _i < _a.length; _i++) {
+        for (var _i = 0, _a = document.cookie.split(";" /* Semicolon */); _i < _a.length; _i++) {
             var c = _a[_i];
-            count += c.split("=" /* Constant.Equals */)[0].trim() === "_clck" /* Constant.CookieKey */ ? 1 : 0;
+            count += c.split("=" /* Equals */)[0].trim() === "_clck" /* CookieKey */ ? 1 : 0;
         }
         // Check if we either got version-less cookie value or saw multiple copies of the user cookie crumbs
         // In both these cases, we go ahead and delete the existing cookie set on current domain
         if (parts.length === 1 || count > 1) {
-            var deleted = "".concat(";" /* Constant.Semicolon */).concat("expires=" /* Constant.Expires */).concat((new Date(0)).toUTCString()).concat(";path=/" /* Constant.Path */);
+            var deleted = "" + ";" /* Semicolon */ + "expires=" /* Expires */ + (new Date(0)).toUTCString() + ";path=/" /* Path */;
             // First, delete current user cookie which might be set on current sub-domain vs. root domain
-            document.cookie = "".concat("_clck" /* Constant.CookieKey */, "=").concat(deleted);
+            document.cookie = "_clck" /* CookieKey */ + "=" + deleted;
             // Second, same thing for current session cookie so it can be re-written later with the root domain
-            document.cookie = "".concat("_clsk" /* Constant.SessionKey */, "=").concat(deleted);
+            document.cookie = "_clsk" /* SessionKey */ + "=" + deleted;
         }
         // End code for backward compatibility
         // Read version information and timestamp from cookie, if available
@@ -4006,21 +4010,21 @@ function user() {
         }
         // Check if we have explicit consent to track this user
         if (parts.length > 3 && num(parts[3]) === 1) {
-            output.consent = 1 /* BooleanFlag.True */;
+            output.consent = 1 /* True */;
         }
         // Set track configuration to true for this user if we have explicit consent, regardless of project setting
-        config$1.track = config$1.track || output.consent === 1 /* BooleanFlag.True */;
+        config$1.track = config$1.track || output.consent === 1 /* True */;
         // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
         output.id = config$1.track ? parts[0] : output.id;
     }
     return output;
 }
 function getCookie(key) {
-    if (supported(document, "cookie" /* Constant.Cookie */)) {
-        var cookies = document.cookie.split(";" /* Constant.Semicolon */);
+    if (supported(document, "cookie" /* Cookie */)) {
+        var cookies = document.cookie.split(";" /* Semicolon */);
         if (cookies) {
             for (var i = 0; i < cookies.length; i++) {
-                var pair = cookies[i].split("=" /* Constant.Equals */);
+                var pair = cookies[i].split("=" /* Equals */);
                 if (pair.length > 1 && pair[0] && pair[0].trim() === key) {
                     return pair[1];
                 }
@@ -4030,23 +4034,23 @@ function getCookie(key) {
     return null;
 }
 function setCookie(key, value, time) {
-    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported(document, "cookie" /* Constant.Cookie */))) {
+    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported(document, "cookie" /* Cookie */))) {
         var expiry = new Date();
         expiry.setDate(expiry.getDate() + time);
-        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 */);
+        var expires = expiry ? "expires=" /* Expires */ + expiry.toUTCString() : "" /* Empty */;
+        var cookie = key + "=" + value + ";" /* Semicolon */ + expires + ";path=/" /* Path */;
         try {
             // Attempt to get the root domain only once and fall back to writing cookie on the current domain.
             if (rootDomain === null) {
-                var hostname = location.hostname ? location.hostname.split("." /* Constant.Dot */) : [];
+                var hostname = location.hostname ? location.hostname.split("." /* Dot */) : [];
                 // Walk backwards on a domain and attempt to set a cookie, until successful
                 for (var i = hostname.length - 1; i >= 0; i--) {
-                    rootDomain = ".".concat(hostname[i]).concat(rootDomain ? rootDomain : "" /* Constant.Empty */);
+                    rootDomain = "." + hostname[i] + (rootDomain ? rootDomain : "" /* Empty */);
                     // We do not wish to attempt writing a cookie on the absolute last part of the domain, e.g. .com or .net.
                     // So we start attempting after second-last part, e.g. .domain.com (PASS) or .co.uk (FAIL)
                     if (i < hostname.length - 1) {
                         // Write the cookie on the current computed top level domain
-                        document.cookie = "".concat(cookie).concat(";" /* Constant.Semicolon */).concat("domain=" /* Constant.Domain */).concat(rootDomain);
+                        document.cookie = "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain;
                         // Once written, check if the cookie exists and its value matches exactly with what we intended to set
                         // Checking for exact value match helps us eliminate a corner case where the cookie may already be present with a different value
                         // If the check is successful, no more action is required and we can return from the function since rootDomain cookie is already set
@@ -4058,13 +4062,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 = "" /* Constant.Empty */;
+                rootDomain = "" /* Empty */;
             }
         }
         catch (_a) {
-            rootDomain = "" /* Constant.Empty */;
+            rootDomain = "" /* Empty */;
         }
-        document.cookie = rootDomain ? "".concat(cookie).concat(";" /* Constant.Semicolon */).concat("domain=" /* Constant.Domain */).concat(rootDomain) : cookie;
+        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
     }
 }
 
@@ -4080,8 +4084,8 @@ function start$8() {
         userId: m.userId,
         sessionId: m.sessionId,
         pageNum: m.pageNum,
-        upload: 0 /* Upload.Async */,
-        end: 0 /* BooleanFlag.False */
+        upload: 0 /* Async */,
+        end: 0 /* False */
     };
 }
 function stop$7() {
@@ -4091,8 +4095,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 /* Upload.Beacon */ : 0 /* Upload.Async */;
-    data$1.end = last ? 1 /* BooleanFlag.True */ : 0 /* BooleanFlag.False */;
+    data$1.upload = last && "sendBeacon" in navigator ? 1 /* Beacon */ : 0 /* Async */;
+    data$1.end = last ? 1 /* True */ : 0 /* False */;
     return [
         data$1.version,
         data$1.sequence,
@@ -4145,10 +4149,10 @@ function measure (method) {
             throw report(ex);
         }
         var duration = performance.now() - start;
-        sum(4 /* Metric.TotalCost */, duration);
-        if (duration > 30 /* Setting.LongTask */) {
-            count$1(7 /* Metric.LongTaskCount */);
-            max(6 /* Metric.ThreadBlockedTime */, duration);
+        sum(4 /* TotalCost */, duration);
+        if (duration > 30 /* LongTask */) {
+            count$1(7 /* LongTaskCount */);
+            max(6 /* ThreadBlockedTime */, duration);
         }
     };
 }
@@ -4160,7 +4164,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" /* Constant.AddEventListener */)](event, listener, capture);
+        target[api("addEventListener" /* AddEventListener */)](event, listener, capture);
         bindings.push({ event: event, target: target, listener: listener, capture: capture });
     }
     catch ( /* do nothing */_a) { /* do nothing */ }
@@ -4171,7 +4175,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" /* Constant.RemoveEventListener */)](binding.event, binding.listener, binding.capture);
+            binding.target[api("removeEventListener" /* RemoveEventListener */)](binding.event, binding.listener, binding.capture);
         }
         catch ( /* do nothing */_a) { /* do nothing */ }
     }
@@ -4208,8 +4212,8 @@ function start$7() {
     }
 }
 function check$1() {
-    if (count++ > 20 /* Setting.CallStackDepth */) {
-        log$1(4 /* Code.CallStackDepth */, 0 /* Severity.Info */);
+    if (count++ > 20 /* CallStackDepth */) {
+        log$1(4 /* CallStackDepth */, 0 /* Info */);
         return false;
     }
     return true;
@@ -4219,15 +4223,15 @@ function compute$1() {
     if (url !== getCurrentUrl()) {
         // If the url changed, start tracking it as a new page
         stop();
-        window.setTimeout(restart$1, 250 /* Setting.RestartDelay */);
+        window.setTimeout(restart$1, 250 /* RestartDelay */);
     }
 }
 function restart$1() {
     start();
-    max(29 /* Metric.SinglePage */, 1 /* BooleanFlag.True */);
+    max(29 /* SinglePage */, 1 /* True */);
 }
 function getCurrentUrl() {
-    return location.href ? location.href.replace(location.hash, "" /* Constant.Empty */) : location.href;
+    return location.href ? location.href.replace(location.hash, "" /* Empty */) : location.href;
 }
 function stop$6() {
     url = null;
@@ -4290,7 +4294,7 @@ function config(override) {
 // not holding the session during inactive time periods.
 function suspend() {
     if (status) {
-        event("clarity" /* Constant.Clarity */, "suspend" /* Constant.Suspend */);
+        event("clarity" /* Clarity */, "suspend" /* Suspend */);
         stop();
         ["mousemove", "touchstart"].forEach(function (x) { return bind(document, x, restart); });
         ["resize", "scroll", "pageshow"].forEach(function (x) { return bind(window, x, restart); });
@@ -4298,7 +4302,7 @@ function suspend() {
 }
 function restart() {
     start();
-    event("clarity" /* Constant.Clarity */, "restart" /* Constant.Restart */);
+    event("clarity" /* Clarity */, "restart" /* Restart */);
 }
 
 function start$5() {
@@ -4317,7 +4321,7 @@ var diagnostic = /*#__PURE__*/Object.freeze({
 });
 
 function start$4() {
-    schedule$1(discover, 1 /* Priority.High */).then(function () {
+    schedule$1(discover, 1 /* High */).then(function () {
         measure(compute$7)();
         measure(compute$6)();
     });
@@ -4329,12 +4333,12 @@ function discover() {
             switch (_a.label) {
                 case 0:
                     ts = time();
-                    timer = { id: id(), cost: 3 /* Metric.LayoutCost */ };
+                    timer = { id: id(), cost: 3 /* LayoutCost */ };
                     start$w(timer);
-                    return [4 /*yield*/, traverse(document, timer, 0 /* Source.Discover */)];
+                    return [4 /*yield*/, traverse(document, timer, 0 /* Discover */)];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, encode$4(5 /* Event.Discover */, timer, ts)];
+                    return [4 /*yield*/, encode$4(5 /* Discover */, timer, ts)];
                 case 2:
                     _a.sent();
                     stop$t(timer);
@@ -4373,7 +4377,7 @@ function encode (type) {
             t = time();
             tokens = [t, type];
             switch (type) {
-                case 29 /* Event.Navigation */:
+                case 29 /* Navigation */:
                     tokens.push(data.fetchStart);
                     tokens.push(data.connectStart);
                     tokens.push(data.connectEnd);
@@ -4422,11 +4426,11 @@ function compute(entry) {
         encodedSize: entry.encodedBodySize ? entry.encodedBodySize : 0,
         decodedSize: entry.decodedBodySize ? entry.decodedBodySize : 0
     };
-    encode(29 /* Event.Navigation */);
+    encode(29 /* Navigation */);
 }
 
 var observer;
-var types = ["navigation" /* Constant.Navigation */, "resource" /* Constant.Resource */, "longtask" /* Constant.LongTask */, "first-input" /* Constant.FID */, "layout-shift" /* Constant.CLS */, "largest-contentful-paint" /* Constant.LCP */];
+var types = ["navigation" /* Navigation */, "resource" /* Resource */, "longtask" /* LongTask */, "first-input" /* FID */, "layout-shift" /* CLS */, "largest-contentful-paint" /* LCP */];
 function start$2() {
     // Check the browser support performance observer as a pre-requisite for any performance measurement
     if (window["PerformanceObserver"] && PerformanceObserver.supportedEntryTypes) {
@@ -4441,7 +4445,7 @@ function start$2() {
         }
     }
     else {
-        log$1(3 /* Code.PerformanceObserver */, 0 /* Severity.Info */);
+        log$1(3 /* PerformanceObserver */, 0 /* Info */);
     }
 }
 function observe() {
@@ -4461,15 +4465,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" /* Constant.CLS */) {
-                    sum(9 /* Metric.CumulativeLayoutShift */, 0);
+                if (x === "layout-shift" /* CLS */) {
+                    sum(9 /* CumulativeLayoutShift */, 0);
                 }
                 observer.observe({ type: x, buffered: true });
             }
         }
     }
     catch (_a) {
-        log$1(3 /* Code.PerformanceObserver */, 1 /* Severity.Warning */);
+        log$1(3 /* PerformanceObserver */, 1 /* Warning */);
     }
 }
 function handle(entries) {
@@ -4480,41 +4484,41 @@ function process(entries) {
     for (var i = 0; i < entries.length; i++) {
         var entry = entries[i];
         switch (entry.entryType) {
-            case "navigation" /* Constant.Navigation */:
+            case "navigation" /* Navigation */:
                 compute(entry);
                 break;
-            case "resource" /* Constant.Resource */:
+            case "resource" /* Resource */:
                 var name_1 = entry.name;
-                log(4 /* Dimension.NetworkHosts */, host(name_1));
+                log(4 /* NetworkHosts */, host(name_1));
                 if (name_1 === config$1.upload || name_1 === config$1.fallback) {
-                    max(28 /* Metric.UploadTime */, entry.duration);
+                    max(28 /* UploadTime */, entry.duration);
                 }
                 break;
-            case "longtask" /* Constant.LongTask */:
-                count$1(7 /* Metric.LongTaskCount */);
+            case "longtask" /* LongTask */:
+                count$1(7 /* LongTaskCount */);
                 break;
-            case "first-input" /* Constant.FID */:
+            case "first-input" /* FID */:
                 if (visible) {
-                    max(10 /* Metric.FirstInputDelay */, entry["processingStart"] - entry.startTime);
+                    max(10 /* FirstInputDelay */, entry["processingStart"] - entry.startTime);
                 }
                 break;
-            case "layout-shift" /* Constant.CLS */:
+            case "layout-shift" /* CLS */:
                 // Scale the value to avoid sending back floating point number
                 if (visible && !entry["hadRecentInput"]) {
-                    sum(9 /* Metric.CumulativeLayoutShift */, entry["value"] * 1000);
+                    sum(9 /* CumulativeLayoutShift */, entry["value"] * 1000);
                 }
                 break;
-            case "largest-contentful-paint" /* Constant.LCP */:
+            case "largest-contentful-paint" /* LCP */:
                 if (visible) {
-                    max(8 /* Metric.LargestPaint */, entry.startTime);
+                    max(8 /* LargestPaint */, entry.startTime);
                 }
                 break;
         }
     }
-    if (performance && "memory" /* Constant.Memory */ in performance && performance["memory" /* Constant.Memory */].usedJSHeapSize) {
+    if (performance && "memory" /* Memory */ in performance && performance["memory" /* Memory */].usedJSHeapSize) {
         // Track consumed memory (MBs) where "memory" API is available
         // Reference: https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
-        max(30 /* Metric.UsedMemory */, Math.abs(performance["memory" /* Constant.Memory */].usedJSHeapSize / 1048576 /* Setting.MegaByte */));
+        max(30 /* UsedMemory */, Math.abs(performance["memory" /* Memory */].usedJSHeapSize / 1048576 /* MegaByte */));
     }
 }
 function stop$2() {
@@ -4562,7 +4566,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" /* Constant.Clarity */, "pause" /* Constant.Pause */);
+        event("clarity" /* Clarity */, "pause" /* Pause */);
         pause$1();
     }
 }
@@ -4570,7 +4574,7 @@ function pause() {
 function resume() {
     if (active()) {
         resume$1();
-        event("clarity" /* Constant.Clarity */, "resume" /* Constant.Resume */);
+        event("clarity" /* Clarity */, "resume" /* Resume */);
     }
 }
 function stop() {