clarity-js 0.6.23

package/build/clarity.module.js

@@ -0,0 +1,4473 @@
+var upload$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get track () { return track; },
+    get start () { return start$a; },
+    get queue () { return queue; },
+    get stop () { return stop$9; }
+});
+
+var config$1 = {
+    projectId: null,
+    delay: 1 * 1000 /* Second */,
+    cssRules: false,
+    lean: false,
+    track: true,
+    content: true,
+    mask: [],
+    unmask: [],
+    regions: [],
+    metrics: [],
+    cookies: [],
+    report: null,
+    upload: null,
+    fallback: null,
+    upgrade: null
+};
+
+var startTime = 0;
+function start$E() {
+    startTime = performance.now();
+}
+function time(ts) {
+    if (ts === void 0) { ts = null; }
+    ts = ts ? ts : performance.now();
+    return Math.max(Math.round(ts - startTime), 0);
+}
+function stop$B() {
+    startTime = 0;
+}
+
+var state$7 = null;
+var buffer = null;
+var update$1 = false;
+function start$D() {
+    update$1 = false;
+    reset$n();
+}
+function reset$n() {
+    // 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$1) {
+        state$7 = { time: time(), event: 4 /* Baseline */, data: {
+                visible: buffer.visible,
+                docWidth: buffer.docWidth,
+                docHeight: buffer.docHeight,
+                screenWidth: buffer.screenWidth,
+                screenHeight: buffer.screenHeight,
+                scrollX: buffer.scrollX,
+                scrollY: buffer.scrollY,
+                pointerX: buffer.pointerX,
+                pointerY: buffer.pointerY,
+                activityTime: buffer.activityTime
+            }
+        };
+    }
+    buffer = buffer ? buffer : {
+        visible: 1 /* True */,
+        docWidth: 0,
+        docHeight: 0,
+        screenWidth: 0,
+        screenHeight: 0,
+        scrollX: 0,
+        scrollY: 0,
+        pointerX: 0,
+        pointerY: 0,
+        activityTime: 0
+    };
+}
+function track$7(event, x, y) {
+    switch (event) {
+        case 8 /* Document */:
+            buffer.docWidth = x;
+            buffer.docHeight = y;
+            break;
+        case 11 /* Resize */:
+            buffer.screenWidth = x;
+            buffer.screenHeight = y;
+            break;
+        case 10 /* Scroll */:
+            buffer.scrollX = x;
+            buffer.scrollY = y;
+            break;
+        default:
+            buffer.pointerX = x;
+            buffer.pointerY = y;
+            break;
+    }
+    update$1 = true;
+}
+function activity(t) {
+    buffer.activityTime = t;
+}
+function visibility(t, visible) {
+    buffer.visible = visible === "visible" ? 1 /* True */ : 0 /* False */;
+    if (!buffer.visible) {
+        activity(t);
+    }
+    update$1 = true;
+}
+function compute$c() {
+    if (update$1) {
+        encode$1(4 /* Baseline */);
+    }
+}
+function stop$A() {
+    reset$n();
+}
+
+var baseline = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get state () { return state$7; },
+    start: start$D,
+    reset: reset$n,
+    track: track$7,
+    activity: activity,
+    visibility: visibility,
+    compute: compute$c,
+    stop: stop$A
+});
+
+var data$k = null;
+function event(key, value) {
+    if (active() &&
+        key &&
+        value &&
+        typeof key === "string" /* String */ &&
+        typeof value === "string" /* String */ &&
+        key.length < 255 &&
+        value.length < 255) {
+        data$k = { key: key, value: value };
+        encode$1(24 /* Custom */);
+    }
+}
+
+// tslint:disable: no-bitwise
+function hash (input) {
+    // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
+    var hash = 0;
+    var hashOne = 5381;
+    var hashTwo = hashOne;
+    for (var i = 0; i < input.length; i += 2) {
+        var charOne = input.charCodeAt(i);
+        hashOne = ((hashOne << 5) + hashOne) ^ charOne;
+        if (i + 1 < input.length) {
+            var charTwo = input.charCodeAt(i + 1);
+            hashTwo = ((hashTwo << 5) + hashTwo) ^ charTwo;
+        }
+    }
+    // Replace the magic number from C# implementation (1566083941) with a smaller prime number (11579)
+    // This ensures we don't hit integer overflow and prevent collisions
+    hash = Math.abs(hashOne + (hashTwo * 11579));
+    return hash.toString(36);
+}
+
+var data$j = null;
+function start$C() {
+    reset$m();
+}
+function set(variable, 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" /* UserId */, [userId]);
+    log$2("sessionId" /* SessionId */, [sessionId]);
+    log$2("pageId" /* PageId */, [pageId]);
+}
+function log$2(variable, value) {
+    if (active() &&
+        variable &&
+        value &&
+        typeof variable === "string" /* String */ &&
+        variable.length < 255) {
+        var validValues = variable in data$j ? data$j[variable] : [];
+        for (var i = 0; i < value.length; i++) {
+            if (typeof value[i] === "string" /* String */ && value[i].length < 255) {
+                validValues.push(value[i]);
+            }
+        }
+        data$j[variable] = validValues;
+    }
+}
+function compute$b() {
+    encode$1(34 /* Variable */);
+}
+function reset$m() {
+    data$j = {};
+}
+function stop$z() {
+    reset$m();
+}
+
+var variable = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$j; },
+    start: start$C,
+    set: set,
+    identify: identify,
+    compute: compute$b,
+    reset: reset$m,
+    stop: stop$z
+});
+
+var data$i = null;
+var callback = null;
+var rootDomain = null;
+function start$B() {
+    callback = null;
+    rootDomain = null;
+    var ua = navigator && "userAgent" in navigator ? navigator.userAgent : "" /* Empty */;
+    var title = document && document.title ? document.title : "" /* Empty */;
+    // Populate ids for this page
+    var s = session();
+    var u = user();
+    data$i = {
+        projectId: config$1.projectId || hash(location.host),
+        userId: u.id,
+        sessionId: s.session,
+        pageNum: s.count
+    };
+    // Override configuration based on what's in the session storage
+    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 : config$1.upload;
+    // Log dimensions
+    log$1(0 /* UserAgent */, ua);
+    log$1(3 /* PageTitle */, title);
+    log$1(1 /* Url */, location.href);
+    log$1(2 /* Referrer */, document.referrer);
+    log$1(15 /* TabId */, tab());
+    log$1(16 /* PageLanguage */, document.documentElement.lang);
+    log$1(17 /* DocumentDirection */, document.dir);
+    if (navigator) {
+        log$1(9 /* Language */, navigator.userLanguage || navigator.language);
+    }
+    // Metrics
+    max(0 /* ClientTimestamp */, s.ts);
+    max(1 /* Playback */, 0 /* False */);
+    if (screen) {
+        max(14 /* ScreenWidth */, Math.round(screen.width));
+        max(15 /* ScreenHeight */, Math.round(screen.height));
+        max(16 /* ColorDepth */, Math.round(screen.colorDepth));
+    }
+    // Read cookies specified in configuration
+    for (var _i = 0, _a = config$1.cookies; _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = getCookie(key);
+        if (value) {
+            set(key, value);
+        }
+    }
+    // Track ids using a cookie if configuration allows it
+    track$6(u);
+}
+function stop$y() {
+    callback = null;
+    rootDomain = null;
+}
+function metadata$2(cb) {
+    callback = cb;
+}
+function id() {
+    return data$i ? [data$i.userId, data$i.sessionId, data$i.pageNum].join("." /* Dot */) : "" /* Empty */;
+}
+function consent() {
+    if (active()) {
+        config$1.track = true;
+        track$6(user(), 1 /* True */);
+    }
+}
+function clear() {
+    // Clear any stored information in the cookie that tracks session information so we can restart fresh the next time
+    setCookie("_clsk" /* SessionKey */, "" /* Empty */, 0);
+}
+function tab() {
+    var id = shortid();
+    if (config$1.track && supported$1(window, "sessionStorage" /* SessionStorage */)) {
+        var value = sessionStorage.getItem("_cltk" /* TabKey */);
+        id = value ? value : id;
+        sessionStorage.setItem("_cltk" /* TabKey */, id);
+    }
+    return id;
+}
+function save() {
+    var ts = Math.round(Date.now());
+    var upgrade = config$1.lean ? 0 /* False */ : 1 /* True */;
+    var upload = config$1.upload && typeof config$1.upload === "string" /* String */ ? config$1.upload.replace("https://" /* HTTPS */, "" /* Empty */) : "" /* Empty */;
+    if (upgrade && callback) {
+        callback(data$i, !config$1.lean);
+    }
+    setCookie("_clsk" /* SessionKey */, [data$i.sessionId, ts, data$i.pageNum, upgrade, upload].join("|" /* Pipe */), 1 /* SessionExpire */);
+}
+function supported$1(target, api) {
+    try {
+        return !!target[api];
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function track$6(u, consent) {
+    if (consent === void 0) { consent = null; }
+    // If consent is not explicitly specified, infer it from the user object
+    consent = consent === null ? u.consent : consent;
+    // Convert time precision into days to reduce number of bytes we have to write in a cookie
+    // E.g. Math.ceil(1628735962643 / (24*60*60*1000)) => 18852 (days) => ejo in base36 (13 bytes => 3 bytes)
+    var end = Math.ceil((Date.now() + (365 /* Expire */ * 86400000 /* Day */)) / 86400000 /* Day */);
+    // To avoid cookie churn, write user id cookie only once every day
+    if (u.expiry === null || Math.abs(end - u.expiry) >= 1 /* CookieInterval */ || u.consent !== consent) {
+        setCookie("_clck" /* CookieKey */, [data$i.userId, 1 /* CookieVersion */, end.toString(36), consent].join("|" /* Pipe */), 365 /* Expire */);
+    }
+}
+function shortid() {
+    var id = Math.floor(Math.random() * Math.pow(2, 32));
+    if (window && window.crypto && window.crypto.getRandomValues && Uint32Array) {
+        id = window.crypto.getRandomValues(new Uint32Array(1))[0];
+    }
+    return id.toString(36);
+}
+function session() {
+    var output = { session: shortid(), ts: Math.round(Date.now()), count: 1, upgrade: null, upload: "" /* Empty */ };
+    var value = getCookie("_clsk" /* SessionKey */);
+    if (value) {
+        var parts = value.split("|" /* Pipe */);
+        // Making it backward & forward compatible by using greater than comparison (v0.6.21)
+        // In future version, we can reduce the parts length to be 5 where the last part contains the full upload URL
+        if (parts.length >= 5 && output.ts - num$2(parts[1]) < 1800000 /* SessionTimeout */) {
+            output.session = parts[0];
+            output.count = num$2(parts[2]) + 1;
+            output.upgrade = num$2(parts[3]);
+            output.upload = parts.length >= 6 ? "" + "https://" /* HTTPS */ + parts[5] + "/" + parts[4] : "" + "https://" /* HTTPS */ + parts[4];
+        }
+    }
+    return output;
+}
+function num$2(string, base) {
+    if (base === void 0) { base = 10; }
+    return parseInt(string, base);
+}
+function user() {
+    var output = { id: shortid(), expiry: null, consent: 0 /* False */ };
+    var cookie = getCookie("_clck" /* CookieKey */);
+    if (cookie && cookie.length > 0) {
+        // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
+        var parts = cookie.split("|" /* Pipe */);
+        // For backward compatibility introduced in v0.6.18; following code can be removed with future iterations
+        // Count number of times Clarity's user cookie crumb appears in document.cookie (could be on different sub-domains e.g. www.domain.com and .domain.com)
+        var count = 0;
+        for (var _i = 0, _a = document.cookie.split(";" /* Semicolon */); _i < _a.length; _i++) {
+            var c = _a[_i];
+            count += c.split("=" /* Equals */)[0].trim() === "_clck" /* CookieKey */ ? 1 : 0;
+        }
+        // Check if we either got version-less cookie value or saw multiple copies of the user cookie crumbs
+        // In both these cases, we go ahead and delete the existing cookie set on current domain
+        if (parts.length === 1 || count > 1) {
+            var deleted = "" + ";" /* Semicolon */ + "expires=" /* Expires */ + (new Date(0)).toUTCString() + ";path=/" /* Path */;
+            // First, delete current user cookie which might be set on current sub-domain vs. root domain
+            document.cookie = "_clck" /* CookieKey */ + "=" + deleted;
+            // Second, same thing for current session cookie so it can be re-written later with the root domain
+            document.cookie = "_clsk" /* SessionKey */ + "=" + deleted;
+        }
+        // End code for backward compatibility
+        // Read version information and timestamp from cookie, if available
+        if (parts.length > 2) {
+            output.expiry = num$2(parts[2], 36);
+        }
+        // Check if we have explicit consent to track this user
+        if (parts.length > 3 && num$2(parts[3]) === 1) {
+            output.consent = 1 /* True */;
+        }
+        // Set track configuration to true for this user if we have explicit consent, regardless of project setting
+        config$1.track = config$1.track || output.consent === 1 /* True */;
+        // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
+        output.id = config$1.track ? parts[0] : output.id;
+    }
+    return output;
+}
+function getCookie(key) {
+    if (supported$1(document, "cookie" /* Cookie */)) {
+        var cookies = document.cookie.split(";" /* Semicolon */);
+        if (cookies) {
+            for (var i = 0; i < cookies.length; i++) {
+                var pair = cookies[i].split("=" /* Equals */);
+                if (pair.length > 1 && pair[0] && pair[0].trim() === key) {
+                    return pair[1];
+                }
+            }
+        }
+    }
+    return null;
+}
+function setCookie(key, value, time) {
+    if (config$1.track && ((navigator && navigator.cookieEnabled) || supported$1(document, "cookie" /* Cookie */))) {
+        var expiry = new Date();
+        expiry.setDate(expiry.getDate() + time);
+        var expires = expiry ? "expires=" /* Expires */ + expiry.toUTCString() : "" /* Empty */;
+        var cookie = key + "=" + value + ";" /* Semicolon */ + expires + ";path=/" /* Path */;
+        try {
+            // Attempt to get the root domain only once and fall back to writing cookie on the current domain.
+            if (rootDomain === null) {
+                var hostname = location.hostname ? location.hostname.split("." /* Dot */) : [];
+                // Walk backwards on a domain and attempt to set a cookie, until successful
+                for (var i = hostname.length - 1; i >= 0; i--) {
+                    rootDomain = "." + hostname[i] + (rootDomain ? rootDomain : "" /* Empty */);
+                    // We do not wish to attempt writing a cookie on the absolute last part of the domain, e.g. .com or .net.
+                    // So we start attempting after second-last part, e.g. .domain.com (PASS) or .co.uk (FAIL)
+                    if (i < hostname.length - 1) {
+                        // Write the cookie on the current computed top level domain
+                        document.cookie = "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain;
+                        // Once written, check if the cookie exists and its value matches exactly with what we intended to set
+                        // Checking for exact value match helps us eliminate a corner case where the cookie may already be present with a different value
+                        // If the check is successful, no more action is required and we can return from the function since rootDomain cookie is already set
+                        // If the check fails, continue with the for loop until we can successfully set and verify the cookie
+                        if (getCookie(key) === value) {
+                            return;
+                        }
+                    }
+                }
+                // Finally, if we were not successful and gone through all the options, play it safe and reset rootDomain to be empty
+                // This forces our code to fall back to always writing cookie to the current domain
+                rootDomain = "" /* Empty */;
+            }
+        }
+        catch (_a) {
+            rootDomain = "" /* Empty */;
+        }
+        document.cookie = rootDomain ? "" + cookie + ";" /* Semicolon */ + "domain=" /* Domain */ + rootDomain : cookie;
+    }
+}
+
+var metadata$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$i; },
+    get callback () { return callback; },
+    start: start$B,
+    stop: stop$y,
+    metadata: metadata$2,
+    id: id,
+    consent: consent,
+    clear: clear,
+    save: save
+});
+
+var history$5;
+function reset$l() {
+    history$5 = [];
+}
+function report(check, message) {
+    if (message === void 0) { message = null; }
+    // Do not report the same message twice for the same page
+    if (history$5 && history$5.indexOf(message) === -1) {
+        var url = config$1.report;
+        if (url && url.length > 0) {
+            var payload = { c: check, p: data$i.projectId, u: data$i.userId, s: data$i.sessionId, n: data$i.pageNum };
+            if (message)
+                payload.m = message;
+            // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
+            // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
+            var xhr = new XMLHttpRequest();
+            xhr.open("POST", url);
+            xhr.send(JSON.stringify(payload));
+            history$5.push(message);
+        }
+    }
+}
+
+var version$1 = "0.6.23";
+
+var data$h = null;
+function start$A() {
+    var m = data$i;
+    data$h = {
+        version: version$1,
+        sequence: 0,
+        start: 0,
+        duration: 0,
+        projectId: m.projectId,
+        userId: m.userId,
+        sessionId: m.sessionId,
+        pageNum: m.pageNum,
+        upload: 0 /* Async */,
+        end: 0 /* False */
+    };
+}
+function stop$x() {
+    data$h = null;
+}
+function envelope(last) {
+    data$h.start = data$h.start + data$h.duration;
+    data$h.duration = time() - data$h.start;
+    data$h.sequence++;
+    data$h.upload = last && "sendBeacon" in navigator ? 1 /* Beacon */ : 0 /* Async */;
+    data$h.end = last ? 1 /* True */ : 0 /* False */;
+    return [
+        data$h.version,
+        data$h.sequence,
+        data$h.start,
+        data$h.duration,
+        data$h.projectId,
+        data$h.userId,
+        data$h.sessionId,
+        data$h.pageNum,
+        data$h.upload,
+        data$h.end
+    ];
+}
+
+var envelope$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$h; },
+    start: start$A,
+    stop: stop$x,
+    envelope: envelope
+});
+
+var data$g;
+function start$z() {
+    data$g = { check: 0 /* None */ };
+}
+function check$3(bytes) {
+    if (data$g.check === 0 /* None */) {
+        var reason = data$g.check;
+        reason = data$h.sequence >= 128 /* PayloadLimit */ ? 1 /* Payload */ : reason;
+        reason = time() > 7200000 /* ShutdownLimit */ ? 2 /* Shutdown */ : reason;
+        reason = bytes > 10485760 /* PlaybackBytesLimit */ ? 2 /* Shutdown */ : reason;
+        if (reason !== data$g.check) {
+            trigger$1(reason);
+        }
+    }
+}
+function trigger$1(reason) {
+    report(reason);
+    data$g.check = reason;
+    clear();
+    stop();
+}
+function compute$a() {
+    if (data$g.check !== 0 /* None */) {
+        encode$1(35 /* Limit */);
+    }
+}
+function stop$w() {
+    data$g = null;
+}
+
+var limit = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$g; },
+    start: start$z,
+    check: check$3,
+    trigger: trigger$1,
+    compute: compute$a,
+    stop: stop$w
+});
+
+var data$f = null;
+var updates$3 = null;
+function start$y() {
+    data$f = {};
+    updates$3 = {};
+}
+function stop$v() {
+    data$f = {};
+    updates$3 = {};
+}
+function log$1(dimension, value) {
+    // Check valid value before moving ahead
+    if (value) {
+        // Ensure received value is casted into a string if it wasn't a string to begin with
+        value = "" + value;
+        if (!(dimension in data$f)) {
+            data$f[dimension] = [];
+        }
+        if (data$f[dimension].indexOf(value) < 0) {
+            data$f[dimension].push(value);
+            // If this is a new value, track it as part of updates object
+            // This allows us to only send back new values in subsequent payloads
+            if (!(dimension in updates$3)) {
+                updates$3[dimension] = [];
+            }
+            updates$3[dimension].push(value);
+            // Limit check to ensure we have a cap on number of dimensions we can collect
+            if (data$f[dimension].length > 128 /* CollectionLimit */) {
+                trigger$1(5 /* Collection */);
+            }
+        }
+    }
+}
+function compute$9() {
+    encode$1(1 /* Dimension */);
+}
+function reset$k() {
+    updates$3 = {};
+}
+
+var dimension = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$f; },
+    get updates () { return updates$3; },
+    start: start$y,
+    stop: stop$v,
+    log: log$1,
+    compute: compute$9,
+    reset: reset$k
+});
+
+function setTimeout(handler, timeout, event) {
+    return window.setTimeout(measure(handler), timeout, event);
+}
+function clearTimeout(handle) {
+    return window.clearTimeout(handle);
+}
+
+var data$e;
+var last = 0;
+var interval = 0;
+var timeout$6 = null;
+function start$x() {
+    interval = 60000 /* PingInterval */;
+    last = 0;
+}
+function reset$j() {
+    if (timeout$6) {
+        clearTimeout(timeout$6);
+    }
+    timeout$6 = setTimeout(ping, interval);
+    last = time();
+}
+function ping() {
+    var now = time();
+    data$e = { gap: now - last };
+    encode$1(25 /* Ping */);
+    if (data$e.gap < 300000 /* PingTimeout */) {
+        timeout$6 = setTimeout(ping, interval);
+    }
+    else {
+        suspend();
+    }
+}
+function stop$u() {
+    clearTimeout(timeout$6);
+    last = 0;
+    interval = 0;
+}
+
+var ping$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$e; },
+    start: start$x,
+    reset: reset$j,
+    stop: stop$u
+});
+
+var data$d = null;
+function start$w() {
+    data$d = {};
+}
+function stop$t() {
+    data$d = {};
+}
+function track$5(event, time) {
+    if (!(event in data$d)) {
+        data$d[event] = [[time, 0]];
+    }
+    else {
+        var e = data$d[event];
+        var last = e[e.length - 1];
+        // Add a new entry only if the new event occurs after configured interval
+        // Otherwise, extend the duration of the previous entry
+        if (time - last[0] > 100 /* SummaryInterval */) {
+            data$d[event].push([time, 0]);
+        }
+        else {
+            last[1] = time - last[0];
+        }
+    }
+}
+function compute$8() {
+    encode$1(36 /* Summary */);
+}
+function reset$i() {
+    data$d = {};
+}
+
+var summary = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$d; },
+    start: start$w,
+    stop: stop$t,
+    track: track$5,
+    compute: compute$8,
+    reset: reset$i
+});
+
+var data$c = null;
+function start$v() {
+    if (!config$1.lean && config$1.upgrade) {
+        config$1.upgrade("Config" /* Config */);
+    }
+    data$c = null;
+}
+// Following call will upgrade the session from lean mode into the full mode retroactively from the start of the page.
+// As part of the lean mode, we do not send back any layout information - including discovery of DOM and mutations.
+// However, if there's a need for full fidelity playback, calling this function will disable lean mode
+// and send all backed up layout events to the server.
+function upgrade(key) {
+    // Upgrade only if Clarity was successfully activated on the page
+    if (active() && config$1.lean) {
+        config$1.lean = false;
+        data$c = { key: key };
+        // Update metadata to track we have upgraded this session
+        save();
+        // Callback upgrade handler, if configured
+        if (config$1.upgrade) {
+            config$1.upgrade(key);
+        }
+        encode$1(3 /* Upgrade */);
+    }
+}
+function stop$s() {
+    data$c = null;
+}
+
+var upgrade$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get data () { return data$c; },
+    start: start$v,
+    upgrade: upgrade,
+    stop: stop$s
+});
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var supported = "CompressionStream" /* CompressionStream */ in window;
+function compress (input) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stream, _a;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 3, , 4]);
+                    if (!supported) return [3 /*break*/, 2];
+                    stream = new ReadableStream({ start: function (controller) {
+                            return __awaiter(this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    controller.enqueue(input);
+                                    controller.close();
+                                    return [2 /*return*/];
+                                });
+                            });
+                        } }).pipeThrough(new TextEncoderStream()).pipeThrough(new window["CompressionStream" /* CompressionStream */]("gzip"));
+                    _a = Uint8Array.bind;
+                    return [4 /*yield*/, read(stream)];
+                case 1: return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _c.sent()]))()];
+                case 2: return [3 /*break*/, 4];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, null];
+            }
+        });
+    });
+}
+function read(stream) {
+    return __awaiter(this, void 0, void 0, function () {
+        var reader, chunks, done, value;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = stream.getReader();
+                    chunks = [];
+                    done = false;
+                    value = [];
+                    _b.label = 1;
+                case 1:
+                    if (!!done) return [3 /*break*/, 3];
+                    return [4 /*yield*/, reader.read()];
+                case 2:
+                    (_a = _b.sent(), done = _a.done, value = _a.value);
+                    if (done) {
+                        return [2 /*return*/, chunks];
+                    }
+                    chunks.push.apply(chunks, value);
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, chunks];
+            }
+        });
+    });
+}
+
+var modules$1 = [baseline, dimension, variable, limit, summary, metadata$3, envelope$1, upload$1, ping$1, upgrade$1];
+function start$u() {
+    // Metric needs to be initialized before we can start measuring. so metric is not wrapped in measure
+    start$9();
+    modules$1.forEach(function (x) { return measure(x.start)(); });
+}
+function stop$r() {
+    // Stop modules in the reverse order of their initialization
+    // The ordering below should respect inter-module dependency.
+    // E.g. if upgrade depends on upload, then upgrade needs to end before upload.
+    // Similarly, if upload depends on metadata, upload needs to end before metadata.
+    modules$1.slice().reverse().forEach(function (x) { return measure(x.stop)(); });
+    stop$8();
+}
+function compute$7() {
+    compute$b();
+    compute$c();
+    compute$9();
+    compute$2();
+    compute$8();
+    compute$a();
+}
+
+function scrub (value, hint, privacy, mangle) {
+    if (mangle === void 0) { mangle = false; }
+    if (value) {
+        switch (privacy) {
+            case 0 /* None */:
+                return value;
+            case 1 /* Sensitive */:
+                switch (hint) {
+                    case "*T" /* TextTag */:
+                    case "value":
+                    case "placeholder":
+                        return redact(value);
+                    case "input":
+                        return mangleToken(value);
+                }
+                return value;
+            case 2 /* Text */:
+            case 3 /* TextImage */:
+                switch (hint) {
+                    case "*T" /* TextTag */:
+                        return mangle ? mangleText(value) : mask(value);
+                    case "src":
+                    case "srcset":
+                    case "title":
+                    case "alt":
+                        return privacy === 3 /* TextImage */ ? "" /* Empty */ : value;
+                    case "value":
+                    case "click":
+                    case "input":
+                        return mangleToken(value);
+                    case "placeholder":
+                        return mask(value);
+                }
+                break;
+        }
+    }
+    return value;
+}
+function mangleText(value) {
+    var trimmed = value.trim();
+    if (trimmed.length > 0) {
+        var first = trimmed[0];
+        var index = value.indexOf(first);
+        var prefix = value.substr(0, index);
+        var suffix = value.substr(index + trimmed.length);
+        return "" + prefix + trimmed.length.toString(36) + suffix;
+    }
+    return value;
+}
+function mask(value) {
+    return value.replace(/\S/gi, "\u2022" /* Mask */);
+}
+function mangleToken(value) {
+    var length = ((Math.floor(value.length / 5 /* WordLength */) + 1) * 5 /* WordLength */);
+    var output = "" /* Empty */;
+    for (var i = 0; i < length; i++) {
+        output += i > 0 && i % 5 /* WordLength */ === 0 ? " " /* Space */ : "\u2022" /* Mask */;
+    }
+    return output;
+}
+function redact(value) {
+    var spaceIndex = -1;
+    var hasDigit = false;
+    var hasEmail = false;
+    var hasWhitespace = false;
+    var array = null;
+    for (var i = 0; i < value.length; i++) {
+        var c = value.charCodeAt(i);
+        hasDigit = hasDigit || (c >= 48 && c <= 57); // Check for digits in the current word
+        hasEmail = hasEmail || c === 64; // Check for @ sign anywhere within the current word
+        hasWhitespace = c === 9 || c === 10 || c === 13 || c === 32; // Whitespace character (32: blank space | 9: \t | 10: \n | 13: \r)
+        // Process each word as an individual token to redact any sensitive information
+        if (i === 0 || i === value.length - 1 || hasWhitespace) {
+            // Performance optimization: Lazy load string -> array conversion only when required
+            if (hasDigit || hasEmail) {
+                if (array === null) {
+                    array = value.split("" /* Empty */);
+                }
+                mutate(array, spaceIndex, hasWhitespace ? i : i + 1);
+            }
+            // Reset digit and email flags after every word boundary, except the beginning of string
+            if (hasWhitespace) {
+                hasDigit = false;
+                hasEmail = false;
+                spaceIndex = i;
+            }
+        }
+    }
+    return array ? array.join("" /* Empty */) : value;
+}
+function mutate(array, start, end) {
+    for (var i = start + 1; i < end; i++) {
+        array[i] = "\u2022" /* Mask */;
+    }
+}
+
+// Track the start time to be able to compute duration at the end of the task
+var idleTimeout = 5000;
+var tracker = {};
+var queuedTasks = [];
+var activeTask = null;
+var pauseTask = null;
+var resumeResolve = null;
+function pause$1() {
+    if (pauseTask === null) {
+        pauseTask = new Promise(function (resolve) {
+            resumeResolve = resolve;
+        });
+    }
+}
+function resume$1() {
+    if (pauseTask) {
+        resumeResolve();
+        pauseTask = null;
+        if (activeTask === null) {
+            run();
+        }
+    }
+}
+function reset$h() {
+    tracker = {};
+    queuedTasks = [];
+    activeTask = null;
+    pauseTask = null;
+}
+function schedule$1(task, priority) {
+    if (priority === void 0) { priority = 0 /* Normal */; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _i, queuedTasks_1, q, promise;
+        return __generator(this, function (_a) {
+            // If this task is already scheduled, skip it
+            for (_i = 0, queuedTasks_1 = queuedTasks; _i < queuedTasks_1.length; _i++) {
+                q = queuedTasks_1[_i];
+                if (q.task === task) {
+                    return [2 /*return*/];
+                }
+            }
+            promise = new Promise(function (resolve) {
+                var insert = priority === 1 /* High */ ? "unshift" : "push";
+                // Queue this task for asynchronous execution later
+                // We also store a unique page identifier (id) along with the task to ensure
+                // ensure that we do not accidentally execute this task in context of a different page
+                queuedTasks[insert]({ task: task, resolve: resolve, id: id() });
+            });
+            // If there is no active task running, and Clarity is not in pause state,
+            // invoke the first task in the queue synchronously. This ensures that we don't yield the thread during unload event
+            if (activeTask === null && pauseTask === null) {
+                run();
+            }
+            return [2 /*return*/, promise];
+        });
+    });
+}
+function run() {
+    var entry = queuedTasks.shift();
+    if (entry) {
+        activeTask = entry;
+        entry.task().then(function () {
+            // Bail out if the context in which this task was operating is different from the current page
+            // An example scenario where task could span across pages is Single Page Applications (SPA)
+            // A task that started on page #1, but completes on page #2
+            if (entry.id !== id()) {
+                return;
+            }
+            entry.resolve();
+            activeTask = null; // Reset active task back to null now that the promise is resolved
+            run();
+        }).catch(function (error) {
+            // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
+            if (entry.id !== id()) {
+                return;
+            }
+            if (error) {
+                log(0 /* RunTask */, 1 /* Warning */, error.name, error.message, error.stack);
+            }
+            activeTask = null;
+            run();
+        });
+    }
+}
+function state$6(timer) {
+    var id = key(timer);
+    if (id in tracker) {
+        var elapsed = performance.now() - tracker[id].start;
+        return (elapsed > tracker[id].yield) ? 0 /* Wait */ : 1 /* Run */;
+    }
+    // If this task is no longer being tracked, send stop message to the caller
+    return 2 /* Stop */;
+}
+function start$t(timer) {
+    tracker[key(timer)] = { start: performance.now(), calls: 0, yield: 30 /* LongTask */ };
+}
+function restart$1(timer) {
+    var id = key(timer);
+    if (tracker && tracker[id]) {
+        var c = tracker[id].calls;
+        var y = tracker[id].yield;
+        start$t(timer);
+        tracker[id].calls = c + 1;
+        tracker[id].yield = y;
+    }
+}
+function stop$q(timer) {
+    var end = performance.now();
+    var id = key(timer);
+    var duration = end - tracker[id].start;
+    sum(timer.cost, duration);
+    count$1(5 /* InvokeCount */);
+    // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
+    // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
+    if (tracker[id].calls > 0) {
+        sum(4 /* TotalCost */, duration);
+    }
+}
+function suspend$1(timer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var id, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    id = key(timer);
+                    if (!(id in tracker)) return [3 /*break*/, 2];
+                    stop$q(timer);
+                    _a = tracker[id];
+                    return [4 /*yield*/, wait()];
+                case 1:
+                    _a.yield = (_b.sent()).timeRemaining();
+                    restart$1(timer);
+                    _b.label = 2;
+                case 2: 
+                // After we are done with suspending task, ensure that we are still operating in the right context
+                // If the task is still being tracked, continue running the task, otherwise ask caller to stop execution
+                return [2 /*return*/, id in tracker ? 1 /* Run */ : 2 /* Stop */];
+            }
+        });
+    });
+}
+function key(timer) {
+    return timer.id + "." + timer.cost;
+}
+function wait() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!pauseTask) return [3 /*break*/, 2];
+                    return [4 /*yield*/, pauseTask];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, new Promise(function (resolve) {
+                        requestIdleCallback(resolve, { timeout: idleTimeout });
+                    })];
+            }
+        });
+    });
+}
+// Use native implementation of requestIdleCallback if it exists.
+// Otherwise, fall back to a custom implementation using requestAnimationFrame & MessageChannel.
+// While it's not possible to build a perfect polyfill given the nature of this API, the following code attempts to get close.
+// Background context: requestAnimationFrame invokes the js code right before: style, layout and paint computation within the frame.
+// This means, that any code that runs as part of requestAnimationFrame will by default be blocking in nature. Not what we want.
+// For non-blocking behavior, We need to know when browser has finished painiting. This can be accomplished in two different ways (hacks):
+//   (1) Use MessageChannel to pass the message, and browser will receive the message right after pain event has occured.
+//   (2) Use setTimeout call within requestAnimationFrame. This also works, but there's a risk that browser may throttle setTimeout calls.
+// Given this information, we are currently using (1) from above. More information on (2) as well as some additional context is below:
+// https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Performance_best_practices_for_Firefox_fe_engineers
+function requestIdleCallbackPolyfill(callback, options) {
+    var startTime = performance.now();
+    var channel = new MessageChannel();
+    var incoming = channel.port1;
+    var outgoing = channel.port2;
+    incoming.onmessage = function (event) {
+        var currentTime = performance.now();
+        var elapsed = currentTime - startTime;
+        var duration = currentTime - event.data;
+        if (duration > 30 /* LongTask */ && elapsed < options.timeout) {
+            requestAnimationFrame(function () { outgoing.postMessage(currentTime); });
+        }
+        else {
+            var didTimeout_1 = elapsed > options.timeout;
+            callback({
+                didTimeout: didTimeout_1,
+                timeRemaining: function () { return didTimeout_1 ? 30 /* LongTask */ : Math.max(0, 30 /* LongTask */ - duration); }
+            });
+        }
+    };
+    requestAnimationFrame(function () { outgoing.postMessage(performance.now()); });
+}
+var requestIdleCallback = window["requestIdleCallback"] || requestIdleCallbackPolyfill;
+
+var data$b;
+function start$s() {
+    bind(document, "error", handler$5, true);
+}
+function handler$5(error) {
+    var element = error.target;
+    if (element && element.tagName === "IMG") {
+        data$b = { source: element.src, target: element };
+        schedule$1(encode$3.bind(this, 32 /* ImageError */));
+    }
+}
+function stop$p() {
+    data$b = null;
+}
+
+// Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
+// The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
+// If so, it replaces the token with its reference (index). This helps us save bytes by not repeating the same value twice.
+// E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
+// Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
+// Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
+function tokenize (tokens) {
+    var output = [];
+    var lookup = {};
+    var pointer = 0;
+    var reference = null;
+    for (var i = 0; i < tokens.length; i++) {
+        // Only optimize for string values
+        if (typeof tokens[i] === "string" /* String */) {
+            var token = tokens[i];
+            var index = lookup[token] || -1;
+            if (index >= 0) {
+                if (reference) {
+                    reference.push(index);
+                }
+                else {
+                    reference = [index];
+                    output.push(reference);
+                    pointer++;
+                }
+            }
+            else {
+                reference = null;
+                output.push(token);
+                lookup[token] = pointer++;
+            }
+        }
+        else {
+            // If the value is anything other than string, append it as it is to the output array
+            // And, also increment the pointer to stay in sync with output array
+            reference = null;
+            output.push(tokens[i]);
+            pointer++;
+        }
+    }
+    return output;
+}
+
+var data$a;
+function reset$g() {
+    data$a = null;
+}
+function start$r() {
+    reset$g();
+    compute$6();
+}
+function compute$6() {
+    var body = document.body;
+    var d = document.documentElement;
+    var bodyClientWidth = body ? body.clientWidth : null;
+    var bodyScrollWidth = body ? body.scrollWidth : null;
+    var bodyOffsetWidth = body ? body.offsetWidth : null;
+    var documentClientWidth = d ? d.clientWidth : null;
+    var documentScrollWidth = d ? d.scrollWidth : null;
+    var documentOffsetWidth = d ? d.offsetWidth : null;
+    var width = Math.max(bodyClientWidth, bodyScrollWidth, bodyOffsetWidth, documentClientWidth, documentScrollWidth, documentOffsetWidth);
+    var bodyClientHeight = body ? body.clientHeight : null;
+    var bodyScrollHeight = body ? body.scrollHeight : null;
+    var bodyOffsetHeight = body ? body.offsetHeight : null;
+    var documentClientHeight = d ? d.clientHeight : null;
+    var documentScrollHeight = d ? d.scrollHeight : null;
+    var documentOffsetHeight = d ? d.offsetHeight : null;
+    var height = Math.max(bodyClientHeight, bodyScrollHeight, bodyOffsetHeight, documentClientHeight, documentScrollHeight, documentOffsetHeight);
+    // Check that width or height has changed from before, and also that width & height are not null values
+    if ((data$a === null || width !== data$a.width || height !== data$a.height) && width !== null && height !== null) {
+        data$a = { width: width, height: height };
+        encode$4(8 /* Document */);
+    }
+}
+function end() {
+    reset$g();
+}
+
+function encode$4 (type, timer, ts) {
+    if (timer === void 0) { timer = null; }
+    if (ts === void 0) { ts = null; }
+    return __awaiter(this, void 0, void 0, function () {
+        var eventTime, tokens, _a, d, _i, _b, r, b, _c, b_1, entry, values, _d, values_1, value, state, data, active, privacy, mangle, keys, _e, keys_1, key, size, factor, attr;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    eventTime = ts || time();
+                    tokens = [eventTime, type];
+                    _a = type;
+                    switch (_a) {
+                        case 8 /* Document */: return [3 /*break*/, 1];
+                        case 7 /* Region */: return [3 /*break*/, 2];
+                        case 37 /* Box */: return [3 /*break*/, 3];
+                        case 5 /* Discover */: return [3 /*break*/, 4];
+                        case 6 /* Mutation */: return [3 /*break*/, 4];
+                    }
+                    return [3 /*break*/, 11];
+                case 1:
+                    d = data$a;
+                    tokens.push(d.width);
+                    tokens.push(d.height);
+                    track$7(type, d.width, d.height);
+                    queue(tokens);
+                    return [3 /*break*/, 11];
+                case 2:
+                    for (_i = 0, _b = state$5; _i < _b.length; _i++) {
+                        r = _b[_i];
+                        tokens = [r.time, 7 /* Region */];
+                        tokens.push(r.data.id);
+                        tokens.push(r.data.state);
+                        tokens.push(r.data.name);
+                        queue(tokens);
+                    }
+                    reset$d();
+                    return [3 /*break*/, 11];
+                case 3:
+                    b = data$9;
+                    for (_c = 0, b_1 = b; _c < b_1.length; _c++) {
+                        entry = b_1[_c];
+                        tokens.push(entry.id);
+                        tokens.push(entry.width);
+                        tokens.push(entry.height);
+                    }
+                    reset$f();
+                    queue(tokens);
+                    return [3 /*break*/, 11];
+                case 4:
+                    // Check if we are operating within the context of the current page
+                    if (state$6(timer) === 2 /* Stop */) {
+                        return [3 /*break*/, 11];
+                    }
+                    values = updates$2();
+                    if (!(values.length > 0)) return [3 /*break*/, 10];
+                    _d = 0, values_1 = values;
+                    _f.label = 5;
+                case 5:
+                    if (!(_d < values_1.length)) return [3 /*break*/, 9];
+                    value = values_1[_d];
+                    state = state$6(timer);
+                    if (!(state === 0 /* Wait */)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, suspend$1(timer)];
+                case 6:
+                    state = _f.sent();
+                    _f.label = 7;
+                case 7:
+                    if (state === 2 /* Stop */) {
+                        return [3 /*break*/, 9];
+                    }
+                    data = value.data;
+                    active = value.metadata.active;
+                    privacy = value.metadata.privacy;
+                    mangle = shouldMangle(value);
+                    keys = active ? ["tag", "path", "attributes", "value"] : ["tag"];
+                    compute$5(value.id);
+                    for (_e = 0, keys_1 = keys; _e < keys_1.length; _e++) {
+                        key = keys_1[_e];
+                        if (data[key]) {
+                            switch (key) {
+                                case "tag":
+                                    size = value.metadata.size;
+                                    factor = mangle ? -1 : 1;
+                                    tokens.push(value.id * factor);
+                                    if (value.parent && active) {
+                                        tokens.push(value.parent);
+                                    }
+                                    if (value.previous && active) {
+                                        tokens.push(value.previous);
+                                    }
+                                    tokens.push(value.position ? data[key] + "~" + value.position : data[key]);
+                                    if (size && size.length === 2) {
+                                        tokens.push("" + "#" /* Box */ + str(size[0]) + "." + str(size[1]));
+                                    }
+                                    break;
+                                case "path":
+                                    tokens.push(value.data.path + ">");
+                                    break;
+                                case "attributes":
+                                    for (attr in data[key]) {
+                                        if (data[key][attr] !== undefined) {
+                                            tokens.push(attribute(attr, data[key][attr], privacy));
+                                        }
+                                    }
+                                    break;
+                                case "value":
+                                    tokens.push(scrub(data[key], data.tag, privacy, mangle));
+                                    break;
+                            }
+                        }
+                    }
+                    _f.label = 8;
+                case 8:
+                    _d++;
+                    return [3 /*break*/, 5];
+                case 9:
+                    if (type === 6 /* Mutation */) {
+                        activity(eventTime);
+                    }
+                    queue(tokenize(tokens), !config$1.lean);
+                    _f.label = 10;
+                case 10: return [3 /*break*/, 11];
+                case 11: return [2 /*return*/];
+            }
+        });
+    });
+}
+function shouldMangle(value) {
+    var privacy = value.metadata.privacy;
+    return value.data.tag === "*T" /* TextTag */ && !(privacy === 0 /* None */ || privacy === 1 /* Sensitive */);
+}
+function str(input) {
+    return input.toString(36);
+}
+function attribute(key, value, privacy) {
+    return key + "=" + scrub(value, key, privacy);
+}
+
+var data$9 = [];
+var enabled = false;
+var observer$2 = null;
+function start$q() {
+    reset$f();
+    observer$2 = null;
+    enabled = window["ResizeObserver"] ? true : false;
+}
+function compute$5(id) {
+    if (enabled === false) {
+        return;
+    }
+    observer$2 = observer$2 === null ? new ResizeObserver(handler$4) : observer$2;
+    if (observer$2) {
+        var value = getValue(id);
+        // If this is the first time computing size for this node, go ahead and wire up ResizeObserver
+        // In all other cases, value.metadata.size will be null or an array with two elements [width, height]
+        // And, in those cases, we will skip through the following section and not attach the observer
+        if (value && value.metadata.size !== null && value.metadata.size.length === 0) {
+            var node = getNode(id);
+            if (node && node.nodeType === Node.ELEMENT_NODE) {
+                var e = node;
+                var r = e.getBoundingClientRect();
+                value.metadata.size = [Math.floor(r.width * 100 /* BoxPrecision */), Math.floor(r.height * 100 /* BoxPrecision */)];
+                observer$2.observe(e);
+            }
+        }
+    }
+}
+function handler$4(entries) {
+    window.requestAnimationFrame(function () {
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var entry = entries_1[_i];
+            var target = entry.target;
+            var id = target ? getId(target) : null;
+            if (id) {
+                var v = getValue(id);
+                var s = v.metadata.size;
+                var b = entry.borderBoxSize;
+                var w = null;
+                var h = null;
+                // Check if browser supports borderBoxSize property on ResizeObserverEntry object
+                // Otherwise, fall back to using getBoundingClientRect() to be cross browser compatible
+                // Reference: https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry/borderBoxSize
+                if (b && b.length > 0) {
+                    w = Math.floor(b[0].inlineSize * 100 /* BoxPrecision */);
+                    h = Math.floor(b[0].blockSize * 100 /* BoxPrecision */);
+                }
+                else {
+                    var r = target.getBoundingClientRect();
+                    w = Math.floor(r.width * 100 /* BoxPrecision */);
+                    h = Math.floor(r.height * 100 /* BoxPrecision */);
+                }
+                // Capture new width & height only if they are different from what we have in in-memory cache
+                if (w !== s[0] && h !== s[1]) {
+                    s = [w, h];
+                    data$9.push({ id: id, width: w, height: h });
+                }
+            }
+        }
+        // Schedule encode only when we have at least one valid data entry
+        if (data$9.length > 0) {
+            encode$4(37 /* Box */);
+        }
+    });
+}
+function reset$f() {
+    data$9 = [];
+}
+function stop$o() {
+    reset$f();
+    if (observer$2) {
+        observer$2.disconnect();
+        observer$2 = null;
+    }
+    enabled = false;
+}
+
+var history$4 = {};
+var data$8;
+function start$p() {
+    bind(window, "error", handler$3);
+    history$4 = {};
+}
+function handler$3(error) {
+    var e = error["error"] || error;
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure first few times and not spam logs with redundant information.
+    if (!(e.message in history$4)) {
+        history$4[e.message] = 0;
+    }
+    if (history$4[e.message]++ >= 5 /* ScriptErrorLimit */) {
+        return true;
+    }
+    // Send back information only if the handled error has valid information
+    if (e && e.message) {
+        data$8 = {
+            message: e.message,
+            line: error["lineno"],
+            column: error["colno"],
+            stack: e.stack,
+            source: error["filename"]
+        };
+        // In certain cases, ResizeObserver could lead to flood of benign errors - especially when video element is involved.
+        // Reference Chromium issue: https://bugs.chromium.org/p/chromium/issues/detail?id=809574
+        // Even though it doesn't impact user experience, or show up in console, it can still flood error reporting through on error
+        // To mitigate that, we turn off Clarity's ResizeObserver on getting the first instance of this error
+        if (e.message.indexOf("ResizeObserver" /* ResizeObserver */) >= 0) {
+            stop$o();
+            return false;
+        }
+        encode$3(31 /* ScriptError */);
+    }
+    return true;
+}
+
+function encode$3 (type) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tokens, imageTarget;
+        return __generator(this, function (_a) {
+            tokens = [time(), type];
+            switch (type) {
+                case 31 /* ScriptError */:
+                    tokens.push(data$8.message);
+                    tokens.push(data$8.line);
+                    tokens.push(data$8.column);
+                    tokens.push(data$8.stack);
+                    tokens.push(data$8.source);
+                    queue(tokens);
+                    break;
+                case 32 /* ImageError */:
+                    if (data$b) {
+                        imageTarget = metadata(data$b.target, type);
+                        tokens.push(data$b.source);
+                        tokens.push(imageTarget.id);
+                        queue(tokens);
+                    }
+                    break;
+                case 33 /* Log */:
+                    if (data$7) {
+                        tokens.push(data$7.code);
+                        tokens.push(data$7.name);
+                        tokens.push(data$7.message);
+                        tokens.push(data$7.stack);
+                        tokens.push(data$7.severity);
+                        queue(tokens, false);
+                    }
+                    break;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+
+var history$3 = {};
+var data$7;
+function start$o() {
+    history$3 = {};
+    bind(document, "securitypolicyviolation", csp);
+}
+function log(code, severity, name, message, stack) {
+    if (name === void 0) { name = null; }
+    if (message === void 0) { message = null; }
+    if (stack === void 0) { stack = null; }
+    var key = name ? name + "|" + message : "";
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure once and not spam logs with redundant information.
+    if (code in history$3 && history$3[code].indexOf(key) >= 0) {
+        return;
+    }
+    data$7 = { code: code, name: name, message: message, stack: stack, severity: severity };
+    // Maintain history of errors in memory to avoid sending redundant information
+    if (code in history$3) {
+        history$3[code].push(key);
+    }
+    else {
+        history$3[code] = [key];
+    }
+    encode$3(33 /* Log */);
+}
+function csp(e) {
+    var upload = config$1.upload;
+    var parts = upload ? upload.substr(0, upload.indexOf("/", "https://" /* HTTPS */.length)).split("." /* Dot */) : []; // Look for first "/" starting after initial "https://" string
+    var domain = parts.length >= 2 ? parts.splice(-2).join("." /* Dot */) : null;
+    // Capture content security policy violation only if disposition value is not explicitly set to "report"
+    if (domain && e.blockedURI && e.blockedURI.indexOf(domain) >= 0 && e["disposition"] !== "report" /* Report */) {
+        log(7 /* ContentSecurityPolicy */, 1 /* Warning */, e.blockedURI);
+    }
+}
+function stop$n() {
+    history$3 = {};
+}
+
+var formatRegex = /1/g;
+var digitsRegex$1 = /[^0-9\.]/g;
+var digitsWithCommaRegex = /[^0-9\.,]/g;
+var regexCache = {};
+function regions$1(root, value) {
+    var _loop_1 = function (v) {
+        var regionId = v[0], selector = v[1], filter = v[2], match = v[3];
+        var valid = true;
+        switch (filter) {
+            case 0 /* Url */:
+                valid = match && !!top.location.href.match(regex(match));
+                break;
+            case 1 /* Javascript */:
+                valid = match && !!evaluate(match);
+                break;
+        }
+        if (valid) {
+            root.querySelectorAll(selector).forEach(function (e) { return observe$9(e, regionId.toString()); });
+        }
+    };
+    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+        var v = value_1[_i];
+        _loop_1(v);
+    }
+}
+function metrics(root, value) {
+    var _loop_2 = function (v) {
+        var metricId = v[0], source = v[1], match = v[2], scale = v[3];
+        if (match) {
+            switch (source) {
+                case 0 /* Text */:
+                    root.querySelectorAll(match).forEach(function (e) { max(metricId, num$1(e.innerText, scale)); });
+                    break;
+                case 2 /* Attribute */:
+                    root.querySelectorAll("[" + match + "]").forEach(function (e) { max(metricId, num$1(e.getAttribute(match), scale, false)); });
+                    break;
+                case 1 /* Javascript */:
+                    max(metricId, evaluate(match, "number" /* Number */));
+                    break;
+            }
+        }
+    };
+    for (var _i = 0, value_2 = value; _i < value_2.length; _i++) {
+        var v = value_2[_i];
+        _loop_2(v);
+    }
+}
+function regex(match) {
+    regexCache[match] = match in regexCache ? regexCache[match] : new RegExp(match);
+    return regexCache[match];
+}
+// The function below takes in a variable name in following format: "a.b.c" and safely evaluates its value in javascript context
+// For instance, for a.b.c, it will first check window["a"]. If it exists, it will recursively look at: window["a"]["b"] and finally,
+// return the value for window["a"]["b"]["c"].
+function evaluate(variable, type, base) {
+    if (type === void 0) { type = null; }
+    if (base === void 0) { base = window; }
+    var parts = variable.split("." /* Dot */);
+    var first = parts.shift();
+    if (base && base[first]) {
+        if (parts.length > 0) {
+            return evaluate(parts.join("." /* Dot */), type, base[first]);
+        }
+        var output = type === null || type === typeof base[first] ? base[first] : null;
+        return output;
+    }
+    return null;
+}
+function num$1(text, scale, localize) {
+    if (localize === void 0) { localize = true; }
+    try {
+        scale = scale || 1;
+        // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+        var lang = document.documentElement.lang;
+        if (Intl && Intl.NumberFormat && lang && localize) {
+            text = text.replace(digitsWithCommaRegex, "" /* Empty */);
+            // Infer current group and decimal separator from current locale
+            var group = Intl.NumberFormat(lang).format(11111).replace(formatRegex, "" /* Empty */);
+            var decimal = Intl.NumberFormat(lang).format(1.1).replace(formatRegex, "" /* Empty */);
+            // Parse number using inferred group and decimal separators
+            return Math.round(parseFloat(text
+                .replace(new RegExp('\\' + group, 'g'), "" /* Empty */)
+                .replace(new RegExp('\\' + decimal), "." /* Dot */)) * scale);
+        }
+        // Fallback to en locale
+        return Math.round(parseFloat(text.replace(digitsRegex$1, "" /* Empty */)) * scale);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+
+function selector (tag, prefix, attributes, position) {
+    var suffix = position ? ":nth-of-type(" + position + ")" : "" /* Empty */;
+    switch (tag) {
+        case "STYLE":
+        case "TITLE":
+        case "LINK":
+        case "META":
+        case "*T" /* TextTag */:
+        case "*D" /* DocumentTag */:
+            return "" /* Empty */;
+        case "HTML":
+            return "HTML" /* HTML */;
+        default:
+            if (prefix === null) {
+                return "" /* Empty */;
+            }
+            tag = tag.indexOf("svg:" /* SvgPrefix */) === 0 ? tag.substr("svg:" /* SvgPrefix */.length) : tag;
+            var selector = "" + prefix + tag + suffix;
+            if ("class" /* Class */ in attributes && attributes["class" /* Class */].length > 0) {
+                selector = "" + prefix + tag + "." + attributes.class.trim().split(/\s+/).join(".") + suffix;
+            }
+            return selector;
+    }
+}
+
+var index = 1;
+// Reference: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Input#%3Cinput%3E_types
+var DISALLOWED_TYPES = ["password", "hidden", "email", "tel"];
+var DISALLOWED_NAMES = ["addr", "cell", "code", "dob", "email", "mob", "name", "phone", "secret", "social", "ssn", "tel", "zip", "pass"];
+var DISALLOWED_MATCH = ["address", "password", "contact"];
+var nodes = [];
+var values = [];
+var changes = [];
+var updateMap = [];
+var selectorMap = [];
+// The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced
+var idMap = null; // Maps node => id.
+var iframeMap = null; // Maps iframe's contentDocument => parent iframe element
+var privacyMap = null; // Maps node => Privacy (enum)
+var urlMap = {};
+function start$n() {
+    reset$e();
+    parse(document);
+}
+function stop$m() {
+    reset$e();
+}
+function reset$e() {
+    index = 1;
+    nodes = [];
+    values = [];
+    updateMap = [];
+    changes = [];
+    selectorMap = [];
+    urlMap = {};
+    idMap = new WeakMap();
+    iframeMap = new WeakMap();
+    privacyMap = new WeakMap();
+    if ("__CLARITY_DEVTOOLS_HOOK__" /* DevHook */ in window) {
+        window["__CLARITY_DEVTOOLS_HOOK__" /* DevHook */] = { get: get, getNode: getNode, history: history$2 };
+    }
+}
+// We parse new root nodes for any regions or masked nodes in the beginning (document) and
+// later whenever there are new additions or modifications to DOM (mutations)
+function parse(root) {
+    // Wrap selectors in a try / catch block.
+    // It's possible for script to receive invalid selectors, e.g. "'#id'" with extra quotes, and cause the code below to fail
+    try {
+        // 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) {
+            regions$1(root, config$1.regions);
+            metrics(root, config$1.metrics);
+            config$1.mask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 3 /* TextImage */); }); }); // Masked Elements
+            config$1.unmask.forEach(function (x) { return root.querySelectorAll(x).forEach(function (e) { return privacyMap.set(e, 0 /* None */); }); }); // Unmasked Elements
+        }
+    }
+    catch (e) {
+        log(5 /* Selector */, 1 /* Warning */, e ? e.name : null);
+    }
+}
+function getId(node, autogen) {
+    if (autogen === void 0) { autogen = false; }
+    if (node === null) {
+        return null;
+    }
+    var id = idMap.get(node);
+    if (!id && autogen) {
+        id = index++;
+        idMap.set(node, id);
+    }
+    return id ? id : null;
+}
+function add(node, parent, data, source) {
+    var id = getId(node, true);
+    var parentId = parent ? getId(parent) : null;
+    var previousId = getPreviousId(node);
+    var privacy = config$1.content ? 1 /* Sensitive */ : 2 /* Text */;
+    var parentValue = null;
+    var parentTag = "" /* Empty */;
+    var regionId = exists(node) ? id : null;
+    if (parentId >= 0 && values[parentId]) {
+        parentValue = values[parentId];
+        parentTag = parentValue.data.tag;
+        parentValue.children.push(id);
+        regionId = regionId === null ? parentValue.region : regionId;
+        privacy = parentValue.metadata.privacy;
+    }
+    // Check to see if this particular node should be masked or not
+    privacy = getPrivacy(node, data, parentTag, privacy);
+    // If there's an explicit region attribute set on the element, use it to mark a region on the page
+    if (data.attributes && "data-clarity-region" /* RegionData */ in data.attributes) {
+        observe$9(node, data.attributes["data-clarity-region" /* RegionData */]);
+        regionId = id;
+    }
+    nodes[id] = node;
+    values[id] = {
+        id: id,
+        parent: parentId,
+        previous: previousId,
+        children: [],
+        position: null,
+        data: data,
+        selector: "" /* Empty */,
+        region: regionId,
+        metadata: { active: true, privacy: privacy, size: null }
+    };
+    updateSelector(values[id]);
+    size(values[id], parentValue);
+    metadata$1(data.tag, id, parentId);
+    track$4(id, source);
+}
+function update(node, parent, data, source) {
+    var id = getId(node);
+    var parentId = parent ? getId(parent) : null;
+    var previousId = getPreviousId(node);
+    var changed = false;
+    var parentChanged = false;
+    if (id in values) {
+        var value = values[id];
+        value.metadata.active = true;
+        // Handle case where internal ordering may have changed
+        if (value.previous !== previousId) {
+            changed = true;
+            value.previous = previousId;
+        }
+        // Handle case where parent might have been updated
+        if (value.parent !== parentId) {
+            changed = true;
+            var oldParentId = value.parent;
+            value.parent = parentId;
+            // Move this node to the right location under new parent
+            if (parentId !== null && parentId >= 0) {
+                var childIndex = previousId === null ? 0 : values[parentId].children.indexOf(previousId) + 1;
+                values[parentId].children.splice(childIndex, 0, id);
+                // Update region after the move
+                value.region = exists(node) ? id : values[parentId].region;
+            }
+            else {
+                // Mark this element as deleted if the parent has been updated to null
+                remove(id, source);
+            }
+            // Remove reference to this node from the old parent
+            if (oldParentId !== null && oldParentId >= 0) {
+                var nodeIndex = values[oldParentId].children.indexOf(id);
+                if (nodeIndex >= 0) {
+                    values[oldParentId].children.splice(nodeIndex, 1);
+                }
+            }
+            parentChanged = true;
+        }
+        // Update data
+        for (var key in data) {
+            if (diff(value["data"], data, key)) {
+                changed = true;
+                value["data"][key] = data[key];
+            }
+        }
+        // Update selector
+        updateSelector(value);
+        metadata$1(data.tag, id, parentId);
+        track$4(id, source, changed, parentChanged);
+    }
+}
+function sameorigin(node) {
+    var output = false;
+    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.
+        // However, if we do a get a valid document object back, we assume the contents are accessible and iframe is same-origin.
+        try {
+            var doc = frame.contentDocument;
+            if (doc) {
+                iframeMap.set(frame.contentDocument, frame);
+                output = true;
+            }
+        }
+        catch ( /* do nothing */_a) { /* do nothing */ }
+    }
+    return output;
+}
+function iframe(node) {
+    var doc = node.nodeType === Node.DOCUMENT_NODE ? node : null;
+    return doc && iframeMap.has(doc) ? iframeMap.get(doc) : null;
+}
+function getPrivacy(node, data, parentTag, privacy) {
+    var attributes = data.attributes;
+    var tag = data.tag.toUpperCase();
+    // If this node was explicitly configured to contain sensitive content, use that information and return the value
+    if (privacyMap.has(node)) {
+        return privacyMap.get(node);
+    }
+    // Do not proceed if attributes are missing for the node
+    if (attributes === null || attributes === undefined) {
+        return privacy;
+    }
+    // Look up for sensitive fields
+    if ("class" /* Class */ in attributes && privacy === 1 /* Sensitive */) {
+        for (var _i = 0, DISALLOWED_MATCH_1 = DISALLOWED_MATCH; _i < DISALLOWED_MATCH_1.length; _i++) {
+            var match = DISALLOWED_MATCH_1[_i];
+            if (attributes["class" /* Class */].indexOf(match) >= 0) {
+                privacy = 2 /* Text */;
+                break;
+            }
+        }
+    }
+    // Check for disallowed list of fields (e.g. address, phone, etc.) only if the input node is not already masked
+    if (tag === "INPUT" /* InputTag */) {
+        if (privacy === 0 /* None */) {
+            var field = "" /* Empty */;
+            // Be aggressive in looking up any attribute (id, class, name, etc.) for disallowed names
+            for (var _a = 0, _b = Object.keys(attributes); _a < _b.length; _a++) {
+                var attribute = _b[_a];
+                field += attributes[attribute].toLowerCase();
+            }
+            for (var _c = 0, DISALLOWED_NAMES_1 = DISALLOWED_NAMES; _c < DISALLOWED_NAMES_1.length; _c++) {
+                var name_1 = DISALLOWED_NAMES_1[_c];
+                if (field.indexOf(name_1) >= 0) {
+                    privacy = 2 /* Text */;
+                    break;
+                }
+            }
+        }
+        else if (privacy === 1 /* Sensitive */) {
+            // Mask all input fields with an exception of type=submit; since they do not accept user input
+            privacy = attributes && attributes["type" /* Type */] === "submit" /* Submit */ ? 0 /* None */ : 2 /* Text */;
+        }
+    }
+    // Check for disallowed list of types (e.g. password, email, etc.) and set the masked property appropriately
+    if ("type" /* Type */ in attributes && DISALLOWED_TYPES.indexOf(attributes["type" /* Type */]) >= 0) {
+        privacy = 2 /* Text */;
+    }
+    // Following two conditions supersede any of the above. If there are explicit instructions to mask / unmask a field, we honor that.
+    if ("data-clarity-mask" /* MaskData */ in attributes) {
+        privacy = 3 /* TextImage */;
+    }
+    if ("data-clarity-unmask" /* UnmaskData */ in attributes) {
+        privacy = 0 /* None */;
+    }
+    // If it's a text node belonging to a STYLE or TITLE tag; then reset the privacy setting to ensure we capture the content
+    var cTag = tag === "*T" /* TextTag */ ? parentTag : tag;
+    if (cTag === "STYLE" /* StyleTag */ || cTag === "TITLE" /* TitleTag */) {
+        privacy = 0 /* None */;
+    }
+    return privacy;
+}
+function diff(a, b, field) {
+    if (typeof a[field] === "object" && typeof b[field] === "object") {
+        for (var key in a[field]) {
+            if (a[field][key] !== b[field][key]) {
+                return true;
+            }
+        }
+        for (var key in b[field]) {
+            if (b[field][key] !== a[field][key]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return a[field] !== b[field];
+}
+function position(parent, child) {
+    var tag = child.data.tag;
+    var hasClassName = child.data.attributes && !("class" /* Class */ in child.data.attributes);
+    // Find relative position of the element to generate :nth-of-type selector
+    // We restrict relative positioning to two cases:
+    //   a) For specific whitelist of tags
+    //   b) And, for remaining tags, only if they don't have a valid class name
+    if (parent && (["DIV", "TR", "P", "LI", "UL", "A", "BUTTON"].indexOf(tag) >= 0 || hasClassName)) {
+        child.position = 1;
+        var idx = parent ? parent.children.indexOf(child.id) : -1;
+        while (idx-- > 0) {
+            var sibling = values[parent.children[idx]];
+            if (child.data.tag === sibling.data.tag) {
+                child.position = sibling.position + 1;
+                break;
+            }
+        }
+    }
+    return child.position;
+}
+function updateSelector(value) {
+    var parent = value.parent && value.parent in values ? values[value.parent] : null;
+    var prefix = parent ? parent.selector + ">" : null;
+    var ex = value.selector;
+    var current = selector(value.data.tag, prefix, value.data.attributes, position(parent, value));
+    if (current !== ex && selectorMap.indexOf(value.id) === -1) {
+        selectorMap.push(value.id);
+    }
+    value.selector = current;
+}
+function getNode(id) {
+    if (id in nodes) {
+        return nodes[id];
+    }
+    return null;
+}
+function getMatch(url) {
+    if (url in urlMap) {
+        return getNode(urlMap[url]);
+    }
+    return null;
+}
+function getValue(id) {
+    if (id in values) {
+        return values[id];
+    }
+    return null;
+}
+function get(node) {
+    var id = getId(node);
+    return id in values ? values[id] : null;
+}
+function has(node) {
+    return getId(node) in nodes;
+}
+function updates$2() {
+    var output = [];
+    for (var _i = 0, updateMap_1 = updateMap; _i < updateMap_1.length; _i++) {
+        var id = updateMap_1[_i];
+        if (id in values) {
+            var v = values[id];
+            var p = v.parent;
+            v.data.path = p === null || updateMap.indexOf(p) >= 0 || v.selector.length === 0 ? null : values[p].selector;
+            output.push(values[id]);
+        }
+    }
+    updateMap = [];
+    return output;
+}
+function remove(id, source) {
+    if (id in values) {
+        var value = values[id];
+        value.metadata.active = false;
+        value.parent = null;
+        track$4(id, source);
+    }
+}
+function size(value, parent) {
+    var data = value.data;
+    var tag = data.tag;
+    // If this element is a text node, is masked, and longer than configured length, then track box model for the parent element
+    var isLongText = tag === "*T" /* TextTag */ && data.value && data.value.length > 15 /* ResizeObserverThreshold */;
+    var isMasked = value.metadata.privacy === 2 /* Text */ || value.metadata.privacy === 3 /* TextImage */;
+    if (isLongText && isMasked && parent && parent.metadata.size === null) {
+        parent.metadata.size = [];
+    }
+    // If this element is a image node, and is masked, then track box model for the current element
+    if (data.tag === "IMG" /* ImageTag */ && value.metadata.privacy === 3 /* TextImage */) {
+        value.metadata.size = [];
+    }
+}
+function metadata$1(tag, id, parentId) {
+    if (id !== null && parentId !== null) {
+        var value = values[id];
+        var attributes = "attributes" in value.data ? value.data.attributes : {};
+        switch (tag) {
+            case "VIDEO":
+            case "AUDIO":
+            case "LINK":
+                // Track mapping between URL and corresponding nodes
+                if ("href" /* Href */ in attributes && attributes["href" /* Href */].length > 0) {
+                    urlMap[getFullUrl(attributes["href" /* Href */])] = id;
+                }
+                if ("src" /* Src */ in attributes && attributes["src" /* Src */].length > 0) {
+                    if (attributes["src" /* Src */].indexOf("data:" /* DataPrefix */) !== 0) {
+                        urlMap[getFullUrl(attributes["src" /* Src */])] = id;
+                    }
+                }
+                if ("srcset" /* Srcset */ in attributes && attributes["srcset" /* Srcset */].length > 0) {
+                    var srcset = attributes["srcset" /* Srcset */];
+                    var urls = srcset.split(",");
+                    for (var _i = 0, urls_1 = urls; _i < urls_1.length; _i++) {
+                        var u = urls_1[_i];
+                        var parts = u.trim().split(" ");
+                        if (parts.length === 2 && parts[0].length > 0) {
+                            urlMap[getFullUrl(parts[0])] = id;
+                        }
+                    }
+                }
+                break;
+        }
+    }
+}
+function getFullUrl(relative) {
+    var a = document.createElement("a");
+    a.href = relative;
+    return a.href;
+}
+function getPreviousId(node) {
+    var id = null;
+    // Some nodes may not have an ID by design since Clarity skips over tags like SCRIPT, NOSCRIPT, META, COMMENTS, etc..
+    // In that case, we keep going back and check for their sibling until we find a sibling with ID or no more sibling nodes are left.
+    while (id === null && node.previousSibling) {
+        id = getId(node.previousSibling);
+        node = node.previousSibling;
+    }
+    return id;
+}
+function copy(input) {
+    return JSON.parse(JSON.stringify(input));
+}
+function track$4(id, source, changed, parentChanged) {
+    if (changed === void 0) { changed = true; }
+    if (parentChanged === void 0) { parentChanged = false; }
+    // Keep track of the order in which mutations happened, they may not be sequential
+    // Edge case: If an element is added later on, and pre-discovered element is moved as a child.
+    // In that case, we need to reorder the pre-discovered element in the update list to keep visualization consistent.
+    var uIndex = updateMap.indexOf(id);
+    if (uIndex >= 0 && source === 1 /* ChildListAdd */ && parentChanged) {
+        updateMap.splice(uIndex, 1);
+        updateMap.push(id);
+    }
+    else if (uIndex === -1 && changed) {
+        updateMap.push(id);
+    }
+    if ("__CLARITY_DEVTOOLS_HOOK__" /* DevHook */ in window) {
+        var value = copy([values[id]])[0];
+        var change = { time: time(), source: source, value: value };
+        if (!(id in changes)) {
+            changes[id] = [];
+        }
+        changes[id].push(change);
+    }
+}
+function history$2(id) {
+    if (id in changes) {
+        return changes[id];
+    }
+    return [];
+}
+
+var dom = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    start: start$n,
+    stop: stop$m,
+    parse: parse,
+    getId: getId,
+    add: add,
+    update: update,
+    sameorigin: sameorigin,
+    iframe: iframe,
+    getNode: getNode,
+    getMatch: getMatch,
+    getValue: getValue,
+    get: get,
+    has: has,
+    updates: updates$2
+});
+
+var state$5 = [];
+var regionMap = null; // Maps region nodes => region name
+var regions = {};
+var queue$2 = [];
+var watch = false;
+var observer$1 = null;
+function start$m() {
+    reset$d();
+    observer$1 = null;
+    regionMap = new WeakMap();
+    regions = {};
+    queue$2 = [];
+    watch = window["IntersectionObserver"] ? true : false;
+}
+function observe$9(node, name) {
+    if (regionMap.has(node) === false) {
+        regionMap.set(node, name);
+        observer$1 = observer$1 === null && watch ? new IntersectionObserver(handler$2, {
+            // Get notified as intersection continues to change
+            // This allows us to process regions that get partially hidden during the lifetime of the page
+            // See: https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API#creating_an_intersection_observer
+            // By default, intersection observers only fire an event when even a single pixel is visible and not thereafter.
+            threshold: [0, 0.2, 0.4, 0.6, 0.8, 1]
+        }) : observer$1;
+        if (observer$1 && node && node.nodeType === Node.ELEMENT_NODE) {
+            observer$1.observe(node);
+        }
+    }
+}
+function exists(node) {
+    // Check if regionMap is not null before looking up a node
+    // Since, dom module stops after region module, it's possible that we may set regionMap to be null
+    // and still attempt to call exists on a late coming DOM mutation (or addition), effectively causing a script error
+    return regionMap && regionMap.has(node);
+}
+function track$3(id, event) {
+    var node = getNode(id);
+    var data = id in regions ? regions[id] : { id: id, state: 0 /* Rendered */, name: regionMap.get(node) };
+    // Determine the interaction state based on incoming event
+    var interactionState = 0 /* Rendered */;
+    switch (event) {
+        case 9 /* Click */:
+            interactionState = 20 /* Clicked */;
+            break;
+        case 27 /* Input */:
+            interactionState = 30 /* Input */;
+            break;
+    }
+    // Process updates to this region, if applicable
+    process$6(node, data, interactionState);
+}
+function compute$4() {
+    // Process any regions where we couldn't resolve an "id" for at the time of last intersection observer event
+    // This could happen in cases where elements are not yet processed by Clarity's virtual DOM but browser reports a change, regardless.
+    // For those cases we add them to the queue and re-process them below
+    var q = [];
+    for (var _i = 0, queue_1 = queue$2; _i < queue_1.length; _i++) {
+        var r = queue_1[_i];
+        var id = getId(r.node);
+        if (!(id in regions)) {
+            if (id) {
+                r.data.id = id;
+                regions[id] = r.data;
+                state$5.push(clone(r.data));
+            }
+            else {
+                q.push(r);
+            }
+        }
+    }
+    queue$2 = q;
+    // Schedule encode only when we have at least one valid data entry
+    if (state$5.length > 0) {
+        encode$4(7 /* Region */);
+    }
+}
+function handler$2(entries) {
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var entry = entries_1[_i];
+        var target = entry.target;
+        var rect = entry.boundingClientRect;
+        var overlap = entry.intersectionRect;
+        var viewport = entry.rootBounds;
+        // Only capture regions that have non-zero width or height to avoid tracking and sending regions
+        // that cannot ever be seen by the user. In some cases, websites will have a multiple copy of the same region
+        // like search box - one for desktop, and another for mobile. In those cases, CSS media queries determine which one should be visible.
+        // 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), state: 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.25 /* ViewportIntersectionRatio */ || entry.intersectionRatio > 0.8 /* IntersectionRatio */;
+            // Process updates to this region, if applicable
+            process$6(target, data, visible ? 10 /* Visible */ : 0 /* Rendered */);
+            // Stop observing this element now that we have already received visibility signal
+            if (data.state >= 10 /* Visible */ && observer$1) {
+                observer$1.unobserve(target);
+            }
+        }
+    }
+    if (state$5.length > 0) {
+        encode$4(7 /* Region */);
+    }
+}
+function process$6(n, d, s) {
+    // Check if received a state that supersedes existing state
+    var updated = s > d.state;
+    d.state = updated ? s : d.state;
+    // If the corresponding node is already discovered, update the internal state
+    // Otherwise, track it in a queue to reprocess later.
+    if (d.id) {
+        if ((d.id in regions && updated) || !(d.id in regions)) {
+            regions[d.id] = d;
+            state$5.push(clone(d));
+        }
+    }
+    else {
+        queue$2.push({ node: n, data: d });
+    }
+}
+function clone(r) {
+    return { time: time(), data: { id: r.id, state: r.state, name: r.name } };
+}
+function reset$d() {
+    state$5 = [];
+}
+function stop$l() {
+    reset$d();
+    regionMap = null;
+    regions = {};
+    queue$2 = [];
+    if (observer$1) {
+        observer$1.disconnect();
+        observer$1 = null;
+    }
+    watch = false;
+}
+
+function offset (element) {
+    var output = { x: 0, y: 0 };
+    // Walk up the chain to ensure we compute offset distance correctly
+    // In case where we may have nested IFRAMEs, we keep walking up until we get to the top most parent page
+    if (element && element.offsetParent) {
+        do {
+            var parent_1 = element.offsetParent;
+            var frame = parent_1 === null ? iframe(element.ownerDocument) : null;
+            output.x += element.offsetLeft;
+            output.y += element.offsetTop;
+            element = frame ? frame : parent_1;
+        } while (element);
+    }
+    return output;
+}
+
+var UserInputTags = ["input", "textarea", "radio", "button", "canvas"];
+var state$4 = [];
+function start$l() {
+    reset$c();
+}
+function observe$8(root) {
+    bind(root, "click", handler$1.bind(this, 9 /* Click */, root), true);
+}
+function handler$1(event, root, evt) {
+    var frame = iframe(root);
+    var d = frame ? frame.contentDocument.documentElement : document.documentElement;
+    var x = "pageX" in evt ? Math.round(evt.pageX) : ("clientX" in evt ? Math.round(evt["clientX"] + d.scrollLeft) : null);
+    var y = "pageY" in evt ? Math.round(evt.pageY) : ("clientY" in evt ? Math.round(evt["clientY"] + d.scrollTop) : null);
+    // In case of iframe, we adjust (x,y) to be relative to top parent's origin
+    if (frame) {
+        var distance = offset(frame);
+        x = x ? x + Math.round(distance.x) : x;
+        y = y ? y + Math.round(distance.y) : y;
+    }
+    var t = target(evt);
+    // Find nearest anchor tag (<a/>) parent if current target node is part of one
+    // If present, we use the returned link element to populate text and link properties below
+    var a = link(t);
+    // Get layout rectangle for the target element
+    var l = layout$1(t);
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/UIEvent/detail
+    // This property helps differentiate between a keyboard navigation vs. pointer click
+    // In case of a keyboard navigation, we use center of target element as (x,y)
+    if (evt.detail === 0 && l) {
+        x = Math.round(l.x + (l.w / 2));
+        y = Math.round(l.y + (l.h / 2));
+    }
+    var eX = l ? Math.max(Math.floor(((x - l.x) / l.w) * 32767 /* ClickPrecision */), 0) : 0;
+    var eY = l ? Math.max(Math.floor(((y - l.y) / l.h) * 32767 /* ClickPrecision */), 0) : 0;
+    // Check for null values before processing this event
+    if (x !== null && y !== null) {
+        state$4.push({
+            time: time(),
+            event: event, data: {
+                target: t,
+                x: x,
+                y: y,
+                eX: eX,
+                eY: eY,
+                button: evt.button,
+                reaction: reaction(t),
+                context: context(a),
+                text: text(t),
+                link: a ? a.href : null,
+                hash: null
+            }
+        });
+        schedule$1(encode$2.bind(this, event));
+    }
+}
+function text(element) {
+    var output = null;
+    if (element) {
+        // Grab text using "textContent" for most HTMLElements, however, use "value" for HTMLInputElements and "alt" for HTMLImageElement.
+        var t = element.textContent || element.value || element.alt;
+        if (t) {
+            // Trim any spaces at the beginning or at the end of string
+            // Also, replace multiple occurrence of space characters with a single white space
+            // Finally, send only first few characters as specified by the Setting
+            output = t.trim().replace(/\s+/g, " " /* Space */).substr(0, 25 /* ClickText */);
+        }
+    }
+    return output;
+}
+function reaction(element) {
+    if (element.nodeType === Node.ELEMENT_NODE) {
+        var tag = element.tagName.toLowerCase();
+        if (UserInputTags.indexOf(tag) >= 0) {
+            return 0 /* False */;
+        }
+    }
+    return 1 /* True */;
+}
+function layout$1(element) {
+    var box = null;
+    var de = document.documentElement;
+    if (typeof element.getBoundingClientRect === "function") {
+        // getBoundingClientRect returns rectangle relative positioning to viewport
+        var rect = element.getBoundingClientRect();
+        if (rect && rect.width > 0 && rect.height > 0) {
+            // Add viewport's scroll position to rectangle to get position relative to document origin
+            // Also: using Math.floor() instead of Math.round() because in Edge,
+            // getBoundingClientRect returns partial pixel values (e.g. 162.5px) and Chrome already
+            // floors the value (e.g. 162px). This keeps consistent behavior across browsers.
+            box = {
+                x: Math.floor(rect.left + ("pageXOffset" in window ? window.pageXOffset : de.scrollLeft)),
+                y: Math.floor(rect.top + ("pageYOffset" in window ? window.pageYOffset : de.scrollTop)),
+                w: Math.floor(rect.width),
+                h: Math.floor(rect.height)
+            };
+        }
+    }
+    return box;
+}
+function context(a) {
+    if (a && a.hasAttribute("target" /* Target */)) {
+        switch (a.getAttribute("target" /* Target */)) {
+            case "_blank" /* Blank */: return 1 /* Blank */;
+            case "_parent" /* Parent */: return 2 /* Parent */;
+            case "_top" /* Top */: return 3 /* Top */;
+        }
+    }
+    return 0 /* Self */;
+}
+function reset$c() {
+    state$4 = [];
+}
+function stop$k() {
+    reset$c();
+}
+
+var timeout$5 = null;
+var state$3 = [];
+function start$k() {
+    reset$b();
+}
+function observe$7(root) {
+    bind(root, "input", recompute$6, true);
+}
+function recompute$6(evt) {
+    var input = target(evt);
+    var value = get(input);
+    if (input && input.type && value) {
+        var v = void 0;
+        switch (input.type) {
+            case "radio":
+            case "checkbox":
+                v = input.checked ? "true" : "false";
+                break;
+            case "range":
+                v = input.value;
+                break;
+            default:
+                v = scrub(input.value, "input", value.metadata.privacy);
+                break;
+        }
+        var data = { target: input, value: v };
+        // If last entry in the queue is for the same target node as the current one, remove it so we can later swap it with current data.
+        if (state$3.length > 0 && (state$3[state$3.length - 1].data.target === data.target)) {
+            state$3.pop();
+        }
+        state$3.push({ time: time(), event: 27 /* Input */, data: data });
+        clearTimeout(timeout$5);
+        timeout$5 = setTimeout(process$5, 500 /* LookAhead */, 27 /* Input */);
+    }
+}
+function process$5(event) {
+    schedule$1(encode$2.bind(this, event));
+}
+function reset$b() {
+    state$3 = [];
+}
+function stop$j() {
+    clearTimeout(timeout$5);
+    reset$b();
+}
+
+var state$2 = [];
+var timeout$4 = null;
+function start$j() {
+    reset$a();
+}
+function observe$6(root) {
+    bind(root, "mousedown", mouse.bind(this, 13 /* MouseDown */, root), true);
+    bind(root, "mouseup", mouse.bind(this, 14 /* MouseUp */, root), true);
+    bind(root, "mousemove", mouse.bind(this, 12 /* MouseMove */, root), true);
+    bind(root, "mousewheel", 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);
+    var d = frame ? frame.contentDocument.documentElement : document.documentElement;
+    var x = "pageX" in evt ? Math.round(evt.pageX) : ("clientX" in evt ? Math.round(evt["clientX"] + d.scrollLeft) : null);
+    var y = "pageY" in evt ? Math.round(evt.pageY) : ("clientY" in evt ? Math.round(evt["clientY"] + d.scrollTop) : null);
+    // In case of iframe, we adjust (x,y) to be relative to top parent's origin
+    if (frame) {
+        var distance = offset(frame);
+        x = x ? x + Math.round(distance.x) : x;
+        y = y ? y + Math.round(distance.y) : y;
+    }
+    // Check for null values before processing this event
+    if (x !== null && y !== null) {
+        handler({ time: time(), event: event, data: { target: target(evt), x: x, y: y } });
+    }
+}
+function touch(event, root, evt) {
+    var frame = iframe(root);
+    var d = frame ? frame.contentDocument.documentElement : document.documentElement;
+    var touches = evt.changedTouches;
+    var t = time();
+    if (touches) {
+        for (var i = 0; i < touches.length; i++) {
+            var entry = touches[i];
+            var x = "clientX" in entry ? Math.round(entry["clientX"] + d.scrollLeft) : null;
+            var y = "clientY" in entry ? Math.round(entry["clientY"] + d.scrollTop) : null;
+            x = x && frame ? x + Math.round(frame.offsetLeft) : x;
+            y = y && frame ? y + Math.round(frame.offsetTop) : y;
+            // Check for null values before processing this event
+            if (x !== null && y !== null) {
+                handler({ time: t, event: event, data: { target: target(evt), x: x, y: y } });
+            }
+        }
+    }
+}
+function handler(current) {
+    switch (current.event) {
+        case 12 /* MouseMove */:
+        case 15 /* MouseWheel */:
+        case 19 /* TouchMove */:
+            var length_1 = state$2.length;
+            var last = length_1 > 1 ? state$2[length_1 - 2] : null;
+            if (last && similar$1(last, current)) {
+                state$2.pop();
+            }
+            state$2.push(current);
+            clearTimeout(timeout$4);
+            timeout$4 = setTimeout(process$4, 500 /* LookAhead */, current.event);
+            break;
+        default:
+            state$2.push(current);
+            process$4(current.event);
+            break;
+    }
+}
+function process$4(event) {
+    schedule$1(encode$2.bind(this, event));
+}
+function reset$a() {
+    state$2 = [];
+}
+function similar$1(last, current) {
+    var dx = last.data.x - current.data.x;
+    var dy = last.data.y - current.data.y;
+    var distance = Math.sqrt(dx * dx + dy * dy);
+    var gap = current.time - last.time;
+    var match = current.data.target === last.data.target;
+    return current.event === last.event && match && distance < 20 /* Distance */ && gap < 25 /* Interval */;
+}
+function stop$i() {
+    clearTimeout(timeout$4);
+    // Send out any pending pointer events in the pipeline
+    if (state$2.length > 0) {
+        process$4(state$2[state$2.length - 1].event);
+    }
+}
+
+var data$6;
+function start$i() {
+    bind(window, "resize", recompute$5);
+    recompute$5();
+}
+function recompute$5() {
+    var de = document.documentElement;
+    // window.innerWidth includes width of the scrollbar and is not a true representation of the viewport width.
+    // Therefore, when possible, use documentElement's clientWidth property.
+    data$6 = {
+        width: de && "clientWidth" in de ? Math.min(de.clientWidth, window.innerWidth) : window.innerWidth,
+        height: de && "clientHeight" in de ? Math.min(de.clientHeight, window.innerHeight) : window.innerHeight,
+    };
+    encode$2(11 /* Resize */);
+}
+function reset$9() {
+    data$6 = null;
+}
+function stop$h() {
+    reset$9();
+}
+
+var state$1 = [];
+var timeout$3 = null;
+function start$h() {
+    state$1 = [];
+    recompute$4();
+}
+function observe$5(root) {
+    var frame = iframe(root);
+    var node = frame ? frame.contentWindow : (root === document ? window : root);
+    bind(node, "scroll", recompute$4, true);
+}
+function recompute$4(event) {
+    if (event === void 0) { event = null; }
+    var w = window;
+    var de = document.documentElement;
+    var element = event ? target(event) : de;
+    // If the target is a Document node, then identify corresponding documentElement and window for this document
+    if (element && element.nodeType === Node.DOCUMENT_NODE) {
+        var frame = iframe(element);
+        w = frame ? frame.contentWindow : w;
+        element = de = element.documentElement;
+    }
+    // Edge doesn't support scrollTop position on document.documentElement.
+    // For cross browser compatibility, looking up pageYOffset on window if the scroll is on document.
+    // And, if for some reason that is not available, fall back to looking up scrollTop on document.documentElement.
+    var x = element === de && "pageXOffset" in w ? Math.round(w.pageXOffset) : Math.round(element.scrollLeft);
+    var y = element === de && "pageYOffset" in w ? Math.round(w.pageYOffset) : Math.round(element.scrollTop);
+    var current = { time: time(), event: 10 /* Scroll */, data: { target: element, x: x, y: y } };
+    // 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;
+    }
+    var length = state$1.length;
+    var last = length > 1 ? state$1[length - 2] : null;
+    if (last && similar(last, current)) {
+        state$1.pop();
+    }
+    state$1.push(current);
+    clearTimeout(timeout$3);
+    timeout$3 = setTimeout(process$3, 500 /* LookAhead */, 10 /* Scroll */);
+}
+function reset$8() {
+    state$1 = [];
+}
+function process$3(event) {
+    schedule$1(encode$2.bind(this, event));
+}
+function similar(last, current) {
+    var dx = last.data.x - current.data.x;
+    var dy = last.data.y - current.data.y;
+    return (dx * dx + dy * dy < 20 /* Distance */ * 20 /* Distance */) && (current.time - last.time < 25 /* Interval */);
+}
+function stop$g() {
+    clearTimeout(timeout$3);
+    state$1 = [];
+}
+
+var data$5 = null;
+var previous = null;
+var timeout$2 = null;
+function start$g() {
+    reset$7();
+}
+function observe$4(root) {
+    bind(root, "selectstart", recompute$3.bind(this, root), true);
+    bind(root, "selectionchange", recompute$3.bind(this, root), true);
+}
+function recompute$3(root) {
+    var doc = root.nodeType === Node.DOCUMENT_NODE ? root : document;
+    var current = doc.getSelection();
+    // Bail out if we don't have a valid selection
+    if (current === null) {
+        return;
+    }
+    // Bail out if we got a valid selection but not valid nodes
+    // In Edge, selectionchange gets fired even on interactions like right clicks and
+    // can result in null anchorNode and focusNode if there was no previous selection on page
+    // Also, ignore any selections that start and end at the exact same point
+    if ((current.anchorNode === null && current.focusNode === null) ||
+        (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)) {
+        return;
+    }
+    var startNode = data$5.start ? data$5.start : null;
+    if (previous !== null && data$5.start !== null && startNode !== current.anchorNode) {
+        clearTimeout(timeout$2);
+        process$2(21 /* Selection */);
+    }
+    data$5 = {
+        start: current.anchorNode,
+        startOffset: current.anchorOffset,
+        end: current.focusNode,
+        endOffset: current.focusOffset
+    };
+    previous = current;
+    clearTimeout(timeout$2);
+    timeout$2 = setTimeout(process$2, 500 /* LookAhead */, 21 /* Selection */);
+}
+function process$2(event) {
+    schedule$1(encode$2.bind(this, event));
+}
+function reset$7() {
+    previous = null;
+    data$5 = { start: 0, startOffset: 0, end: 0, endOffset: 0 };
+}
+function stop$f() {
+    reset$7();
+    clearTimeout(timeout$2);
+}
+
+var data$4;
+function start$f() {
+    bind(window, "pagehide", recompute$2);
+}
+function recompute$2(evt) {
+    data$4 = { name: evt.type };
+    encode$2(26 /* Unload */);
+    stop();
+}
+function reset$6() {
+    data$4 = null;
+}
+function stop$e() {
+    reset$6();
+}
+
+var data$3;
+function start$e() {
+    bind(document, "visibilitychange", recompute$1);
+    recompute$1();
+}
+function recompute$1() {
+    data$3 = { visible: "visibilityState" in document ? document.visibilityState : "default" };
+    encode$2(28 /* Visibility */);
+}
+function reset$5() {
+    data$3 = null;
+}
+function stop$d() {
+    reset$5();
+}
+
+function start$d() {
+    start$b();
+    start$l();
+    start$j();
+    start$k();
+    start$i();
+    start$e();
+    start$h();
+    start$g();
+    start$f();
+}
+function stop$c() {
+    stop$a();
+    stop$k();
+    stop$i();
+    stop$j();
+    stop$h();
+    stop$d();
+    stop$g();
+    stop$f();
+    stop$e();
+}
+function observe$3(root) {
+    observe$5(root);
+    // Only monitor following interactions if the root node is a document
+    // In case of shadow DOM, following events automatically bubble up to the parent document.
+    if (root.nodeType === Node.DOCUMENT_NODE) {
+        observe$8(root);
+        observe$6(root);
+        observe$7(root);
+        observe$4(root);
+    }
+}
+
+var interaction = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    start: start$d,
+    stop: stop$c,
+    observe: observe$3
+});
+
+var digitsRegex = /[^0-9\.]/g;
+/* JSON+LD (Linked Data) Recursive Parser */
+function ld(json) {
+    for (var _i = 0, _a = Object.keys(json); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = json[key];
+        if (key === "@type" /* Type */ && typeof value === "string") {
+            value = value.toLowerCase();
+            /* Normalizations */
+            value = value.indexOf("article" /* Article */) >= 0 || value.indexOf("posting" /* Posting */) >= 0 ? "article" /* Article */ : value;
+            switch (value) {
+                case "article" /* Article */:
+                case "recipe" /* Recipe */:
+                    log$1(5 /* SchemaType */, json[key]);
+                    log$1(8 /* AuthorName */, json["creator" /* Creator */]);
+                    log$1(18 /* Headline */, json["headline" /* Headline */]);
+                    break;
+                case "product" /* Product */:
+                    log$1(5 /* SchemaType */, json[key]);
+                    log$1(10 /* ProductName */, json["name" /* Name */]);
+                    log$1(12 /* ProductSku */, json["sku" /* Sku */]);
+                    if (json["brand" /* Brand */]) {
+                        log$1(6 /* ProductBrand */, json["brand" /* Brand */]["name" /* Name */]);
+                    }
+                    break;
+                case "aggregaterating" /* AggregateRating */:
+                    if (json["ratingValue" /* RatingValue */]) {
+                        max(11 /* RatingValue */, num(json["ratingValue" /* RatingValue */], 100 /* RatingScale */));
+                        max(18 /* BestRating */, num(json["bestRating" /* BestRating */]));
+                        max(19 /* WorstRating */, num(json["worstRating" /* WorstRating */]));
+                    }
+                    max(12 /* RatingCount */, num(json["ratingCount" /* RatingCount */]));
+                    max(17 /* ReviewCount */, num(json["reviewCount" /* ReviewCount */]));
+                    break;
+                case "person" /* Author */:
+                    log$1(8 /* AuthorName */, json["name" /* Name */]);
+                    break;
+                case "offer" /* Offer */:
+                    log$1(7 /* ProductAvailability */, json["availability" /* Availability */]);
+                    log$1(14 /* ProductCondition */, json["itemCondition" /* ItemCondition */]);
+                    log$1(13 /* ProductCurrency */, json["priceCurrency" /* PriceCurrency */]);
+                    log$1(12 /* ProductSku */, json["sku" /* Sku */]);
+                    max(13 /* ProductPrice */, num(json["price" /* Price */]));
+                    break;
+                case "brand" /* Brand */:
+                    log$1(6 /* ProductBrand */, json["name" /* Name */]);
+                    break;
+            }
+        }
+        // Continue parsing nested objects
+        if (value !== null && typeof (value) === "object" /* Object */) {
+            ld(value);
+        }
+    }
+}
+function num(input, scale) {
+    if (scale === void 0) { scale = 1; }
+    if (input !== null) {
+        switch (typeof input) {
+            case "number" /* Number */: return Math.round(input * scale);
+            case "string" /* String */: return Math.round(parseFloat(input.replace(digitsRegex, "" /* Empty */)) * scale);
+        }
+    }
+    return null;
+}
+
+var IGNORE_ATTRIBUTES = ["title", "alt", "onload", "onfocus", "onerror"];
+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 /* ChildListRemove */ && has(node) === false) {
+        return child;
+    }
+    // Special handling for text nodes that belong to style nodes
+    if (source !== 0 /* Discover */ &&
+        node.nodeType === Node.TEXT_NODE &&
+        node.parentElement &&
+        node.parentElement.tagName === "STYLE") {
+        node = node.parentNode;
+    }
+    var add = has(node) === false;
+    var call = add ? "add" : "update";
+    var parent = node.parentElement ? node.parentElement : null;
+    var insideFrame = node.ownerDocument !== document;
+    switch (node.nodeType) {
+        case Node.DOCUMENT_TYPE_NODE:
+            parent = insideFrame && node.parentNode ? iframe(node.parentNode) : parent;
+            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" /* DocumentTag */, attributes: docAttributes };
+            dom[call](node, parent, docData, source);
+            break;
+        case Node.DOCUMENT_NODE:
+            // We check for regions in the beginning when discovering document and
+            // later whenever there are new additions or modifications to DOM (mutations)
+            if (node === document)
+                parse(document);
+            observe$2(node);
+            break;
+        case Node.DOCUMENT_FRAGMENT_NODE:
+            var shadowRoot = node;
+            if (shadowRoot.host) {
+                var type = typeof (shadowRoot.constructor);
+                if (type === "function" /* Function */ && shadowRoot.constructor.toString().indexOf("[native code]" /* NativeCode */) >= 0) {
+                    observe$2(shadowRoot);
+                    // See: https://wicg.github.io/construct-stylesheets/ for more details on adoptedStyleSheets.
+                    // At the moment, we are only able to capture "open" shadow DOM nodes. If they are closed, they are not accessible.
+                    // In future we may decide to proxy "attachShadow" call to gain access, but at the moment, we don't want to
+                    // cause any unintended side effect to the page. We will re-evaluate after we gather more real world data on this.
+                    var style = "" /* Empty */;
+                    var adoptedStyleSheets = "adoptedStyleSheets" in shadowRoot ? shadowRoot["adoptedStyleSheets"] : [];
+                    for (var _i = 0, adoptedStyleSheets_1 = adoptedStyleSheets; _i < adoptedStyleSheets_1.length; _i++) {
+                        var styleSheet = adoptedStyleSheets_1[_i];
+                        style += getCssRules(styleSheet);
+                    }
+                    var fragementData = { tag: "*S" /* ShadowDomTag */, attributes: { style: style } };
+                    dom[call](node, shadowRoot.host, fragementData, source);
+                }
+                else {
+                    // If the browser doesn't support shadow DOM natively, we detect that, and send appropriate tag back.
+                    // The differentiation is important because we don't have to observe pollyfill shadow DOM nodes,
+                    // the same way we observe real shadow DOM nodes (encapsulation provided by the browser).
+                    dom[call](node, shadowRoot.host, { tag: "*P" /* PolyfillShadowDomTag */, attributes: {} }, source);
+                }
+            }
+            break;
+        case Node.TEXT_NODE:
+            // In IE11 TEXT_NODE doesn't expose a valid parentElement property. Instead we need to lookup parentNode property.
+            parent = parent ? parent : node.parentNode;
+            // Account for this text node only if we are tracking the parent node
+            // We do not wish to track text nodes for ignored parent nodes, like script tags
+            // Also, we do not track text nodes for STYLE tags
+            // The only exception is when we receive a mutation to remove the text node, in that case
+            // parent will be null, but we can still process the node by checking it's an update call.
+            if (call === "update" || (parent && has(parent) && parent.tagName !== "STYLE")) {
+                var textData = { tag: "*T" /* TextTag */, value: node.nodeValue };
+                dom[call](node, parent, textData, source);
+            }
+            break;
+        case Node.ELEMENT_NODE:
+            var element = node;
+            var tag = element.tagName;
+            var attributes = getAttributes(element);
+            // In some cases, external libraries like vue-fragment, can modify parentNode property to not be in sync with the DOM
+            // For correctness, we first look at parentElement and if it not present then fall back to using parentNode
+            parent = node.parentElement ? node.parentElement : (node.parentNode ? node.parentNode : null);
+            // If we encounter a node that is part of SVG namespace, prefix the tag with SVG_PREFIX
+            if (element.namespaceURI === "http://www.w3.org/2000/svg" /* SvgNamespace */) {
+                tag = "svg:" /* SvgPrefix */ + tag;
+            }
+            switch (tag) {
+                case "HTML":
+                    parent = insideFrame && parent ? iframe(parent) : null;
+                    var htmlPrefix = insideFrame ? "iframe:" /* IFramePrefix */ : "" /* Empty */;
+                    var htmlData = { tag: htmlPrefix + tag, attributes: attributes };
+                    dom[call](node, parent, htmlData, source);
+                    break;
+                case "SCRIPT":
+                    if ("type" /* Type */ in attributes && attributes["type" /* Type */] === "application/ld+json" /* JsonLD */) {
+                        try {
+                            ld(JSON.parse(element.text));
+                        }
+                        catch ( /* do nothing */_a) { /* do nothing */ }
+                    }
+                    break;
+                case "NOSCRIPT":
+                    break;
+                case "META":
+                    if ("property" /* Property */ in attributes && "content" /* Content */ in attributes) {
+                        var content = attributes["content" /* Content */];
+                        switch (attributes["property" /* Property */]) {
+                            case "og:title" /* ogTitle */:
+                                log$1(20 /* MetaTitle */, content);
+                                break;
+                            case "og:type" /* ogType */:
+                                log$1(19 /* MetaType */, content);
+                                break;
+                            case "generator" /* Generator */:
+                                log$1(21 /* Generator */, content);
+                                break;
+                        }
+                    }
+                    break;
+                case "HEAD":
+                    var head = { tag: tag, attributes: attributes };
+                    if (location) {
+                        head.attributes["*B" /* Base */] = location.protocol + "//" + location.hostname;
+                    }
+                    dom[call](node, parent, head, source);
+                    break;
+                case "STYLE":
+                    var styleData = { tag: tag, attributes: attributes, value: getStyleValue(element) };
+                    dom[call](node, parent, styleData, source);
+                    break;
+                case "IFRAME":
+                    var iframe$1 = node;
+                    var frameData = { tag: tag, attributes: attributes };
+                    if (sameorigin(iframe$1)) {
+                        monitor(iframe$1);
+                        frameData.attributes["*O" /* SameOrigin */] = "true";
+                        if (iframe$1.contentDocument && iframe$1.contentWindow && iframe$1.contentDocument.readyState !== "loading") {
+                            child = iframe$1.contentDocument;
+                        }
+                    }
+                    dom[call](node, parent, frameData, source);
+                    break;
+                default:
+                    var data = { tag: tag, attributes: attributes };
+                    if (element.shadowRoot) {
+                        child = element.shadowRoot;
+                    }
+                    dom[call](node, parent, data, source);
+                    break;
+            }
+            break;
+    }
+    return child;
+}
+function observe$2(root) {
+    if (has(root)) {
+        return;
+    }
+    observe$1(root); // Observe mutations for this root node
+    observe$3(root); // Observe interactions for this root node
+}
+function getStyleValue(style) {
+    // Call trim on the text content to ensure we do not process white spaces ( , \n, \r\n, \t, etc.)
+    // Also, check if stylesheet has any data-* attribute, if so process rules instead of looking up text
+    var value = style.textContent ? style.textContent.trim() : "" /* Empty */;
+    var dataset = style.dataset ? Object.keys(style.dataset).length : 0;
+    if (value.length === 0 || dataset > 0 || config$1.cssRules) {
+        value = getCssRules(style.sheet);
+    }
+    return value;
+}
+function getCssRules(sheet) {
+    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 /* CssRules */, 1 /* Warning */, e ? e.name : null);
+        if (e && e.name !== "SecurityError") {
+            throw e;
+        }
+    }
+    if (cssRules !== null) {
+        for (var i = 0; i < cssRules.length; i++) {
+            value += cssRules[i].cssText;
+        }
+    }
+    return value;
+}
+function getAttributes(element) {
+    var output = {};
+    var attributes = element.attributes;
+    if (attributes && attributes.length > 0) {
+        for (var i = 0; i < attributes.length; i++) {
+            var name_1 = attributes[i].name;
+            if (IGNORE_ATTRIBUTES.indexOf(name_1) < 0) {
+                output[name_1] = attributes[i].value;
+            }
+        }
+    }
+    // For INPUT tags read the dynamic "value" property if an explicit "value" attribute is not set
+    if (element.tagName === "INPUT" /* InputTag */ && !("value" /* Value */ in output) && element.value) {
+        output["value" /* Value */] = element.value;
+    }
+    return output;
+}
+
+function traverse (root, timer, source) {
+    return __awaiter(this, void 0, void 0, function () {
+        var queue, node, next, state, subnode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    queue = [root];
+                    _a.label = 1;
+                case 1:
+                    if (!(queue.length > 0)) return [3 /*break*/, 4];
+                    node = queue.shift();
+                    next = node.firstChild;
+                    while (next) {
+                        queue.push(next);
+                        next = next.nextSibling;
+                    }
+                    state = state$6(timer);
+                    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 /* Stop */) {
+                        return [3 /*break*/, 4];
+                    }
+                    subnode = processNode(node, source);
+                    if (subnode) {
+                        queue.push(subnode);
+                    }
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+var observers = [];
+var mutations = [];
+var insertRule = null;
+var deleteRule = null;
+var queue$1 = [];
+var timeout$1 = null;
+var activePeriod = null;
+var history$1 = {};
+function start$c() {
+    observers = [];
+    queue$1 = [];
+    timeout$1 = null;
+    activePeriod = 0;
+    history$1 = {};
+    if (insertRule === null) {
+        insertRule = CSSStyleSheet.prototype.insertRule;
+    }
+    if (deleteRule === null) {
+        deleteRule = CSSStyleSheet.prototype.deleteRule;
+    }
+    // Some popular open source libraries, like styled-components, optimize performance
+    // by injecting CSS using insertRule API vs. appending text node. A side effect of
+    // using javascript API is that it doesn't trigger DOM mutation and therefore we
+    // need to override the insertRule API and listen for changes manually.
+    CSSStyleSheet.prototype.insertRule = function () {
+        schedule(this.ownerNode);
+        return insertRule.apply(this, arguments);
+    };
+    CSSStyleSheet.prototype.deleteRule = function () {
+        schedule(this.ownerNode);
+        return deleteRule.apply(this, arguments);
+    };
+}
+function observe$1(node) {
+    // Create a new observer for every time a new DOM tree (e.g. root document or shadowdom root) is discovered on the page
+    // In the case of shadow dom, any mutations that happen within the shadow dom are not bubbled up to the host document
+    // 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 {
+        // In an edge case, it's possible to get stuck into infinite Mutation loop within Angular applications
+        // This appears to be an issue with Zone.js package, see: https://github.com/angular/angular/issues/31712
+        // As a temporary work around, ensuring Clarity can invoke MutationObserver outside of Zone (and use native implementation instead)
+        var api = window["Zone" /* Zone */] && "__symbol__" /* Symbol */ in window["Zone" /* Zone */] ? window["Zone" /* Zone */]["__symbol__" /* Symbol */]("MutationObserver" /* MutationObserver */) : "MutationObserver" /* MutationObserver */;
+        var observer = api in window ? new window[api](measure(handle$1)) : null;
+        if (observer) {
+            observer.observe(node, { attributes: true, childList: true, characterData: true, subtree: true });
+            observers.push(observer);
+        }
+    }
+    catch (e) {
+        log(2 /* MutationObserver */, 0 /* Info */, e ? e.name : null);
+    }
+}
+function monitor(frame) {
+    // Bind to iframe's onload event so we get notified anytime there's an update to iframe content.
+    // This includes cases where iframe location is updated without explicitly updating src attribute
+    // E.g. iframe.contentWindow.location.href = "new-location";
+    if (has(frame) === false) {
+        bind(frame, "load" /* LoadEvent */, generate.bind(this, frame, "childList" /* ChildList */), true);
+    }
+}
+function stop$b() {
+    for (var _i = 0, observers_1 = observers; _i < observers_1.length; _i++) {
+        var observer = observers_1[_i];
+        if (observer) {
+            observer.disconnect();
+        }
+    }
+    observers = [];
+    // Restoring original insertRule
+    if (insertRule !== null) {
+        CSSStyleSheet.prototype.insertRule = insertRule;
+        insertRule = null;
+    }
+    // Restoring original deleteRule
+    if (deleteRule !== null) {
+        CSSStyleSheet.prototype.deleteRule = deleteRule;
+        deleteRule = null;
+    }
+    history$1 = {};
+    mutations = [];
+    queue$1 = [];
+    activePeriod = 0;
+    timeout$1 = null;
+}
+function active$2() {
+    activePeriod = time() + 3000 /* MutationActivePeriod */;
+}
+function handle$1(m) {
+    // Queue up mutation records for asynchronous processing
+    var now = time();
+    track$5(6 /* Mutation */, now);
+    mutations.push({ time: now, mutations: m });
+    schedule$1(process$1, 1 /* High */).then(function () {
+        measure(compute$6)();
+        measure(compute$4)();
+    });
+}
+function process$1() {
+    return __awaiter(this, void 0, void 0, function () {
+        var timer, record, _i, _a, mutation, state, target, type, value;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    timer = { id: id(), cost: 3 /* LayoutCost */ };
+                    start$t(timer);
+                    _b.label = 1;
+                case 1:
+                    if (!(mutations.length > 0)) return [3 /*break*/, 8];
+                    record = mutations.shift();
+                    _i = 0, _a = record.mutations;
+                    _b.label = 2;
+                case 2:
+                    if (!(_i < _a.length)) return [3 /*break*/, 6];
+                    mutation = _a[_i];
+                    state = state$6(timer);
+                    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 /* Stop */) {
+                        return [3 /*break*/, 6];
+                    }
+                    target = mutation.target;
+                    type = track$2(mutation, timer);
+                    if (type && target && target.ownerDocument) {
+                        parse(target.ownerDocument);
+                    }
+                    switch (type) {
+                        case "attributes" /* Attributes */:
+                            processNode(target, 3 /* Attributes */);
+                            break;
+                        case "characterData" /* CharacterData */:
+                            processNode(target, 4 /* CharacterData */);
+                            break;
+                        case "childList" /* ChildList */:
+                            processNodeList(mutation.addedNodes, 1 /* ChildListAdd */, timer);
+                            processNodeList(mutation.removedNodes, 2 /* ChildListRemove */, timer);
+                            break;
+                        case "suspend" /* Suspend */:
+                            value = get(target);
+                            if (value) {
+                                value.data.tag = "*M" /* SuspendMutationTag */;
+                            }
+                            break;
+                    }
+                    _b.label = 5;
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 6: return [4 /*yield*/, encode$4(6 /* Mutation */, timer, record.time)];
+                case 7:
+                    _b.sent();
+                    return [3 /*break*/, 1];
+                case 8:
+                    stop$q(timer);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function track$2(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.selector !== "HTML" /* HTML */) {
+        var inactive = time() > activePeriod;
+        var target = get(m.target);
+        var element = target ? target.selector : m.target.nodeName;
+        // 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
+        var key = [value.selector, element, m.attributeName, names(m.addedNodes), names(m.removedNodes)].join();
+        // Initialize an entry if it doesn't already exist
+        history$1[key] = key in history$1 ? history$1[key] : [0];
+        var h = history$1[key];
+        // Lookup any pending nodes queued up for removal, and process them now if we suspended a mutation before
+        if (inactive === false && h[0] >= 10 /* MutationSuspendThreshold */) {
+            processNodeList(h[1], 2 /* ChildListRemove */, timer);
+        }
+        // Update the counter
+        h[0] = inactive ? h[0] + 1 : 1;
+        // Return updated mutation type based on if we have already hit the threshold or not
+        if (h[0] === 10 /* MutationSuspendThreshold */) {
+            // Store a reference to removedNodes so we can process them later
+            // when we resume mutations again on user interactions
+            h[1] = m.removedNodes;
+            return "suspend" /* Suspend */;
+        }
+        else if (h[0] > 10 /* MutationSuspendThreshold */) {
+            return "" /* Empty */;
+        }
+    }
+    return m.type;
+}
+function names(nodes) {
+    var output = [];
+    for (var i = 0; nodes && i < nodes.length; i++) {
+        output.push(nodes[i].nodeName);
+    }
+    return output.join();
+}
+function processNodeList(list, source, timer) {
+    return __awaiter(this, void 0, void 0, function () {
+        var length, i, state;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    length = list ? list.length : 0;
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < length)) return [3 /*break*/, 6];
+                    if (!(source === 1 /* ChildListAdd */)) return [3 /*break*/, 2];
+                    traverse(list[i], timer, source);
+                    return [3 /*break*/, 5];
+                case 2:
+                    state = state$6(timer);
+                    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 /* Stop */) {
+                        return [3 /*break*/, 6];
+                    }
+                    processNode(list[i], source);
+                    _a.label = 5;
+                case 5:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+function schedule(node) {
+    // Only schedule manual trigger for this node if it's not already in the queue
+    if (queue$1.indexOf(node) < 0) {
+        queue$1.push(node);
+    }
+    // Cancel any previous trigger before scheduling a new one.
+    // It's common for a webpage to call multiple synchronous "insertRule" / "deleteRule" calls.
+    // And in those cases we do not wish to monitor changes multiple times for the same node.
+    if (timeout$1) {
+        clearTimeout(timeout$1);
+    }
+    timeout$1 = setTimeout(trigger, 33 /* LookAhead */);
+}
+function trigger() {
+    for (var _i = 0, queue_1 = queue$1; _i < queue_1.length; _i++) {
+        var node = queue_1[_i];
+        generate(node, "characterData" /* CharacterData */);
+    }
+    queue$1 = [];
+}
+function generate(target, type) {
+    measure(handle$1)([{
+            addedNodes: [target],
+            attributeName: null,
+            attributeNamespace: null,
+            nextSibling: null,
+            oldValue: null,
+            previousSibling: null,
+            removedNodes: [],
+            target: target,
+            type: type
+        }]);
+}
+
+function target(evt) {
+    var path = evt.composed && evt.composedPath ? evt.composedPath() : null;
+    var node = (path && path.length > 0 ? path[0] : evt.target);
+    active$2(); // Mark active periods of time so mutations can continue uninterrupted
+    return node.nodeType === Node.DOCUMENT_NODE ? node.documentElement : node;
+}
+function link(node) {
+    while (node && node !== document) {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+            var element = node;
+            if (element.tagName === "A") {
+                return element;
+            }
+        }
+        node = node.parentNode;
+    }
+    return null;
+}
+function metadata(node, event) {
+    // If the node is null, we return a reserved value for id: 0. Valid assignment of id begins from 1+.
+    var output = { id: 0, hash: null, selector: null, privacy: 2 /* Text */, node: node };
+    if (node) {
+        var value = get(node);
+        if (value !== null) {
+            output.id = value.id;
+            output.hash = value.selector ? hash(value.selector) : null;
+            output.selector = value.selector;
+            output.privacy = value.metadata.privacy;
+            if (value.region) {
+                track$3(value.region, event);
+            }
+        }
+    }
+    return output;
+}
+
+function encode$2 (type) {
+    return __awaiter(this, void 0, void 0, function () {
+        var t, tokens, i, entry, pTarget, i, entry, cTarget, r, u, i, entry, iTarget, s, startTarget, endTarget, i, entry, sTarget, i, entry, v;
+        return __generator(this, function (_a) {
+            t = time();
+            tokens = [t, type];
+            switch (type) {
+                case 13 /* MouseDown */:
+                case 14 /* MouseUp */:
+                case 12 /* MouseMove */:
+                case 15 /* MouseWheel */:
+                case 16 /* DoubleClick */:
+                case 17 /* TouchStart */:
+                case 18 /* TouchEnd */:
+                case 19 /* TouchMove */:
+                case 20 /* TouchCancel */:
+                    for (i = 0; i < state$2.length; i++) {
+                        entry = state$2[i];
+                        pTarget = metadata(entry.data.target, entry.event);
+                        if (pTarget.id > 0) {
+                            tokens = [entry.time, entry.event];
+                            tokens.push(pTarget.id);
+                            tokens.push(entry.data.x);
+                            tokens.push(entry.data.y);
+                            queue(tokens);
+                            track$7(entry.event, entry.data.x, entry.data.y);
+                        }
+                    }
+                    reset$a();
+                    break;
+                case 9 /* Click */:
+                    for (i = 0; i < state$4.length; i++) {
+                        entry = state$4[i];
+                        cTarget = metadata(entry.data.target, entry.event);
+                        tokens = [entry.time, entry.event];
+                        tokens.push(cTarget.id);
+                        tokens.push(entry.data.x);
+                        tokens.push(entry.data.y);
+                        tokens.push(entry.data.eX);
+                        tokens.push(entry.data.eY);
+                        tokens.push(entry.data.button);
+                        tokens.push(entry.data.reaction);
+                        tokens.push(entry.data.context);
+                        tokens.push(scrub(entry.data.text, "click", cTarget.privacy));
+                        tokens.push(entry.data.link);
+                        tokens.push(cTarget.hash);
+                        queue(tokens);
+                        track$1(entry.time, entry.event, cTarget.hash, entry.data.x, entry.data.y, entry.data.reaction, entry.data.context);
+                    }
+                    reset$c();
+                    break;
+                case 11 /* Resize */:
+                    r = data$6;
+                    tokens.push(r.width);
+                    tokens.push(r.height);
+                    track$7(type, r.width, r.height);
+                    reset$9();
+                    queue(tokens);
+                    break;
+                case 26 /* Unload */:
+                    u = data$4;
+                    tokens.push(u.name);
+                    reset$6();
+                    queue(tokens);
+                    break;
+                case 27 /* Input */:
+                    for (i = 0; i < state$3.length; i++) {
+                        entry = state$3[i];
+                        iTarget = metadata(entry.data.target, entry.event);
+                        tokens = [entry.time, entry.event];
+                        tokens.push(iTarget.id);
+                        tokens.push(entry.data.value);
+                        queue(tokens);
+                    }
+                    reset$b();
+                    break;
+                case 21 /* Selection */:
+                    s = data$5;
+                    if (s) {
+                        startTarget = metadata(s.start, type);
+                        endTarget = metadata(s.end, type);
+                        tokens.push(startTarget.id);
+                        tokens.push(s.startOffset);
+                        tokens.push(endTarget.id);
+                        tokens.push(s.endOffset);
+                        reset$7();
+                        queue(tokens);
+                    }
+                    break;
+                case 10 /* Scroll */:
+                    for (i = 0; i < state$1.length; i++) {
+                        entry = state$1[i];
+                        sTarget = metadata(entry.data.target, entry.event);
+                        if (sTarget.id > 0) {
+                            tokens = [entry.time, entry.event];
+                            tokens.push(sTarget.id);
+                            tokens.push(entry.data.x);
+                            tokens.push(entry.data.y);
+                            queue(tokens);
+                            track$7(entry.event, entry.data.x, entry.data.y);
+                        }
+                    }
+                    reset$8();
+                    break;
+                case 22 /* Timeline */:
+                    for (i = 0; i < updates$1.length; i++) {
+                        entry = updates$1[i];
+                        tokens = [entry.time, entry.event];
+                        tokens.push(entry.data.type);
+                        tokens.push(entry.data.hash);
+                        tokens.push(entry.data.x);
+                        tokens.push(entry.data.y);
+                        tokens.push(entry.data.reaction);
+                        tokens.push(entry.data.context);
+                        queue(tokens, false);
+                    }
+                    reset$4();
+                    break;
+                case 28 /* Visibility */:
+                    v = data$3;
+                    tokens.push(v.visible);
+                    queue(tokens);
+                    visibility(t, v.visible);
+                    reset$5();
+                    break;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+
+var state = [];
+var updates$1 = [];
+function start$b() {
+    state = [];
+    reset$4();
+}
+function reset$4() {
+    updates$1 = [];
+}
+function track$1(time, event, hash, x, y, reaction, context) {
+    if (reaction === void 0) { reaction = 1 /* True */; }
+    if (context === void 0) { context = 0 /* Self */; }
+    state.push({
+        time: time,
+        event: 22 /* Timeline */,
+        data: {
+            type: event,
+            hash: hash,
+            x: x,
+            y: y,
+            reaction: reaction,
+            context: context
+        }
+    });
+    // Since timeline only keeps the data for configured time, we still want to continue tracking these values
+    // as part of the baseline. For instance, in a scenario where last scroll happened 5s ago.
+    // We would still need to capture the last scroll position as part of the baseline event, even when timeline will be empty.
+    track$7(event, x, y);
+}
+function compute$3() {
+    var temp = [];
+    updates$1 = [];
+    var max = data$h.start + data$h.duration;
+    var min = Math.max(max - 2000 /* TimelineSpan */, 0);
+    for (var _i = 0, state_1 = state; _i < state_1.length; _i++) {
+        var s = state_1[_i];
+        if (s.time >= min) {
+            if (s.time <= max) {
+                updates$1.push(s);
+            }
+            temp.push(s);
+        }
+    }
+    state = temp; // Drop events less than the min time
+    encode$2(22 /* Timeline */);
+}
+function stop$a() {
+    state = [];
+    reset$4();
+}
+
+var discoverBytes = 0;
+var playbackBytes = 0;
+var playback;
+var analysis;
+var timeout = null;
+var transit;
+var active$1;
+var queuedTime = 0;
+var track;
+function start$a() {
+    active$1 = true;
+    discoverBytes = 0;
+    playbackBytes = 0;
+    queuedTime = 0;
+    playback = [];
+    analysis = [];
+    transit = {};
+    track = null;
+}
+function queue(tokens, transmit) {
+    if (transmit === void 0) { transmit = true; }
+    if (active$1) {
+        var now = time();
+        var type = tokens.length > 1 ? tokens[1] : null;
+        var event_1 = JSON.stringify(tokens);
+        switch (type) {
+            case 5 /* Discover */:
+                discoverBytes += event_1.length;
+            case 37 /* Box */:
+            case 6 /* Mutation */:
+                playbackBytes += event_1.length;
+                playback.push(event_1);
+                break;
+            default:
+                analysis.push(event_1);
+                break;
+        }
+        // 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.
+        var gap = delay();
+        if (now - queuedTime > (gap * 2)) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+        // Transmit Check: When transmit is set to true (default), it indicates that we should schedule an upload
+        // However, in certain scenarios - like metric calculation - which are triggered as part of an existing upload
+        // We enrich the data going out with the existing upload. In these cases, call to upload comes with 'transmit' set to false.
+        if (transmit && timeout === null) {
+            if (type !== 25 /* Ping */) {
+                reset$j();
+            }
+            timeout = setTimeout(upload, gap);
+            queuedTime = now;
+            check$3(playbackBytes);
+        }
+    }
+}
+function stop$9() {
+    clearTimeout(timeout);
+    upload(true);
+    discoverBytes = 0;
+    playbackBytes = 0;
+    queuedTime = 0;
+    playback = [];
+    analysis = [];
+    transit = {};
+    track = null;
+    active$1 = false;
+}
+function upload(final) {
+    if (final === void 0) { final = false; }
+    return __awaiter(this, void 0, void 0, function () {
+        var sendPlaybackBytes, last, e, a, p, encoded, payload, zipped, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    timeout = null;
+                    sendPlaybackBytes = config$1.lean === false && playbackBytes > 0 && (playbackBytes < 1048576 /* MaxFirstPayloadBytes */ || data$h.sequence > 0);
+                    if (sendPlaybackBytes) {
+                        max(1 /* Playback */, 1 /* True */);
+                    }
+                    // CAUTION: Ensure "transmit" is set to false in the queue function for following events
+                    // Otherwise you run a risk of infinite loop.
+                    compute$4();
+                    compute$3();
+                    compute$7();
+                    last = final === true;
+                    e = JSON.stringify(envelope(last));
+                    a = "[" + analysis.join() + "]";
+                    p = sendPlaybackBytes ? "[" + playback.join() + "]" : "" /* Empty */;
+                    encoded = { e: e, a: a, p: p };
+                    payload = stringify(encoded);
+                    if (!last) return [3 /*break*/, 1];
+                    _a = null;
+                    return [3 /*break*/, 3];
+                case 1: return [4 /*yield*/, compress(payload)];
+                case 2:
+                    _a = _b.sent();
+                    _b.label = 3;
+                case 3:
+                    zipped = _a;
+                    sum(2 /* TotalBytes */, zipped ? zipped.length : payload.length);
+                    send(payload, zipped, data$h.sequence, last);
+                    // Clear out events now that payload has been dispatched
+                    analysis = [];
+                    if (sendPlaybackBytes) {
+                        playback = [];
+                        playbackBytes = 0;
+                        discoverBytes = 0;
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function stringify(encoded) {
+    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" /* String */) {
+        var url = config$1.upload;
+        var dispatched = false;
+        // If it's the last payload, attempt to upload using sendBeacon first.
+        // The advantage to using sendBeacon is that browser can decide to upload asynchronously, improving chances of success
+        // However, we don't want to rely on it for every payload, since we have no ability to retry if the upload failed.
+        // Also, in case of sendBeacon, we do not have a way to alter HTTP headers and therefore can't send compressed payload
+        if (beacon && "sendBeacon" in navigator) {
+            dispatched = navigator.sendBeacon(url, payload);
+            if (dispatched) {
+                done(sequence);
+            }
+        }
+        // Before initiating XHR upload, we check if the data has already been uploaded using sendBeacon
+        // There are two cases when dispatched could still be false:
+        //   a) It's not the last payload, and therefore we didn't attempt sending sendBeacon
+        //   b) It's the last payload, however, we failed to queue sendBeacon call and need to now fall back to XHR.
+        //      E.g. if data is over 64KB, several user agents (like Chrome) will reject to queue the sendBeacon call.
+        if (dispatched === false) {
+            // While tracking payload for retry, we only track string value of the payload to err on the safe side
+            // Not all browsers support compression API and the support for it in supported browsers is still experimental
+            if (sequence in transit) {
+                transit[sequence].attempts++;
+            }
+            else {
+                transit[sequence] = { data: payload, attempts: 1 };
+            }
+            var xhr_1 = new XMLHttpRequest();
+            xhr_1.open("POST", url);
+            if (sequence !== null) {
+                xhr_1.onreadystatechange = function () { measure(check$2)(xhr_1, sequence); };
+            }
+            xhr_1.withCredentials = true;
+            if (zipped) {
+                // If we do have valid compressed array, send it with appropriate HTTP headers so server can decode it appropriately
+                xhr_1.setRequestHeader("Accept" /* Accept */, "application/x-clarity-gzip" /* ClarityGzip */);
+                xhr_1.send(zipped);
+            }
+            else {
+                // In all other cases, continue sending string back to the server
+                xhr_1.send(payload);
+            }
+        }
+    }
+    else if (config$1.upload) {
+        var callback = config$1.upload;
+        callback(payload);
+        done(sequence);
+    }
+}
+function check$2(xhr, sequence) {
+    var transitData = transit[sequence];
+    if (xhr && xhr.readyState === 4 /* Done */ && transitData) {
+        // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
+        if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= 1 /* RetryLimit */) {
+            // We re-attempt in all cases except when server explicitly rejects our request with 4XX error 
+            if (xhr.status >= 400 && xhr.status < 500) {
+                // In case of a 4XX response from the server, we bail out instead of trying again
+                trigger$1(6 /* Server */);
+            }
+            else {
+                // Browser will send status = 0 when it refuses to put network request over the wire
+                // This could happen for several reasons, couple of known ones are:
+                //    1: Browsers block upload because of content security policy violation
+                //    2: Safari will terminate pending XHR requests with status code 0 if the user navigates away from the page
+                // In any case, we switch the upload URL to fallback configuration (if available) before re-trying one more time
+                if (xhr.status === 0) {
+                    config$1.upload = config$1.fallback ? config$1.fallback : config$1.upload;
+                }
+                // In all other cases, re-attempt sending the same data
+                // For retry we always fallback to string payload, even though we may have attempted
+                // sending zipped payload earlier
+                send(transitData.data, null, sequence);
+            }
+        }
+        else {
+            track = { sequence: sequence, attempts: transitData.attempts, status: xhr.status };
+            // Send back an event only if we were not successful in our first attempt
+            if (transitData.attempts > 1) {
+                encode$1(2 /* Upload */);
+            }
+            // Handle response if it was a 200 response with a valid body
+            if (xhr.status === 200 && xhr.responseText) {
+                response(xhr.responseText);
+            }
+            // If we exhausted our retries then trigger Clarity's shutdown for this page since the data will be incomplete
+            if (xhr.status === 0) {
+                // And, right before we terminate the session, we will attempt one last time to see if we can use
+                // different transport option (sendBeacon vs. XHR) to get this data to the server for analysis purposes
+                send(transitData.data, null, sequence, true);
+                trigger$1(3 /* Retry */);
+            }
+            // Signal that this request completed successfully
+            if (xhr.status >= 200 && xhr.status <= 208) {
+                done(sequence);
+            }
+            // Stop tracking this payload now that it's all done
+            delete transit[sequence];
+        }
+    }
+}
+function done(sequence) {
+    // If we everything went successfully, and it is the first sequence, save this session for future reference
+    if (sequence === 1) {
+        save();
+    }
+}
+function delay() {
+    // Progressively increase delay as we continue to send more payloads from the client to the server
+    // If we are not uploading data to a server, and instead invoking UploadCallback, in that case keep returning configured value 
+    var gap = config$1.lean === false && discoverBytes > 0 ? 100 /* MinUploadDelay */ : data$h.sequence * config$1.delay;
+    return typeof config$1.upload === "string" /* String */ ? Math.max(Math.min(gap, 30000 /* MaxUploadDelay */), 100 /* MinUploadDelay */) : config$1.delay;
+}
+function response(payload) {
+    var key = payload && payload.length > 0 ? payload.split(" ")[0] : "" /* Empty */;
+    switch (key) {
+        case "END" /* End */:
+            // Clear out session storage and end the session so we can start fresh the next time
+            trigger$1(6 /* Server */);
+            break;
+        case "UPGRADE" /* Upgrade */:
+            // Upgrade current session to send back playback information
+            upgrade("Auto" /* Auto */);
+            break;
+    }
+}
+
+function encode$1 (event) {
+    var t = time();
+    var tokens = [t, event];
+    switch (event) {
+        case 4 /* Baseline */:
+            var b = state$7;
+            if (b) {
+                tokens = [b.time, b.event];
+                tokens.push(b.data.visible);
+                tokens.push(b.data.docWidth);
+                tokens.push(b.data.docHeight);
+                tokens.push(b.data.screenWidth);
+                tokens.push(b.data.screenHeight);
+                tokens.push(b.data.scrollX);
+                tokens.push(b.data.scrollY);
+                tokens.push(b.data.pointerX);
+                tokens.push(b.data.pointerY);
+                tokens.push(b.data.activityTime);
+                queue(tokens, false);
+            }
+            reset$n();
+            break;
+        case 25 /* Ping */:
+            tokens.push(data$e.gap);
+            queue(tokens);
+            break;
+        case 35 /* Limit */:
+            tokens.push(data$g.check);
+            queue(tokens, false);
+            break;
+        case 3 /* Upgrade */:
+            tokens.push(data$c.key);
+            queue(tokens);
+            break;
+        case 2 /* Upload */:
+            tokens.push(track.sequence);
+            tokens.push(track.attempts);
+            tokens.push(track.status);
+            queue(tokens, false);
+            break;
+        case 24 /* Custom */:
+            tokens.push(data$k.key);
+            tokens.push(data$k.value);
+            queue(tokens);
+            break;
+        case 34 /* Variable */:
+            var variableKeys = Object.keys(data$j);
+            if (variableKeys.length > 0) {
+                for (var _i = 0, variableKeys_1 = variableKeys; _i < variableKeys_1.length; _i++) {
+                    var v = variableKeys_1[_i];
+                    tokens.push(v);
+                    tokens.push(data$j[v]);
+                }
+                reset$m();
+                queue(tokens, false);
+            }
+            break;
+        case 0 /* Metric */:
+            var metricKeys = Object.keys(updates);
+            if (metricKeys.length > 0) {
+                for (var _a = 0, metricKeys_1 = metricKeys; _a < metricKeys_1.length; _a++) {
+                    var m = metricKeys_1[_a];
+                    var key = parseInt(m, 10);
+                    tokens.push(key);
+                    // For computation, we need microseconds precision that performance.now() API offers
+                    // However, for data over the wire, we round it off to milliseconds precision.
+                    tokens.push(Math.round(updates[m]));
+                }
+                reset$3();
+                queue(tokens, false);
+            }
+            break;
+        case 1 /* Dimension */:
+            var dimensionKeys = Object.keys(updates$3);
+            if (dimensionKeys.length > 0) {
+                for (var _b = 0, dimensionKeys_1 = dimensionKeys; _b < dimensionKeys_1.length; _b++) {
+                    var d = dimensionKeys_1[_b];
+                    var key = parseInt(d, 10);
+                    tokens.push(key);
+                    tokens.push(updates$3[d]);
+                }
+                reset$k();
+                queue(tokens, false);
+            }
+            break;
+        case 36 /* Summary */:
+            var eventKeys = Object.keys(data$d);
+            if (eventKeys.length > 0) {
+                for (var _c = 0, eventKeys_1 = eventKeys; _c < eventKeys_1.length; _c++) {
+                    var e = eventKeys_1[_c];
+                    var key = parseInt(e, 10);
+                    tokens.push(key);
+                    tokens.push([].concat.apply([], data$d[e]));
+                }
+                reset$i();
+                queue(tokens, false);
+            }
+            break;
+    }
+}
+
+var data$2 = null;
+var updates = null;
+function start$9() {
+    data$2 = {};
+    updates = {};
+    count$1(5 /* InvokeCount */);
+}
+function stop$8() {
+    data$2 = {};
+    updates = {};
+}
+function count$1(metric, increment) {
+    if (increment === void 0) { increment = 1; }
+    if (!(metric in data$2)) {
+        data$2[metric] = 0;
+    }
+    if (!(metric in updates)) {
+        updates[metric] = 0;
+    }
+    data$2[metric] += increment;
+    updates[metric] += increment;
+}
+function sum(metric, value) {
+    if (value !== null) {
+        if (!(metric in data$2)) {
+            data$2[metric] = 0;
+        }
+        if (!(metric in updates)) {
+            updates[metric] = 0;
+        }
+        data$2[metric] += value;
+        updates[metric] += value;
+    }
+}
+function max(metric, value) {
+    // Ensure that we do not process null or NaN values
+    if (value !== null && isNaN(value) === false) {
+        if (!(metric in data$2)) {
+            data$2[metric] = 0;
+        }
+        if (value > data$2[metric] || data$2[metric] === 0) {
+            updates[metric] = value;
+            data$2[metric] = value;
+        }
+    }
+}
+function compute$2() {
+    encode$1(0 /* Metric */);
+}
+function reset$3() {
+    updates = {};
+}
+
+// tslint:disable-next-line: ban-types
+function measure (method) {
+    return function () {
+        var start = performance.now();
+        method.apply(this, arguments);
+        var duration = performance.now() - start;
+        sum(4 /* TotalCost */, duration);
+        if (duration > 30 /* LongTask */) {
+            count$1(7 /* LongTaskCount */);
+            max(6 /* ThreadBlockedTime */, duration);
+        }
+    };
+}
+
+var bindings = [];
+function bind(target, event, listener, capture) {
+    if (capture === void 0) { capture = false; }
+    listener = measure(listener);
+    // 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.addEventListener(event, listener, capture);
+        bindings.push({ event: event, target: target, listener: listener, capture: capture });
+    }
+    catch ( /* do nothing */_a) { /* do nothing */ }
+}
+function reset$2() {
+    // Walk through existing list of bindings and remove them all
+    for (var _i = 0, bindings_1 = bindings; _i < bindings_1.length; _i++) {
+        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.removeEventListener(binding.event, binding.listener, binding.capture);
+        }
+        catch ( /* do nothing */_a) { /* do nothing */ }
+    }
+    bindings = [];
+}
+
+var pushState = null;
+var replaceState = null;
+var url = null;
+var count = 0;
+function start$8() {
+    url = getCurrentUrl();
+    count = 0;
+    bind(window, "popstate", compute$1);
+    // Add a proxy to history.pushState function
+    if (pushState === null) {
+        pushState = history.pushState;
+    }
+    history.pushState = function () {
+        if (check$1()) {
+            pushState.apply(this, arguments);
+            compute$1();
+        }
+    };
+    // Add a proxy to history.replaceState function
+    if (replaceState === null) {
+        replaceState = history.replaceState;
+    }
+    history.replaceState = function () {
+        if (check$1()) {
+            replaceState.apply(this, arguments);
+            compute$1();
+        }
+    };
+}
+function check$1() {
+    if (count++ > 20 /* CallStackDepth */) {
+        log(4 /* CallStackDepth */, 0 /* Info */);
+        return false;
+    }
+    return true;
+}
+function compute$1() {
+    if (url !== getCurrentUrl() && count <= 20 /* CallStackDepth */) {
+        stop();
+        window.setTimeout(start, 250 /* RestartDelay */);
+    }
+}
+function getCurrentUrl() {
+    return location.href ? location.href.replace(location.hash, "" /* Empty */) : location.href;
+}
+function stop$7() {
+    // Restore original function definition of history.pushState
+    if (pushState !== null) {
+        history.pushState = pushState;
+        pushState = null;
+    }
+    // Restore original function definition of history.replaceState
+    if (replaceState !== null) {
+        history.replaceState = replaceState;
+        replaceState = null;
+    }
+    url = null;
+    count = 0;
+}
+
+var status = false;
+function start$7() {
+    status = true;
+    start$E();
+    reset$h();
+    reset$2();
+    reset$l();
+    start$8();
+}
+function stop$6() {
+    stop$7();
+    reset$l();
+    reset$2();
+    reset$h();
+    stop$B();
+    status = false;
+}
+function active() {
+    return status;
+}
+function check() {
+    try {
+        return status === false &&
+            typeof Promise !== "undefined" &&
+            window["MutationObserver"] &&
+            document["createTreeWalker"] &&
+            "now" in Date &&
+            "now" in performance &&
+            typeof WeakMap !== "undefined";
+    }
+    catch (ex) {
+        return false;
+    }
+}
+function config(override) {
+    // Process custom configuration overrides, if available
+    if (override === null || status) {
+        return false;
+    }
+    for (var key in override) {
+        if (key in config$1) {
+            config$1[key] = override[key];
+        }
+    }
+    return true;
+}
+// Suspend ends the current Clarity instance after a configured timeout period
+// The way it differs from the "end" call is that it starts listening to
+// user interaction events as soon as it terminates existing clarity instance.
+// On the next interaction, it automatically starts another instance under a different page id
+// E.g. if configured timeout is 10m, and user stays inactive for an hour.
+// In this case, we will suspend clarity after 10m of inactivity and after another 50m when user interacts again
+// Clarity will restart and start another instance seamlessly. Effectively not missing any active time, but also
+// not holding the session during inactive time periods.
+function suspend() {
+    if (status) {
+        event("clarity" /* Clarity */, "suspend" /* Suspend */);
+        stop();
+        ["document", "touchstart"].forEach(function (x) { return bind(document, x, restart); });
+        ["resize", "scroll", "pageshow"].forEach(function (x) { return bind(window, x, restart); });
+    }
+}
+function restart() {
+    start();
+    event("clarity" /* Clarity */, "restart" /* Restart */);
+}
+
+function start$6() {
+    start$p();
+    start$s();
+    start$o();
+}
+function stop$5() {
+    stop$p();
+    stop$n();
+}
+
+var diagnostic = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    start: start$6,
+    stop: stop$5
+});
+
+function start$5() {
+    schedule$1(discover, 1 /* High */).then(function () {
+        measure(compute$6)();
+        measure(compute$4)();
+    });
+}
+function discover() {
+    return __awaiter(this, void 0, void 0, function () {
+        var ts, timer;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ts = time();
+                    timer = { id: id(), cost: 3 /* LayoutCost */ };
+                    start$t(timer);
+                    return [4 /*yield*/, traverse(document, timer, 0 /* Discover */)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, encode$4(5 /* Discover */, timer, ts)];
+                case 2:
+                    _a.sent();
+                    stop$q(timer);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+
+function start$4() {
+    // The order below is important 
+    // and is determined by interdependencies of modules
+    start$r();
+    start$m();
+    start$n();
+    start$c();
+    start$5();
+    start$q();
+}
+function stop$4() {
+    stop$l();
+    stop$m();
+    stop$b();
+    stop$o();
+    end();
+}
+
+var layout = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    start: start$4,
+    stop: stop$4
+});
+
+var data$1 = null;
+function reset$1() {
+    data$1 = null;
+}
+function compute(entry) {
+    data$1 = {
+        fetchStart: Math.round(entry.fetchStart),
+        connectStart: Math.round(entry.connectStart),
+        connectEnd: Math.round(entry.connectEnd),
+        requestStart: Math.round(entry.requestStart),
+        responseStart: Math.round(entry.responseStart),
+        responseEnd: Math.round(entry.responseEnd),
+        domInteractive: Math.round(entry.domInteractive),
+        domComplete: Math.round(entry.domComplete),
+        loadEventStart: Math.round(entry.loadEventStart),
+        loadEventEnd: Math.round(entry.loadEventEnd),
+        redirectCount: Math.round(entry.redirectCount),
+        size: entry.transferSize ? entry.transferSize : 0,
+        type: entry.type,
+        protocol: entry.nextHopProtocol,
+        encodedSize: entry.encodedBodySize ? entry.encodedBodySize : 0,
+        decodedSize: entry.decodedBodySize ? entry.decodedBodySize : 0
+    };
+    encode(29 /* Navigation */);
+}
+
+function encode (type) {
+    return __awaiter(this, void 0, void 0, function () {
+        var t, tokens;
+        return __generator(this, function (_a) {
+            t = time();
+            tokens = [t, type];
+            switch (type) {
+                case 30 /* Connection */:
+                    tokens.push(data.downlink);
+                    tokens.push(data.rtt);
+                    tokens.push(data.saveData);
+                    tokens.push(data.type);
+                    reset();
+                    queue(tokens, false);
+                    break;
+                case 29 /* Navigation */:
+                    tokens.push(data$1.fetchStart);
+                    tokens.push(data$1.connectStart);
+                    tokens.push(data$1.connectEnd);
+                    tokens.push(data$1.requestStart);
+                    tokens.push(data$1.responseStart);
+                    tokens.push(data$1.responseEnd);
+                    tokens.push(data$1.domInteractive);
+                    tokens.push(data$1.domComplete);
+                    tokens.push(data$1.loadEventStart);
+                    tokens.push(data$1.loadEventEnd);
+                    tokens.push(data$1.redirectCount);
+                    tokens.push(data$1.size);
+                    tokens.push(data$1.type);
+                    tokens.push(data$1.protocol);
+                    tokens.push(data$1.encodedSize);
+                    tokens.push(data$1.decodedSize);
+                    reset$1();
+                    queue(tokens, false);
+                    break;
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+
+// Reference: https://wicg.github.io/netinfo/
+var data;
+function start$3() {
+    // Check if the client supports Navigator.Connection: https://developer.mozilla.org/en-US/docs/Web/API/Navigator/connection
+    // This is an experimental API so we go a bit deeper in our check and ensure that values returned are valid
+    if (navigator &&
+        "connection" in navigator &&
+        "downlink" in navigator["connection"] &&
+        typeof navigator["connection"]["downlink"] === "number") {
+        navigator["connection"].addEventListener("change", recompute);
+        recompute();
+    }
+}
+function recompute() {
+    var connection = navigator["connection"];
+    data = {
+        downlink: connection.downlink,
+        rtt: connection.rtt,
+        saveData: connection.saveData ? 1 /* True */ : 0 /* False */,
+        type: connection.effectiveType
+    };
+    encode(30 /* Connection */);
+}
+function reset() {
+    data = null;
+}
+function stop$3() {
+    reset();
+}
+
+var observer;
+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) {
+        // Start monitoring performance data after page has finished loading.
+        // If the document.readyState is not yet complete, we intentionally call observe using a setTimeout.
+        // This allows us to capture loadEventEnd on navigation timeline.
+        if (document.readyState !== "complete") {
+            bind(window, "load", setTimeout.bind(this, observe, 0));
+        }
+        else {
+            observe();
+        }
+    }
+    else {
+        log(3 /* PerformanceObserver */, 0 /* Info */);
+    }
+}
+function observe() {
+    // Some browsers will throw an error for unsupported entryType, e.g. "layout-shift"
+    // In those cases, we log it as a warning and continue with rest of the Clarity processing
+    try {
+        if (observer) {
+            observer.disconnect();
+        }
+        observer = new PerformanceObserver(measure(handle));
+        // Reference: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe
+        // "buffered" flag indicates whether buffered entries should be queued into the observer's buffer.
+        // It must only be used only with the "type" option, and cannot be used with entryTypes.
+        // This is why we need to individually "observe" each supported type
+        for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+            var x = types_1[_i];
+            if (PerformanceObserver.supportedEntryTypes.indexOf(x) >= 0) {
+                // Initialize CLS with a value of zero. It's possible (and recommended) for sites to not have any cumulative layout shift.
+                // In those cases, we want to still initialize the metric in Clarity
+                if (x === "layout-shift" /* CLS */) {
+                    sum(9 /* CumulativeLayoutShift */, 0);
+                }
+                observer.observe({ type: x, buffered: true });
+            }
+        }
+    }
+    catch (_a) {
+        log(3 /* PerformanceObserver */, 1 /* Warning */);
+    }
+}
+function handle(entries) {
+    process(entries.getEntries());
+}
+function process(entries) {
+    var visible = "visibilityState" in document ? document.visibilityState === "visible" : true;
+    for (var i = 0; i < entries.length; i++) {
+        var entry = entries[i];
+        switch (entry.entryType) {
+            case "navigation" /* Navigation */:
+                compute(entry);
+                break;
+            case "resource" /* Resource */:
+                log$1(4 /* NetworkHosts */, host(entry.name));
+                break;
+            case "longtask" /* LongTask */:
+                count$1(7 /* LongTaskCount */);
+                break;
+            case "first-input" /* FID */:
+                if (visible) {
+                    max(10 /* FirstInputDelay */, entry["processingStart"] - entry.startTime);
+                }
+                break;
+            case "layout-shift" /* CLS */:
+                // Scale the value to avoid sending back floating point number
+                if (visible && !entry["hadRecentInput"]) {
+                    sum(9 /* CumulativeLayoutShift */, entry["value"] * 1000);
+                }
+                break;
+            case "largest-contentful-paint" /* LCP */:
+                if (visible) {
+                    max(8 /* LargestPaint */, entry.startTime);
+                }
+                break;
+        }
+    }
+}
+function stop$2() {
+    if (observer) {
+        observer.disconnect();
+    }
+    observer = null;
+}
+function host(url) {
+    var a = document.createElement("a");
+    a.href = url;
+    return a.hostname;
+}
+
+function start$1() {
+    reset$1();
+    start$3();
+    start$2();
+}
+function stop$1() {
+    stop$2();
+    stop$3();
+    reset$1();
+}
+
+var performance$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    start: start$1,
+    stop: stop$1
+});
+
+var modules = [diagnostic, layout, interaction, performance$1];
+function start(config$1) {
+    if (config$1 === void 0) { config$1 = null; }
+    // Check that browser supports required APIs and we do not attempt to start Clarity multiple times
+    if (check()) {
+        config(config$1);
+        start$7();
+        start$u();
+        modules.forEach(function (x) { return measure(x.start)(); });
+    }
+}
+// By default Clarity is asynchronous and will yield by looking for requestIdleCallback.
+// However, there can still be situations with single page apps where a user action can result
+// in the whole DOM being destroyed and reconstructed. While Clarity will perform favorably out of the box,
+// we do allow external clients to manually pause Clarity for that short burst of time and minimize
+// performance impact even further. For reference, we are talking single digit milliseconds optimization here, not seconds.
+function pause() {
+    if (active()) {
+        event("clarity" /* Clarity */, "pause" /* Pause */);
+        pause$1();
+    }
+}
+// This is how external clients can get out of pause state, and resume Clarity to continue monitoring the page
+function resume() {
+    if (active()) {
+        resume$1();
+        event("clarity" /* Clarity */, "resume" /* Resume */);
+    }
+}
+function stop() {
+    if (active()) {
+        // Stop modules in the reverse order of their initialization
+        modules.slice().reverse().forEach(function (x) { return measure(x.stop)(); });
+        stop$r();
+        stop$6();
+    }
+}
+
+var clarity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    version: version$1,
+    start: start,
+    pause: pause,
+    resume: resume,
+    stop: stop,
+    consent: consent,
+    event: event,
+    identify: identify,
+    set: set,
+    upgrade: upgrade,
+    metadata: metadata$2
+});
+
+var helper = { hash: hash, selector: selector };
+var version = version$1;
+
+export { clarity, helper, version };