@microsoft/applicationinsights-analytics-js 3.3.12-nightly3.2602-18 → 3.4.0-beta

package/dist/es5/applicationinsights-analytics-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Web Analytics, 3.3.12-nightly3.2602-18
+ * Application Insights JavaScript SDK - Web Analytics, 3.4.0-beta
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -39,6 +39,7 @@
     var CALL = "call";
     var TO_STRING = "toString";
     var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
+    var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
     var ObjClass = ( /*#__PURE__*/_pureAssign(Object));
     var ObjProto = ( /*#__PURE__*/_pureRef(ObjClass, PROTOTYPE));
     var StrCls = ( /*#__PURE__*/_pureAssign(String));
@@ -120,6 +121,9 @@
     function _returnNothing() {
         return;
     }
+    function _returnEmptyArray() {
+        return [];
+    }
     function _returnFalse() {
         return false;
     }
@@ -204,7 +208,26 @@
             throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
         };
     }
+    function _objPropertyIsEnum(obj, propKey) {
+        var desc;
+        var fn = ObjClass.getOwnPropertyDescriptor;
+        if (!isStrictNullOrUndefined(obj) && fn) {
+            desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
+        }
+        if (!desc) {
+            desc = safe(function () {
+                for (var key in obj) {
+                    if (key === propKey) {
+                        return { enumerable: true };
+                    }
+                }
+            }).v;
+        }
+        return (desc && desc.enumerable) || false;
+    }
+    var objPropertyIsEnumerable = ( /*#__PURE__*/_unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
     var _objGetOwnPropertyDescriptor$1 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    var _objGetOwnPropertySymbols = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -237,6 +260,18 @@
     function objDefine(target, key, propDesc) {
         return objDefineProp(target, key, _createProp(propDesc));
     }
+    function objDefineProps(target, propDescMap) {
+        var props = {};
+        objForEachKey(propDescMap, function (key, value) {
+            props[key] = _createProp(value);
+        });
+        arrForEach(_objGetOwnPropertySymbols(propDescMap), function (sym) {
+            if (objPropertyIsEnumerable(propDescMap, sym)) {
+                props[sym] = _createProp(propDescMap[sym]);
+            }
+        });
+        return objDefineProperties(target, props);
+    }
     /*#__NO_SIDE_EFFECTS__*/
     function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
         var theMap = {};
@@ -505,6 +540,21 @@
             toJSON: function () { return value; }
         }, "v", { value: value });
     }
+    /*#__NO_SIDE_EFFECTS__*/
+    function getDeferred(cb, argArray) {
+        var theValue = {
+            toJSON: function () { return theValue.v; }
+        };
+        return objDefineProp(theValue, "v", {
+            get: function () {
+                var result = fnApply(cb, null, argArray);
+                cb = NULL_VALUE;
+                objDefineProp(theValue, "v", { value: result });
+                return result;
+            },
+            configurable: true
+        });
+    }
     var WINDOW = "window";
     var _cachedGlobal;
     function _getGlobalInstFn(getFn, theArgs) {
@@ -750,6 +800,7 @@
         }
         return result;
     }
+    var strSplit = ( /*#__PURE__*/_unwrapFunction("split", StrProto));
     var _perf;
     /*#__NO_SIDE_EFFECTS__*/
     function getPerformance() {
@@ -759,6 +810,13 @@
         }
         return _perf.v;
     }
+    /*#__NO_SIDE_EFFECTS__*/
+    function safeGetDeferred(cb, defValue, argArray) {
+        return getDeferred(function () {
+            var result = safe(cb, argArray);
+            return result.e ? defValue : result.v;
+        });
+    }
     var mathRound = ( /*#__PURE__*/_pureRef(MathCls, "round"));
     var objGetOwnPropertyDescriptor = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
     var strEndsWith = ( /*#__PURE__*/_unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
@@ -1168,8 +1226,8 @@
 
     var createEnumStyle = createEnum;
 
-    var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
-    var _DYN_LENGTH$2 = "length";
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_LENGTH$1 = "length";
     var _DYN_WARN_TO_CONSOLE = "warnToConsole";
     var _DYN_THROW_INTERNAL = "throwInternal";
     var _DYN_WATCH = "watch";
@@ -1180,40 +1238,70 @@
     var _DYN_CANCEL = "cancel";
     var _DYN_INITIALIZE = "initialize";
     var _DYN_IDENTIFIER = "identifier";
+    var _DYN_STRINGIFY = "stringify";
+    var _DYN_TRACE_ID = "traceId";
+    var _DYN_SPAN_ID = "spanId";
+    var _DYN_TRACE_FLAGS = "traceFlags";
     var _DYN_IS_INITIALIZED = "isInitialized";
     var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_NAME$1 = "name";
+    var _DYN_NAME = "name";
+    var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
+    var _DYN_VALUE = "value";
     var _DYN_ENABLED = "enabled";
     var _DYN_UNLOAD = "unload";
+    var _DYN_REASON = "reason";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+    var _DYN_JOIN = "join";
     var _DYN_CREATE_NEW = "createNew";
     var _DYN_TEARDOWN = "teardown";
     var _DYN_MESSAGE_ID = "messageId";
-    var _DYN_MESSAGE$1 = "message";
+    var _DYN_MESSAGE = "message";
     var _DYN_DIAG_LOG$1 = "diagLog";
     var _DYN__DO_TEARDOWN = "_doTeardown";
     var _DYN_UPDATE = "update";
     var _DYN_GET_NEXT = "getNext";
     var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-    var _DYN_USER_AGENT = "userAgent";
-    var _DYN_SPLIT$1 = "split";
-    var _DYN_REPLACE = "replace";
-    var _DYN_SUBSTRING = "substring";
-    var _DYN_INDEX_OF = "indexOf";
-    var _DYN_TYPE = "type";
-    var _DYN_EVT_NAME = "evtName";
+    var _DYN_SPLIT = "split";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
+    var _DYN_DATA = "data";
     var _DYN_GET_CTX = "getCtx";
     var _DYN_SET_CTX = "setCtx";
+    var _DYN_CONFIG$1 = "config";
+    var _DYN_REPLACE = "replace";
+    var _DYN_EXCEPTION = "exception";
+    var _DYN_TYPE = "type";
+    var _DYN_MATCH = "match";
+    var _DYN_SET_TRACE_FLAGS = "setTraceFlags";
+    var _DYN_PATHNAME = "pathname";
+    var _DYN_TRACE_STATE = "traceState";
+    var _DYN_TO_STRING$1 = "toString";
+    var _DYN_EVT_NAME = "evtName";
+    var _DYN_CONCAT = "concat";
+    var _DYN_CREATE_EVENT = "createEvent";
+    var _DYN_SUBSTRING = "substring";
+    var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_GET_ATTRIBUTE = "getAttribute";
+    var _DYN_PROPERTIES$1 = "properties";
+    var _DYN_MEASUREMENTS = "measurements";
+    var _DYN_SIZE_IN_BYTES = "sizeInBytes";
+    var _DYN_TYPE_NAME = "typeName";
+    var _DYN_EXCEPTIONS = "exceptions";
+    var _DYN_SEVERITY_LEVEL = "severityLevel";
+    var _DYN_PROBLEM_GROUP = "problemGroup";
+    var _DYN_PARSED_STACK = "parsedStack";
+    var _DYN_HAS_FULL_STACK = "hasFullStack";
+    var _DYN_ASSEMBLY = "assembly";
+    var _DYN_FILE_NAME = "fileName";
+    var _DYN_LINE = "line";
+    var _DYN_AI_DATA_CONTRACT = "aiDataContract";
 
     var aggregationErrorType;
     function throwAggregationError(message, sourceErrors) {
         if (!aggregationErrorType) {
             aggregationErrorType = createCustomError("AggregationError", function (self, args) {
-                if (args[_DYN_LENGTH$2 ] > 1) {
+                if (args[_DYN_LENGTH$1 ] > 1) {
                     self.errors = args[1];
                 }
             });
@@ -1239,14 +1327,59 @@
     var STR_REDACTED = "REDACTED";
     var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
 
+    function _stringToBoolOrDefault(theValue, defaultValue, theConfig) {
+        if (!theValue && isNullOrUndefined(theValue)) {
+            return defaultValue;
+        }
+        if (isBoolean(theValue)) {
+            return theValue;
+        }
+        return asString(theValue)[_DYN_TO_LOWER_CASE ]() === "true";
+    }
+    function cfgDfMerge(defaultValue) {
+        return {
+            mrg: true,
+            v: defaultValue
+        };
+    }
+    function cfgDfSet(setter, defaultValue) {
+        return {
+            set: setter,
+            v: defaultValue
+        };
+    }
+    function cfgDfValidate(validator, defaultValue, fallBackName) {
+        return {
+            fb: fallBackName,
+            isVal: validator,
+            v: defaultValue
+        };
+    }
+    function cfgDfBoolean(defaultValue, fallBackName) {
+        return {
+            fb: fallBackName,
+            set: _stringToBoolOrDefault,
+            v: !!defaultValue
+        };
+    }
+    function cfgDfString(defaultValue) {
+        return {
+            isVal: isString,
+            v: asString(defaultValue || STR_EMPTY)
+        };
+    }
+
     var strGetPrototypeOf = "getPrototypeOf";
     var rCamelCase = /-([a-z])/g;
     var rNormalizeInvalid = /([^\w\d_$])/g;
     var rLeadingNumeric = /^(\d+[\w\d_$])/;
+    var _ProtoNameTag;
     var _getObjProto = Object[strGetPrototypeOf];
+    /*#__NO_SIDE_EFFECTS__*/
     function isNotNullOrUndefined(value) {
         return !isNullOrUndefined(value);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function normalizeJsName(name) {
         var value = name;
         if (value && isString(value)) {
@@ -1260,18 +1393,21 @@
         }
         return value;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function strContains(value, search) {
         if (value && search) {
             return strIndexOf(value, search) !== -1;
         }
         return false;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function toISOString(date) {
-        return date && date.toISOString() || "";
+        return date && date.toISOString() || STR_EMPTY;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function getExceptionName(object) {
         if (isError(object)) {
-            return object[_DYN_NAME$1 ];
+            return object[_DYN_NAME ];
         }
         return STR_EMPTY;
     }
@@ -1312,6 +1448,84 @@
             }
         }
     }
+    function setObjStringTag(target, nameOrFunc) {
+        safe(objDefine, [target, getKnownSymbol(11 ), isFunction(nameOrFunc) ? { g: nameOrFunc, e: false } : { v: nameOrFunc, w: false, e: false }]);
+        return target;
+    }
+    function setProtoTypeName(target, name) {
+        if (target) {
+            var proto_1 = _getObjProto(target);
+            var done_1 = false;
+            if (proto_1) {
+                safe(function () {
+                    var newProto = setObjStringTag(objCreate(proto_1), name);
+                    if (!_ProtoNameTag) {
+                        _ProtoNameTag = createCachedValue(newSymbol("ai$ProtoName"));
+                    }
+                    objDefine(newProto, _ProtoNameTag.v, {
+                        v: true,
+                        w: false,
+                        e: false
+                    });
+                    objSetPrototypeOf(target, newProto);
+                    done_1 = true;
+                });
+            }
+            if (!done_1) {
+                safe(setObjStringTag, [target, name]);
+            }
+        }
+        return target;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function msToTimeSpan(totalms) {
+        if (isTimeSpan(totalms)) {
+            return totalms;
+        }
+        if (isNaN(totalms) || totalms < 0) {
+            totalms = 0;
+        }
+        totalms = mathRound(totalms);
+        var ms = STR_EMPTY + totalms % 1000;
+        var sec = STR_EMPTY + mathFloor(totalms / 1000) % 60;
+        var min = STR_EMPTY + mathFloor(totalms / (1000 * 60)) % 60;
+        var hour = STR_EMPTY + mathFloor(totalms / (1000 * 60 * 60)) % 24;
+        var days = mathFloor(totalms / (1000 * 60 * 60 * 24));
+        ms = ms[_DYN_LENGTH$1 ] === 1 ? "00" + ms : ms[_DYN_LENGTH$1 ] === 2 ? "0" + ms : ms;
+        sec = sec[_DYN_LENGTH$1 ] < 2 ? "0" + sec : sec;
+        min = min[_DYN_LENGTH$1 ] < 2 ? "0" + min : min;
+        hour = hour[_DYN_LENGTH$1 ] < 2 ? "0" + hour : hour;
+        return (days > 0 ? days + "." : STR_EMPTY) + hour + ":" + min + ":" + sec + "." + ms;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isCrossOriginError(message, url, lineNumber, columnNumber, error) {
+        return !error && isString(message) && (message === "Script error." || message === "Script error");
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isTimeSpan(value) {
+        var result = false;
+        if (isString(value)) {
+            var parts = strSplit(value, ":");
+            if (parts[_DYN_LENGTH$1 ] === 3) {
+                var daysHours = strSplit(parts[0], ".");
+                if (daysHours[_DYN_LENGTH$1 ] === 2) {
+                    result = !isNaN(parseInt(daysHours[0] || "0")) && !isNaN(parseInt(daysHours[1] || "0"));
+                }
+                else {
+                    result = !isNaN(parseInt(daysHours[0] || "0"));
+                }
+                result = result && !isNaN(parseInt(parts[1] || "0"));
+                var secondsParts = strSplit(parts[2], ".");
+                if (secondsParts[_DYN_LENGTH$1 ] === 2) {
+                    result = result && !isNaN(parseInt(secondsParts[0] || "0")) && !isNaN(parseInt(secondsParts[1] || "0"));
+                }
+                else {
+                    result = result && !isNaN(parseInt(secondsParts[0] || "0"));
+                }
+            }
+        }
+        return result;
+    }
 
     var strLocation = "location";
     var strConsole = "console";
@@ -1320,9 +1534,21 @@
     var strMsCrypto = "msCrypto";
     var strMsie = "msie";
     var strTrident = "trident/";
-    var _isTrident = null;
-    var _navUserAgentCheck = null;
+    var _isTrident;
+    var _navUserAgentCheck;
     var _enableMocks = false;
+    var _userAgent;
+    /*#__NO_SIDE_EFFECTS__*/
+    function getUserAgentString() {
+        if (!_userAgent) {
+            _userAgent = getLazy(function () {
+                var nav = getNavigator() || {};
+                return nav.userAgent || STR_EMPTY;
+            });
+        }
+        return _userAgent.v;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function getLocation(checkForMock) {
         if (checkForMock && _enableMocks) {
             var mockLocation = getInst("__mockLocation");
@@ -1335,39 +1561,47 @@
         }
         return getInst(strLocation);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function getConsole() {
         if (typeof console !== strShimUndefined) {
             return console;
         }
         return getInst(strConsole);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function hasJSON() {
         return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function getJSON() {
         if (hasJSON()) {
             return JSON || getInst(strJSON);
         }
         return null;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function getCrypto() {
         return getInst(strCrypto);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function getMsCrypto() {
         return getInst(strMsCrypto);
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function isIE() {
-        var nav = getNavigator();
-        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
-            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+        var userAgent = getUserAgentString();
+        if (!_isTrident || userAgent !== _navUserAgentCheck) {
+            _navUserAgentCheck = userAgent;
+            var lwrUserAgent = _navUserAgentCheck[_DYN_TO_LOWER_CASE ]();
+            _isTrident = createCachedValue(strContains(lwrUserAgent, strMsie) || strContains(lwrUserAgent, strTrident));
         }
-        return _isTrident;
+        return _isTrident.v;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function redactUserInfo(url) {
         return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function redactQueryParameters(url, config) {
         var sensitiveParams;
         var questionMarkIndex = strIndexOf(url, "?");
@@ -1375,7 +1609,7 @@
             return url;
         }
         if (config && config.redactQueryParams) {
-            sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
+            sensitiveParams = DEFAULT_SENSITIVE_PARAMS[_DYN_CONCAT ](config.redactQueryParams);
         }
         else {
             sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
@@ -1389,7 +1623,7 @@
             queryString = strSubstring(queryString, 0, hashIndex);
         }
         var hasPotentialSensitiveParam = false;
-        for (var i = 0; i < sensitiveParams[_DYN_LENGTH$2 ]; i++) {
+        for (var i = 0; i < sensitiveParams[_DYN_LENGTH$1 ]; i++) {
             var paramCheck = sensitiveParams[i] + "=";
             if (strIndexOf(queryString, paramCheck) !== -1) {
                 hasPotentialSensitiveParam = true;
@@ -1401,9 +1635,9 @@
         }
         var resultParts = [];
         var anyParamRedacted = false;
-        if (queryString && queryString[_DYN_LENGTH$2 ]) {
-            var pairs = queryString[_DYN_SPLIT$1 ]("&");
-            for (var i = 0; i < pairs[_DYN_LENGTH$2 ]; i++) {
+        if (queryString && queryString[_DYN_LENGTH$1 ]) {
+            var pairs = queryString[_DYN_SPLIT ]("&");
+            for (var i = 0; i < pairs[_DYN_LENGTH$1 ]; i++) {
                 var pair = pairs[i];
                 if (!pair) {
                     continue;
@@ -1420,7 +1654,7 @@
                     }
                     else {
                         var shouldRedact = false;
-                        for (var j = 0; j < sensitiveParams[_DYN_LENGTH$2 ]; j++) {
+                        for (var j = 0; j < sensitiveParams[_DYN_LENGTH$1 ]; j++) {
                             if (paramName === sensitiveParams[j]) {
                                 shouldRedact = true;
                                 anyParamRedacted = true;
@@ -1440,10 +1674,11 @@
         if (!anyParamRedacted) {
             return url;
         }
-        return baseUrl + resultParts.join("&") + fragment;
+        return baseUrl + resultParts[_DYN_JOIN ]("&") + fragment;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function fieldRedaction(input, config) {
-        if (!input || !isString(input) || input[_DYN_INDEX_OF ](" ") !== -1) {
+        if (!input || !isString(input) || strIndexOf(input, " ") !== -1) {
             return input;
         }
         var isRedactionDisabled = config && config.redactUrls === false;
@@ -1488,7 +1723,7 @@
     function _autoSeedMwc() {
         try {
             var now = utcNow() & 0x7fffffff;
-            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+            _mwcSeed(((mathRandom() * UInt32Mask) ^ now) + now);
         }
         catch (e) {
         }
@@ -1506,7 +1741,7 @@
             value = mwcRandom32() & MaxUInt32;
         }
         if (value === 0) {
-            value = mathFloor((UInt32Mask * Math.random()) | 0);
+            value = mathFloor((UInt32Mask * mathRandom()) | 0);
         }
         if (!signed) {
             value >>>= 0;
@@ -1528,7 +1763,7 @@
         var number = random32() >>> 0;
         var chars = 0;
         var result = STR_EMPTY;
-        while (result[_DYN_LENGTH$2 ] < maxLength) {
+        while (result[_DYN_LENGTH$1 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
             number >>>= 6;
@@ -1540,7 +1775,7 @@
         return result;
     }
 
-    var version = '3.3.12-nightly3.2602-18';
+    var version = '3.4.0-beta';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -1608,7 +1843,7 @@
             if (!isArray(fallbacks)) {
                 fallbacks = [fallbacks];
             }
-            for (var lp = 0; lp < fallbacks[_DYN_LENGTH$2 ]; lp++) {
+            for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1 ]; lp++) {
                 var fallback = fallbacks[lp];
                 var fbValue = theConfig[fallback];
                 if (isDefaultValid(fbValue)) {
@@ -1643,7 +1878,7 @@
             var newValue_1;
             if (isArray(theValue)) {
                 newValue_1 = [];
-                newValue_1[_DYN_LENGTH$2 ] = theValue[_DYN_LENGTH$2 ];
+                newValue_1[_DYN_LENGTH$1 ] = theValue[_DYN_LENGTH$1 ];
             }
             else if (isPlainObject(theValue)) {
                 newValue_1 = {};
@@ -1734,7 +1969,7 @@
             var target_1;
             if (isArray(source)) {
                 target_1 = [];
-                target_1[_DYN_LENGTH$2 ] = source[_DYN_LENGTH$2 ];
+                target_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
             }
             else if (isPlainObject(source)) {
                 target_1 = {};
@@ -2042,13 +2277,13 @@
                         watcherFailures_1[_DYN_PUSH ](e);
                     }
                 }
-                if (watcherFailures_1[_DYN_LENGTH$2 ] > 0) {
+                if (watcherFailures_1[_DYN_LENGTH$1 ] > 0) {
                     throwAggregationError("Watcher error(s): ", watcherFailures_1);
                 }
             }
         }
         function _addWatcher(detail) {
-            if (detail && detail.h[_DYN_LENGTH$2 ] > 0) {
+            if (detail && detail.h[_DYN_LENGTH$1 ] > 0) {
                 if (!_waitingHandlers) {
                     _waitingHandlers = [];
                 }
@@ -2058,7 +2293,7 @@
                         _notifyWatchers();
                     }, 0);
                 }
-                for (var idx = 0; idx < detail.h[_DYN_LENGTH$2 ]; idx++) {
+                for (var idx = 0; idx < detail.h[_DYN_LENGTH$1 ]; idx++) {
                     var handler = detail.h[idx];
                     if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
                         _waitingHandlers[_DYN_PUSH ](handler);
@@ -2097,7 +2332,7 @@
                 configHandler = null;
             }
         };
-        objDefine(handler, "toJSON", { v: function () { return "WatcherHandler" + (handler.fn ? "" : "[X]"); } });
+        objDefine(handler, "toJSON", { v: function () { return "WatcherHandler" + (handler.fn ? STR_EMPTY : "[X]"); } });
         state.use(handler, configHandler);
         return handler;
     }
@@ -2206,47 +2441,8 @@
         return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
-    function _stringToBoolOrDefault(theValue, defaultValue, theConfig) {
-        if (!theValue && isNullOrUndefined(theValue)) {
-            return defaultValue;
-        }
-        if (isBoolean(theValue)) {
-            return theValue;
-        }
-        return asString(theValue)[_DYN_TO_LOWER_CASE$1 ]() === "true";
-    }
-    function cfgDfMerge(defaultValue) {
-        return {
-            mrg: true,
-            v: defaultValue
-        };
-    }
-    function cfgDfSet(setter, defaultValue) {
-        return {
-            set: setter,
-            v: defaultValue
-        };
-    }
-    function cfgDfValidate(validator, defaultValue, fallBackName) {
-        return {
-            fb: fallBackName,
-            isVal: validator,
-            v: defaultValue
-        };
-    }
-    function cfgDfBoolean(defaultValue, fallBackName) {
-        return {
-            fb: fallBackName,
-            set: _stringToBoolOrDefault,
-            v: !!defaultValue
-        };
-    }
-    function cfgDfString(defaultValue) {
-        return {
-            isVal: isString,
-            v: asString(defaultValue || STR_EMPTY)
-        };
-    }
+    var strNotSpecified = "not_specified";
+    var strIkey = "iKey";
 
     var _aiNamespace = null;
     function _getExtensionNamespace() {
@@ -2304,20 +2500,21 @@
             if (isUserAct === void 0) { isUserAct = false; }
             var _self = this;
             _self[_DYN_MESSAGE_ID ] = msgId;
-            _self[_DYN_MESSAGE$1 ] =
+            _self[_DYN_MESSAGE ] =
                 (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                     msgId;
             var strProps = STR_EMPTY;
             if (hasJSON()) {
-                strProps = getJSON().stringify(properties);
+                strProps = getJSON()[_DYN_STRINGIFY ](properties);
             }
             var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
                 (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
-            _self[_DYN_MESSAGE$1 ] += diagnosticText;
+            _self[_DYN_MESSAGE ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
         return _InternalLogMessage;
     }());
+    /*#__NO_SIDE_EFFECTS__*/
     function safeGetLogger(core, config) {
         return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
     }
@@ -2343,17 +2540,17 @@
                     }
                     else {
                         var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
-                        if (!isUndefined(message[_DYN_MESSAGE$1 ])) {
+                        if (!isUndefined(message[_DYN_MESSAGE ])) {
                             if (isUserAct) {
                                 var messageKey = +message[_DYN_MESSAGE_ID ];
                                 if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                     _messageLogged[messageKey] = true;
                                 }
                             }
                             else {
                                 if (_loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                 }
                             }
                             _logInternalMessage(severity, message);
@@ -2384,6 +2581,9 @@
                     _unloadHandler && _unloadHandler.rm();
                     _unloadHandler = null;
                 };
+                objDefine(_self, "dbgMode", {
+                    g: function () { return _enableDebug; }
+                });
                 function _logInternalMessage(severity, message) {
                     if (_areInternalMessagesThrottled()) {
                         return;
@@ -2449,61 +2649,361 @@
         _getLogger(logger)[_DYN_WARN_TO_CONSOLE ](message);
     }
 
-    var _a$2, _b;
-    var strToGMTString = "toGMTString";
-    var strToUTCString = "toUTCString";
-    var strCookie = "cookie";
-    var strExpires = "expires";
-    var strIsCookieUseDisabled = "isCookieUseDisabled";
-    var strDisableCookiesUsage = "disableCookiesUsage";
-    var strConfigCookieMgr = "_ckMgr";
-    var _supportsCookies = null;
-    var _allowUaSameSite = null;
-    var _parsedCookieValue = null;
-    var _doc;
-    var _cookieCache = {};
-    var _globalCookieConfig = {};
-    var rootDefaultConfig = (_a$2 = {
-            cookieCfg: cfgDfMerge((_b = {},
-                _b[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
-                _b.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
-                _b.enabled = UNDEFINED_VALUE,
-                _b.ignoreCookies = UNDEFINED_VALUE,
-                _b.blockedCookies = UNDEFINED_VALUE,
-                _b.disableCookieDefer = false,
-                _b)),
-            cookieDomain: UNDEFINED_VALUE,
-            cookiePath: UNDEFINED_VALUE
-        },
-        _a$2[strDisableCookiesUsage] = UNDEFINED_VALUE,
-        _a$2);
-    function _getDoc() {
-        !_doc && (_doc = getLazy(function () { return getDocument(); }));
+    function _noopVoid() {
     }
-    function _gblCookieMgr(config, logger) {
-        var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
-        if (!inst) {
-            inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
-            _globalCookieConfig[strConfigCookieMgr] = inst;
+
+    var MAX_TRACE_STATE_MEMBERS = 32;
+    var MAX_TRACE_STATE_LEN = 512;
+    var LCALPHA = "[a-z]";
+    var LCALPHA_DIGIT = "[a-z\\d]";
+    var LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH = "[a-z\\d_\\-*\\/]";
+    var SIMPLE_KEY = "(" + LCALPHA + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,255})";
+    var TENANT_ID = "(" + LCALPHA_DIGIT + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,240})";
+    var SYSTEM_ID = "(" + LCALPHA + LCALPHA_DIGIT_UNDERSCORE_DASH_STAR_SLASH + "{0,13})";
+    var MULTI_TENANT_KEY = "(" + TENANT_ID + "@" + SYSTEM_ID + ")";
+    var NBLK_CHAR = "\x21-\x2B\\--\x3C\x3E-\x7E";
+    var TRACESTATE_VALUE = "[\x20" + NBLK_CHAR + "]{0,255}[" + NBLK_CHAR + "]";
+    var TRACESTATE_KVP_REGEX = ( /*#__PURE__*/new RegExp("^\\s*((?:" + SIMPLE_KEY + "|" + MULTI_TENANT_KEY + ")=(" + TRACESTATE_VALUE + "))\\s*$"));
+    function _parseListMember(value) {
+        if (value) {
+            TRACESTATE_KVP_REGEX.lastIndex = 0;
+            var match = TRACESTATE_KVP_REGEX.exec(value);
+            if (match && match[_DYN_LENGTH$1 ] >= 7 && match[1] && match[6]) {
+                var type = match[3] ? 1  : 0 ;
+                var multiTenant = null;
+                if (type === 1 ) {
+                    multiTenant = {
+                        tenantId: match[4],
+                        systemId: match[5]
+                    };
+                }
+                var parts = {
+                    type: type,
+                    key: match[2],
+                    multiTenant: multiTenant,
+                    value: match[6]
+                };
+                return parts;
+            }
         }
-        return inst;
+        return null;
     }
-    function _isMgrEnabled(cookieMgr) {
-        if (cookieMgr) {
-            return cookieMgr.isEnabled();
+    function _parseTraceStateList(value) {
+        var items = [];
+        if (value) {
+            var addedKeys_1 = [];
+            arrForEach(strSplit(value, ","), function (member) {
+                var parts = _parseListMember(member);
+                if (parts) {
+                    if (arrIndexOf(addedKeys_1, parts.key) === -1) {
+                        items[_DYN_PUSH ](parts);
+                        addedKeys_1[_DYN_PUSH ](parts.key);
+                        if (items[_DYN_LENGTH$1 ] >= MAX_TRACE_STATE_MEMBERS) {
+                            return -1;
+                        }
+                    }
+                }
+            });
         }
-        return true;
+        return items;
     }
-    function _isIgnoredCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
-            return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
+    function _indexOf(items, key) {
+        for (var lp = 0; lp < items[_DYN_LENGTH$1 ]; lp++) {
+            if (items[lp].key === key) {
+                return lp;
+            }
         }
-        return false;
+        return -1;
     }
-    function _isBlockedCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
-            if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
-                return true;
+    function _keys(items, parent) {
+        var keys = [];
+        var delKeys = [];
+        arrForEach(items, function (member) {
+            if (member[_DYN_VALUE ] != null) {
+                keys[_DYN_PUSH ](member.key);
+            }
+            else {
+                delKeys[_DYN_PUSH ](member.key);
+            }
+        });
+        if (parent) {
+            arrForEach(parent.keys, function (key) {
+                if (arrIndexOf(keys, key) === -1 && arrIndexOf(delKeys, key) === -1) {
+                    keys[_DYN_PUSH ](key);
+                }
+            });
+        }
+        return keys;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function _isEmpty(items, parent) {
+        var delKeys;
+        var isEmpty = true;
+        if (items && items[_DYN_LENGTH$1 ] > 0) {
+            arrForEach(items, function (member) {
+                if (member[_DYN_VALUE ] != null) {
+                    isEmpty = false;
+                }
+                else {
+                    if (!delKeys) {
+                        delKeys = [];
+                    }
+                    delKeys[_DYN_PUSH ](member.key);
+                }
+            });
+        }
+        if (isEmpty && parent) {
+            isEmpty = parent.isEmpty;
+            if (!isEmpty && delKeys && delKeys[_DYN_LENGTH$1 ] > 0) {
+                isEmpty = true;
+                arrForEach(parent.keys, function (key) {
+                    if (arrIndexOf(delKeys, key) === -1) {
+                        isEmpty = false;
+                        return -1;
+                    }
+                });
+            }
+        }
+        return isEmpty;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isW3cTraceState(value) {
+        return !!(value && isArray(value.keys) && isFunction(value.get) && isFunction(value.set) && isFunction(value.del) && isFunction(value.hdrs));
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function createW3cTraceState(value, parent) {
+        var cachedItems = safeGetDeferred(_parseTraceStateList, [], [value || STR_EMPTY]);
+        function _get(key) {
+            var value;
+            var theItems = cachedItems.v;
+            var idx = _indexOf(theItems, key);
+            if (idx !== -1) {
+                var itmValue = theItems[idx][_DYN_VALUE ];
+                if (itmValue != null) {
+                    value = itmValue;
+                }
+            }
+            else if (parent) {
+                value = parent.get(key);
+            }
+            return value;
+        }
+        function _setMember(member) {
+            if (member) {
+                var theItems = cachedItems.v;
+                var idx = _indexOf(theItems, member.key);
+                if (idx !== -1) {
+                    theItems[_DYN_SPLICE ](idx, 1);
+                }
+                theItems.unshift(member);
+                cachedItems = createCachedValue(theItems);
+                return 0;
+            }
+            return -1;
+        }
+        function _set(key, value) {
+            var member;
+            if (key && isString(key) && !isNullOrUndefined(value) && isString(value)) {
+                member = _parseListMember(key + "=" + value);
+            }
+            return _setMember(member);
+        }
+        function _del(key) {
+            _setMember({
+                type: 2 ,
+                key: key
+            });
+        }
+        function _headers(maxHeaders, maxKeys, maxLen) {
+            var results = [];
+            var result = STR_EMPTY;
+            var numKeys = 0;
+            var len = 0;
+            maxKeys = maxKeys || MAX_TRACE_STATE_MEMBERS;
+            maxLen = maxLen || MAX_TRACE_STATE_LEN;
+            var theItems = cachedItems.v;
+            arrForEach(_keys(theItems, parent), function (key) {
+                var value = _get(key);
+                if (!isNullOrUndefined(value) && isString(value)) {
+                    numKeys++;
+                    var val = key + "=" + value;
+                    var valLen = val[_DYN_LENGTH$1 ];
+                    if (len + 1 + valLen >= maxLen) {
+                        results[_DYN_PUSH ](result);
+                        if (maxHeaders && results[_DYN_LENGTH$1 ] <= maxHeaders) {
+                            return -1;
+                        }
+                        result = STR_EMPTY;
+                        len = 0;
+                    }
+                    if (result[_DYN_LENGTH$1 ] > 0) {
+                        result += ",";
+                        len++;
+                    }
+                    result += val;
+                    len += valLen;
+                    if (numKeys >= maxKeys) {
+                        return -1;
+                    }
+                }
+            });
+            if (result) {
+                results[_DYN_PUSH ](result);
+            }
+            return results;
+        }
+        var traceStateList = {
+            keys: [],
+            isEmpty: false,
+            get: _get,
+            set: _set,
+            del: _del,
+            hdrs: _headers,
+            child: function () { return createW3cTraceState(null, traceStateList); }
+        };
+        function _toString() {
+            var headers = traceStateList.hdrs(1);
+            return headers[_DYN_LENGTH$1 ] > 0 ? headers[0] : STR_EMPTY;
+        }
+        objDefineProps(traceStateList, {
+            "keys": {
+                g: function () { return _keys(cachedItems.v, parent); }
+            },
+            "isEmpty": {
+                g: function () { return _isEmpty(cachedItems.v, parent); }
+            },
+            "toString": {
+                v: _toString,
+                e: false
+            },
+            "_p": {
+                v: parent,
+                e: false
+            }
+        });
+        setObjStringTag(traceStateList, _toString);
+        return traceStateList;
+    }
+
+    function generateW3CId() {
+        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+        var oct = STR_EMPTY, tmp;
+        for (var a = 0; a < 4; a++) {
+            tmp = random32();
+            oct +=
+                hexValues[tmp & 0xF] +
+                    hexValues[tmp >> 4 & 0xF] +
+                    hexValues[tmp >> 8 & 0xF] +
+                    hexValues[tmp >> 12 & 0xF] +
+                    hexValues[tmp >> 16 & 0xF] +
+                    hexValues[tmp >> 20 & 0xF] +
+                    hexValues[tmp >> 24 & 0xF] +
+                    hexValues[tmp >> 28 & 0xF];
+        }
+        var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
+        return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+    }
+
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH$1 ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/i);
+        }
+        return false;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isValidTraceId(value) {
+        return _isValid(value, 32, INVALID_TRACE_ID);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isValidSpanId(value) {
+        return _isValid(value, 16, INVALID_SPAN_ID);
+    }
+    function findAllScripts(doc) {
+        var scripts = doc.getElementsByTagName("script");
+        var result = [];
+        arrForEach(scripts, function (script) {
+            var src = script[_DYN_GET_ATTRIBUTE ]("src");
+            if (src) {
+                var crossOrigin = script[_DYN_GET_ATTRIBUTE ]("crossorigin");
+                var async = script.hasAttribute("async") === true;
+                var defer = script.hasAttribute("defer") === true;
+                var referrerPolicy = script[_DYN_GET_ATTRIBUTE ]("referrerpolicy");
+                var info = { url: src };
+                if (crossOrigin) {
+                    info.crossOrigin = crossOrigin;
+                }
+                if (async) {
+                    info.async = async;
+                }
+                if (defer) {
+                    info.defer = defer;
+                }
+                if (referrerPolicy) {
+                    info.referrerPolicy = referrerPolicy;
+                }
+                result[_DYN_PUSH ](info);
+            }
+        });
+        return result;
+    }
+
+    var _a$2, _b;
+    var strToGMTString = "toGMTString";
+    var strToUTCString = "toUTCString";
+    var strCookie = "cookie";
+    var strExpires = "expires";
+    var strIsCookieUseDisabled = "isCookieUseDisabled";
+    var strDisableCookiesUsage = "disableCookiesUsage";
+    var strConfigCookieMgr = "_ckMgr";
+    var _supportsCookies = null;
+    var _allowUaSameSite = null;
+    var _parsedCookieValue = null;
+    var _doc;
+    var _cookieCache = {};
+    var _globalCookieConfig = {};
+    var rootDefaultConfig = (_a$2 = {
+            cookieCfg: cfgDfMerge((_b = {},
+                _b[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+                _b.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+                _b.enabled = UNDEFINED_VALUE,
+                _b.ignoreCookies = UNDEFINED_VALUE,
+                _b.blockedCookies = UNDEFINED_VALUE,
+                _b.disableCookieDefer = false,
+                _b)),
+            cookieDomain: UNDEFINED_VALUE,
+            cookiePath: UNDEFINED_VALUE
+        },
+        _a$2[strDisableCookiesUsage] = UNDEFINED_VALUE,
+        _a$2);
+    function _getDoc() {
+        !_doc && (_doc = getLazy(function () { return getDocument(); }));
+    }
+    function _gblCookieMgr(config, logger) {
+        var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
+        if (!inst) {
+            inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
+            _globalCookieConfig[strConfigCookieMgr] = inst;
+        }
+        return inst;
+    }
+    function _isMgrEnabled(cookieMgr) {
+        if (cookieMgr) {
+            return cookieMgr.isEnabled();
+        }
+        return true;
+    }
+    function _isIgnoredCookie(cookieMgrCfg, name) {
+        if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
+            return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
+        }
+        return false;
+    }
+    function _isBlockedCookie(cookieMgrCfg, name) {
+        if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
+            if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
+                return true;
             }
         }
         return _isIgnoredCookie(cookieMgrCfg, name);
@@ -2590,7 +3090,7 @@
             if (location && location.protocol === "https:") {
                 setValue(values, "secure", null, null, isUndefined);
                 if (_allowUaSameSite === null) {
-                    _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+                    _allowUaSameSite = !uaDisallowsSameSiteNone(getUserAgentString());
                 }
                 if (_allowUaSameSite) {
                     setValue(values, "SameSite", "None", null, isUndefined);
@@ -2601,7 +3101,7 @@
         }
         function _removePendingCookie(name) {
             if (_pendingCookies) {
-                for (var i = _pendingCookies[_DYN_LENGTH$2 ] - 1; i >= 0; i--) {
+                for (var i = _pendingCookies[_DYN_LENGTH$1 ] - 1; i >= 0; i--) {
                     if (_pendingCookies[i].n === name) {
                         _pendingCookies[_DYN_SPLICE ](i, 1);
                     }
@@ -2688,7 +3188,7 @@
                         value = _getCookieFn(name);
                     }
                     else if (_pendingCookies) {
-                        for (var i = _pendingCookies[_DYN_LENGTH$2 ] - 1; i >= 0; i--) {
+                        for (var i = _pendingCookies[_DYN_LENGTH$1 ] - 1; i >= 0; i--) {
                             var pendingData = _pendingCookies[i];
                             if (pendingData.n === name) {
                                 if (pendingData.o === 0 ) {
@@ -2752,8 +3252,8 @@
     }
     function _extractParts(theValue) {
         var values = {};
-        if (theValue && theValue[_DYN_LENGTH$2 ]) {
-            var parts = strTrim(theValue)[_DYN_SPLIT$1 ](";");
+        if (theValue && theValue[_DYN_LENGTH$1 ]) {
+            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
             arrForEach(parts, function (thePart) {
                 thePart = strTrim(thePart || STR_EMPTY);
                 if (thePart) {
@@ -2833,7 +3333,7 @@
         function PerfEvent(name, payloadDetails, isAsync) {
             var _self = this;
             _self.start = utcNow();
-            _self[_DYN_NAME$1 ] = name;
+            _self[_DYN_NAME ] = name;
             _self.isAsync = isAsync;
             _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
             if (isFunction(payloadDetails)) {
@@ -2878,16 +3378,16 @@
                 var childTime = 0;
                 var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
                 if (isArray(childEvts)) {
-                    for (var lp = 0; lp < childEvts[_DYN_LENGTH$2 ]; lp++) {
+                    for (var lp = 0; lp < childEvts[_DYN_LENGTH$1 ]; lp++) {
                         var childEvt = childEvts[lp];
                         if (childEvt) {
-                            childTime += childEvt.time;
+                            childTime += childEvt[_DYN_TIME ];
                         }
                     }
                 }
-                _self.time = utcNow() - _self.start;
-                _self.exTime = _self.time - childTime;
-                _self.complete = function () { };
+                _self[_DYN_TIME ] = utcNow() - _self.start;
+                _self.exTime = _self[_DYN_TIME ] - childTime;
+                _self.complete = _noopVoid;
             };
         }
         PerfEvent.ParentContextKey = "parent";
@@ -2938,72 +3438,298 @@
         return func();
     }
 
-    function generateW3CId() {
-        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY, tmp;
-        for (var a = 0; a < 4; a++) {
-            tmp = random32();
-            oct +=
-                hexValues[tmp & 0xF] +
-                    hexValues[tmp >> 4 & 0xF] +
-                    hexValues[tmp >> 8 & 0xF] +
-                    hexValues[tmp >> 12 & 0xF] +
-                    hexValues[tmp >> 16 & 0xF] +
-                    hexValues[tmp >> 20 & 0xF] +
-                    hexValues[tmp >> 24 & 0xF] +
-                    hexValues[tmp >> 28 & 0xF];
+    var _otelTraceState;
+    function _initOTelTraceStateSymbol() {
+        if (!_otelTraceState) {
+            _otelTraceState = createCachedValue(symbolFor("otTraceState"));
         }
-        var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
-        return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+        return _otelTraceState;
     }
-
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/i);
-        }
-        return false;
+    /*#__NO_SIDE_EFFECTS__*/
+    function _createOTelTraceState(traceState) {
+        if (!_otelTraceState) {
+            _otelTraceState = _initOTelTraceStateSymbol();
+        }
+        var otTraceState = {
+            set: function (key, value) {
+                var newState = createW3cTraceState(STR_EMPTY, traceState);
+                newState.set(key, value);
+                return _createOTelTraceState(newState);
+            },
+            unset: function (key) {
+                var newState = createW3cTraceState(STR_EMPTY, traceState);
+                newState.del(key);
+                return _createOTelTraceState(newState);
+            },
+            get: function (key) {
+                return traceState.get(key);
+            },
+            serialize: function () {
+                var headers = traceState.hdrs(1);
+                if (headers[_DYN_LENGTH$1 ] > 0) {
+                    return headers[0];
+                }
+                return STR_EMPTY;
+            }
+        };
+        objDefine(otTraceState, _otelTraceState.v, { g: function () { return traceState; } });
+        return otTraceState;
     }
-    function isValidTraceId(value) {
-        return _isValid(value, 32, INVALID_TRACE_ID);
+    /*#__NO_SIDE_EFFECTS__*/
+    function isOTelTraceState(value) {
+        if (!_otelTraceState) {
+            _otelTraceState = _initOTelTraceStateSymbol();
+        }
+        if (value && value[_otelTraceState.v]) {
+            return true;
+        }
+        return value && isFunction(value.serialize) && isFunction(value.unset) && isFunction(value.get) && isFunction(value.set);
     }
-    function isValidSpanId(value) {
-        return _isValid(value, 16, INVALID_SPAN_ID);
+    /*#__NO_SIDE_EFFECTS__*/
+    function createOTelTraceState(value) {
+        var traceState = null;
+        if (isOTelTraceState(value)) {
+            var parentTraceState = void 0;
+            if (_otelTraceState) {
+                parentTraceState = value[_otelTraceState.v];
+            }
+            if (parentTraceState) {
+                traceState = createW3cTraceState(STR_EMPTY, parentTraceState);
+            }
+            else {
+                traceState = createW3cTraceState(value.serialize());
+            }
+        }
+        else if (isW3cTraceState(value)) {
+            traceState = value;
+        }
+        else {
+            traceState = createW3cTraceState(isString(value) ? value : STR_EMPTY);
+        }
+        return _createOTelTraceState(traceState);
     }
-    function findAllScripts(doc) {
-        var scripts = doc.getElementsByTagName("script");
-        var result = [];
-        arrForEach(scripts, function (script) {
-            var src = script[_DYN_GET_ATTRIBUTE ]("src");
-            if (src) {
-                var crossOrigin = script[_DYN_GET_ATTRIBUTE ]("crossorigin");
-                var async = script.hasAttribute("async") === true;
-                var defer = script.hasAttribute("defer") === true;
-                var referrerPolicy = script[_DYN_GET_ATTRIBUTE ]("referrerpolicy");
-                var info = { url: src };
-                if (crossOrigin) {
-                    info.crossOrigin = crossOrigin;
-                }
-                if (async) {
-                    info.async = async;
-                }
-                if (defer) {
-                    info.defer = defer;
-                }
-                if (referrerPolicy) {
-                    info.referrerPolicy = referrerPolicy;
+
+    function createOTelSpanContext(traceContext) {
+        var traceId = isValidTraceId(traceContext[_DYN_TRACE_ID ]) ? traceContext[_DYN_TRACE_ID ] : INVALID_TRACE_ID;
+        var spanId = isValidSpanId(traceContext[_DYN_SPAN_ID ]) ? traceContext[_DYN_SPAN_ID ] : INVALID_SPAN_ID;
+        var isRemote = traceContext.isRemote;
+        var traceFlags = (!isNullOrUndefined(traceContext[_DYN_TRACE_FLAGS ]) ? traceContext[_DYN_TRACE_FLAGS ] : 1 );
+        var otTraceState = null;
+        var traceContextObj = {
+            traceId: traceId,
+            spanId: spanId,
+            traceFlags: traceFlags
+        };
+        return objDefineProps(traceContextObj, {
+            traceId: {
+                g: function () { return traceId; },
+                s: function (value) { return traceId = isValidTraceId(value) ? value : INVALID_TRACE_ID; }
+            },
+            spanId: {
+                g: function () { return spanId; },
+                s: function (value) { return spanId = isValidSpanId(value) ? value : INVALID_SPAN_ID; }
+            },
+            isRemote: {
+                g: function () { return isRemote; }
+            },
+            traceFlags: {
+                g: function () { return traceFlags; },
+                s: function (value) { return traceFlags = value; }
+            },
+            traceState: {
+                g: function () {
+                    if (!otTraceState) {
+                        otTraceState = createOTelTraceState(traceContext[_DYN_TRACE_STATE ]);
+                    }
+                    return otTraceState;
+                },
+                s: function (value) {
+                    otTraceState = value;
                 }
-                result[_DYN_PUSH ](info);
             }
         });
-        return result;
     }
 
     var pluginStateData = createElmNodeData("plugin");
     function _getPluginState(plugin) {
         return pluginStateData.get(plugin, "state", {}, true);
     }
+    /*#__NO_SIDE_EFFECTS__*/
+    function isDistributedTraceContext(obj) {
+        return obj &&
+            isFunction(obj.getName) &&
+            isFunction(obj.getTraceId) &&
+            isFunction(obj.getSpanId) &&
+            isFunction(obj.getTraceFlags) &&
+            isFunction(obj.setName) &&
+            isFunction(obj.setTraceId) &&
+            isFunction(obj.setSpanId) &&
+            isFunction(obj[_DYN_SET_TRACE_FLAGS ]);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function createDistributedTraceContext(parent) {
+        var _a;
+        var parentCtx = null;
+        var initCtx = null;
+        var traceId = (parent && isValidTraceId(parent[_DYN_TRACE_ID ])) ? parent[_DYN_TRACE_ID ] : generateW3CId();
+        var spanId = (parent && isValidSpanId(parent[_DYN_SPAN_ID ])) ? parent[_DYN_SPAN_ID ] : STR_EMPTY;
+        var traceFlags = parent ? parent[_DYN_TRACE_FLAGS ] : UNDEFINED_VALUE;
+        var isRemote = parent ? parent.isRemote : false;
+        var pageName = STR_EMPTY;
+        var traceState = null;
+        if (parent) {
+            if (isDistributedTraceContext(parent)) {
+                parentCtx = parent;
+                pageName = parentCtx.getName();
+            }
+            else {
+                initCtx = parent;
+            }
+        }
+        if (!pageName) {
+            pageName = "_unknown_";
+            var location_1 = getLocation();
+            if (location_1 && location_1[_DYN_PATHNAME ]) {
+                pageName = location_1[_DYN_PATHNAME ] + (location_1.hash || "");
+            }
+        }
+        function _getName() {
+            return pageName;
+        }
+        function _setPageNameFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setName(newValue);
+                }
+                pageName = newValue;
+            };
+        }
+        function _getTraceId() {
+            return traceId;
+        }
+        function _setTraceIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setTraceId(newValue);
+                }
+                if (isValidTraceId(newValue)) {
+                    traceId = newValue;
+                }
+            };
+        }
+        function _getSpanId() {
+            return spanId;
+        }
+        function _setSpanIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setSpanId(newValue);
+                }
+                if (isValidSpanId(newValue)) {
+                    spanId = newValue;
+                }
+            };
+        }
+        function _getTraceFlags() {
+            return traceFlags;
+        }
+        function _setTraceFlagsFn(updateParent) {
+            return function (newTraceFlags) {
+                if (updateParent) {
+                    parentCtx && parentCtx[_DYN_SET_TRACE_FLAGS ](newTraceFlags);
+                }
+                traceFlags = newTraceFlags;
+            };
+        }
+        function _getTraceState() {
+            if (!traceState) {
+                if (!parentCtx) {
+                    if (initCtx) {
+                        if (isOTelTraceState(initCtx[_DYN_TRACE_STATE ])) {
+                            traceState = createW3cTraceState(initCtx[_DYN_TRACE_STATE ].serialize() || STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
+                        }
+                        else {
+                            traceState = createW3cTraceState(STR_EMPTY, initCtx[_DYN_TRACE_STATE ] || (parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined));
+                        }
+                    }
+                }
+                if (!traceState) {
+                    traceState = createW3cTraceState(STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
+                }
+            }
+            return traceState;
+        }
+        var otelSpanCtx = null;
+        var traceCtx = setProtoTypeName((_a = {
+                getName: _getName,
+                setName: _setPageNameFn(true),
+                getTraceId: _getTraceId,
+                setTraceId: _setTraceIdFn(true),
+                getSpanId: _getSpanId,
+                setSpanId: _setSpanIdFn(true),
+                getTraceFlags: _getTraceFlags
+            },
+            _a[_DYN_SET_TRACE_FLAGS ] = _setTraceFlagsFn(true),
+            _a.traceId = traceId,
+            _a.spanId = spanId,
+            _a.traceFlags = traceFlags,
+            _a.traceState = traceState,
+            _a.isRemote = isRemote,
+            _a.pageName = pageName,
+            _a.getOTelSpanContext = function () {
+                if (!otelSpanCtx) {
+                    otelSpanCtx = createOTelSpanContext(traceCtx);
+                }
+                return otelSpanCtx;
+            },
+            _a), "DistributedTraceContext");
+        return objDefineProps(traceCtx, {
+            pageName: {
+                g: _getName,
+                s: _setPageNameFn(false)
+            },
+            traceId: {
+                g: _getTraceId,
+                s: _setTraceIdFn(false)
+            },
+            spanId: {
+                g: _getSpanId,
+                s: _setSpanIdFn(false)
+            },
+            traceFlags: {
+                g: _getTraceFlags,
+                s: _setTraceFlagsFn(false)
+            },
+            isRemote: {
+                v: isRemote,
+                w: false
+            },
+            traceState: {
+                g: _getTraceState
+            },
+            parentCtx: {
+                g: function () { return parentCtx; }
+            },
+            _parent: {
+                g: function () {
+                    var result;
+                    if (parentCtx) {
+                        result = {
+                            t: "traceCtx",
+                            v: parentCtx
+                        };
+                    }
+                    else if (initCtx) {
+                        result = {
+                            t: "initCtx",
+                            v: initCtx
+                        };
+                    }
+                    return result;
+                }
+            }
+        });
+    }
 
     var strTelemetryPluginChain = "TelemetryPluginChain";
     var strHasRunFlags = "_hasRun";
@@ -3016,7 +3742,7 @@
             }
             proxy = proxy[_DYN_GET_NEXT ]();
         }
-        return createTelemetryProxyChain([startAt], core.config || {}, core);
+        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG$1 ] || {}, core);
     }
     function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
         var _nextProxy = null;
@@ -3072,7 +3798,7 @@
             _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
             if (!nextProxy) {
                 var onComplete = _onComplete;
-                if (onComplete && onComplete[_DYN_LENGTH$2 ] > 0) {
+                if (onComplete && onComplete[_DYN_LENGTH$1 ] > 0) {
                     arrForEach(onComplete, function (completeDetails) {
                         try {
                             completeDetails.func.call(completeDetails.self, completeDetails.args);
@@ -3088,27 +3814,26 @@
         }
         function _getExtCfg(identifier, createIfMissing) {
             var idCfg = null;
-            var cfg = dynamicHandler.cfg;
+            var extCfg = _getCfg(dynamicHandler.cfg, "extensionConfig", createIfMissing);
+            if (extCfg) {
+                idCfg = _getCfg(extCfg, identifier, createIfMissing);
+            }
+            return idCfg;
+        }
+        function _getCfg(cfg, identifier, createIfMissing) {
+            var idCfg = null;
             if (cfg && identifier) {
-                var extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (!extCfg && createIfMissing) {
-                    extCfg = {};
-                }
-                cfg[STR_EXTENSION_CONFIG] = extCfg;
-                extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
-                if (extCfg) {
-                    idCfg = extCfg[identifier];
-                    if (!idCfg && createIfMissing) {
-                        idCfg = {};
-                    }
-                    extCfg[identifier] = idCfg;
-                    idCfg = dynamicHandler.ref(extCfg, identifier);
+                idCfg = cfg[identifier];
+                if (!idCfg && createIfMissing) {
+                    idCfg = {};
                 }
+                cfg[identifier] = idCfg;
+                idCfg = dynamicHandler.ref(cfg, identifier);
             }
             return idCfg;
         }
-        function _resolveExtCfg(identifier, defaultValues) {
-            var newConfig = _getExtCfg(identifier, true);
+        function _resolveExtCfg(identifier, defaultValues, rootOnly) {
+            var newConfig = rootOnly ? _getCfg(dynamicHandler.cfg, identifier, true) : _getExtCfg(identifier, true);
             if (defaultValues) {
                 objForEachKey(defaultValues, function (field, defaultValue) {
                     if (isNullOrUndefined(newConfig[field])) {
@@ -3169,7 +3894,7 @@
         return context;
     }
     function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core.config);
+        var config = createDynamicConfig(core[_DYN_CONFIG$1 ]);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(unloadState) {
@@ -3189,7 +3914,7 @@
         return context;
     }
     function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core.config);
+        var config = createDynamicConfig(core[_DYN_CONFIG$1 ]);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(updateState) {
@@ -3213,7 +3938,7 @@
     function createTelemetryProxyChain(plugins, config, core, startAt) {
         var firstProxy = null;
         var add = startAt ? false : true;
-        if (isArray(plugins) && plugins[_DYN_LENGTH$2 ] > 0) {
+        if (isArray(plugins) && plugins[_DYN_LENGTH$1 ] > 0) {
             var lastProxy_1 = null;
             arrForEach(plugins, function (thePlugin) {
                 if (!add && startAt === thePlugin) {
@@ -3237,6 +3962,7 @@
         return firstProxy;
     }
     function createTelemetryPluginProxy(plugin, config, core) {
+        var _a;
         var nextProxy = null;
         var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
         var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
@@ -3247,21 +3973,22 @@
         else {
             chainId = "Unknown-0-" + _chainId++;
         }
-        var proxyChain = {
-            getPlugin: function () {
-                return plugin;
-            },
-            getNext: function () {
-                return nextProxy;
+        var proxyChain = (_a = {
+                getPlugin: function () {
+                    return plugin;
+                },
+                getNext: function () {
+                    return nextProxy;
+                }
             },
-            processTelemetry: _processTelemetry,
-            unload: _unloadPlugin,
-            update: _updatePlugin,
-            _id: chainId,
-            _setNext: function (nextPlugin) {
+            _a[STR_PROCESS_TELEMETRY ] = _processTelemetry,
+            _a.unload = _unloadPlugin,
+            _a.update = _updatePlugin,
+            _a._id = chainId,
+            _a._setNext = function (nextPlugin) {
                 nextProxy = nextPlugin;
-            }
-        };
+            },
+            _a);
         function _getTelCtx() {
             var itemCtx;
             if (plugin && isFunction(plugin[strGetTelCtx])) {
@@ -3340,7 +4067,7 @@
                 }
                 return hasRun;
             }
-            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState.isAsync)) {
+            if (!_processChain(unloadCtx, _callTeardown, "unload", _noopVoid, unloadState.isAsync)) {
                 unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
             }
         }
@@ -3358,13 +4085,14 @@
                 }
                 return hasRun;
             }
-            if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
+            if (!_processChain(updateCtx, _callUpdate, "update", _noopVoid, false)) {
                 updateCtx[_DYN_PROCESS_NEXT ](updateState);
             }
         }
         return objFreeze(proxyChain);
     }
 
+    /*#__NO_SIDE_EFFECTS__*/
     function createUnloadHandlerContainer() {
         var handlers = [];
         function _addHandler(handler) {
@@ -3559,19 +4287,24 @@
     var strDetachEvent = "detachEvent";
     var strRemoveEventListener = "removeEventListener";
     var strEvents = "events";
-    createUniqueNamespace("aiEvtPageHide");
-    createUniqueNamespace("aiEvtPageShow");
     var rRemoveEmptyNs = /\.[\.]+/g;
     var rRemoveTrailingEmptyNs = /[\.]+$/;
     var _guid = 1;
-    var elmNodeData = createElmNodeData("events");
+    var _elmNodeData;
+    /*#__NO_SIDE_EFFECTS__*/
+    function _getElmNodeData() {
+        !_elmNodeData && (_elmNodeData = createCachedValue(createElmNodeData("events")));
+        return _elmNodeData.v;
+    }
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
+    /*#__NO_SIDE_EFFECTS__*/
     function _normalizeNamespace(name) {
         if (name && name[_DYN_REPLACE ]) {
             return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
         }
         return name;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function _getEvtNamespace(eventName, evtNamespace) {
         if (evtNamespace) {
             var theNamespace_1 = STR_EMPTY;
@@ -3600,12 +4333,13 @@
         var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
         return {
             type: parsedEvent[1],
-            ns: ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join(".")
+            ns: ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY).split(".").sort())[_DYN_JOIN ](".")
         };
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function _getRegisteredEvents(target, evtName, addDefault) {
         if (addDefault === void 0) { addDefault = true; }
-        var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
+        var aiEvts = _getElmNodeData().get(target, strEvents, {}, addDefault);
         var registeredEvents = aiEvts[evtName];
         if (!registeredEvents) {
             registeredEvents = aiEvts[evtName] = [];
@@ -3637,7 +4371,7 @@
         return result;
     }
     function _doUnregister(target, events, evtName, unRegFn) {
-        var idx = events[_DYN_LENGTH$2 ];
+        var idx = events[_DYN_LENGTH$1 ];
         while (idx--) {
             var theEvent = events[idx];
             if (theEvent) {
@@ -3655,25 +4389,26 @@
             _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
         }
         else {
-            var eventCache = elmNodeData.get(target, strEvents, {});
+            var eventCache = _getElmNodeData().get(target, strEvents, {});
             objForEachKey(eventCache, function (evtType, events) {
                 _doUnregister(target, events, evtName, unRegFn);
             });
-            if (objKeys(eventCache)[_DYN_LENGTH$2 ] === 0) {
-                elmNodeData.kill(target, strEvents);
+            if (objKeys(eventCache)[_DYN_LENGTH$1 ] === 0) {
+                _getElmNodeData().kill(target, strEvents);
             }
         }
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function mergeEvtNamespace(theNamespace, namespaces) {
         var newNamespaces;
         if (namespaces) {
             if (isArray(namespaces)) {
-                newNamespaces = [theNamespace].concat(namespaces);
+                newNamespaces = [theNamespace][_DYN_CONCAT ](namespaces);
             }
             else {
                 newNamespaces = [theNamespace, namespaces];
             }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
         }
         else {
             newNamespaces = theNamespace;
@@ -3687,7 +4422,7 @@
             try {
                 var evtName = _getEvtNamespace(eventName, evtNamespace);
                 result = _doAttach(target, evtName, handlerRef, useCapture);
-                if (result && elmNodeData.accept(target)) {
+                if (result && _getElmNodeData().accept(target)) {
                     var registeredEvent = {
                         guid: _guid++,
                         evtName: evtName,
@@ -3730,7 +4465,7 @@
     ];
     function _arrLoop(arr, fn) {
         if (arr) {
-            for (var lp = 0; lp < arr[_DYN_LENGTH$2 ]; lp++) {
+            for (var lp = 0; lp < arr[_DYN_LENGTH$1 ]; lp++) {
                 if (fn(arr[lp], lp)) {
                     break;
                 }
@@ -3862,35 +4597,7 @@
         return null;
     }
 
-    var strNotSpecified = "not_specified";
-    var strIkey = "iKey";
-
-    var _DYN_SPLIT = "split";
-    var _DYN_LENGTH$1 = "length";
-    var _DYN_TO_LOWER_CASE = "toLowerCase";
-    var _DYN_TO_STRING$1 = "toString";
-    var _DYN_REMOVE_ITEM = "removeItem";
-    var _DYN_MESSAGE = "message";
-    var _DYN_COUNT = "count";
-    var _DYN_STRINGIFY = "stringify";
-    var _DYN_PATHNAME = "pathname";
-    var _DYN_MATCH = "match";
-    var _DYN_NAME = "name";
-    var _DYN_PROPERTIES$1 = "properties";
-    var _DYN_MEASUREMENTS = "measurements";
-    var _DYN_SIZE_IN_BYTES = "sizeInBytes";
-    var _DYN_TYPE_NAME = "typeName";
-    var _DYN_EXCEPTIONS = "exceptions";
-    var _DYN_SEVERITY_LEVEL = "severityLevel";
-    var _DYN_PROBLEM_GROUP = "problemGroup";
-    var _DYN_PARSED_STACK = "parsedStack";
-    var _DYN_HAS_FULL_STACK = "hasFullStack";
-    var _DYN_ASSEMBLY = "assembly";
-    var _DYN_FILE_NAME = "fileName";
-    var _DYN_LINE = "line";
-    var _DYN_AI_DATA_CONTRACT = "aiDataContract";
-    var _DYN_DURATION$1 = "duration";
-
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeKeyAndAddUniqueness(logger, key, map) {
         var origLength = key[_DYN_LENGTH$1 ];
         var field = dataSanitizeKey(logger, key);
@@ -3905,6 +4612,7 @@
         }
         return field;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeKey(logger, name) {
         var nameTrunc;
         if (name) {
@@ -3916,6 +4624,7 @@
         }
         return nameTrunc || name;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeString(logger, value, maxLength) {
         if (maxLength === void 0) { maxLength = 1024 ; }
         var valueTrunc;
@@ -3929,12 +4638,7 @@
         }
         return valueTrunc || value;
     }
-    function dataSanitizeUrl(logger, url, config) {
-        if (isString(url)) {
-            url = fieldRedaction(url, config);
-        }
-        return dataSanitizeInput(logger, url, 2048 , 66 );
-    }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeMessage(logger, message) {
         var messageTrunc;
         if (message) {
@@ -3945,6 +4649,7 @@
         }
         return messageTrunc || message;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeException(logger, exception) {
         var exceptionTrunc;
         if (exception) {
@@ -3956,6 +4661,7 @@
         }
         return exceptionTrunc || exception;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeProperties(logger, properties) {
         if (properties) {
             var tempProps_1 = {};
@@ -3976,6 +4682,7 @@
         }
         return properties;
     }
+    /*#__NO_SIDE_EFFECTS__*/
     function dataSanitizeMeasurements(logger, measurements) {
         if (measurements) {
             var tempMeasurements_1 = {};
@@ -3985,109 +4692,14 @@
             });
             measurements = tempMeasurements_1;
         }
-        return measurements;
-    }
-    function dataSanitizeId(logger, id) {
-        return id ? dataSanitizeInput(logger, id, 128 , 69 )[_DYN_TO_STRING$1 ]() : id;
-    }
-    function dataSanitizeInput(logger, input, maxLength, _msgId) {
-        var inputTrunc;
-        if (input) {
-            input = strTrim(asString(input));
-            if (input[_DYN_LENGTH$1 ] > maxLength) {
-                inputTrunc = strSubstring(input, 0, maxLength);
-                _throwInternal(logger, 2 , _msgId, "input is too long, it has been truncated to " + maxLength + " characters.", { data: input }, true);
-            }
-        }
-        return inputTrunc || input;
-    }
-    function dsPadNumber(num) {
-        var s = "00" + num;
-        return strSubstr(s, s[_DYN_LENGTH$1 ] - 3);
-    }
-
-    var _document = getDocument() || {};
-    var _htmlAnchorIdx = 0;
-    var _htmlAnchorElement = [null, null, null, null, null];
-    function urlParseUrl(url) {
-        var anchorIdx = _htmlAnchorIdx;
-        var anchorCache = _htmlAnchorElement;
-        var tempAnchor = anchorCache[anchorIdx];
-        if (!_document.createElement) {
-            tempAnchor = { host: urlParseHost(url, true) };
-        }
-        else if (!anchorCache[anchorIdx]) {
-            tempAnchor = anchorCache[anchorIdx] = _document.createElement("a");
-        }
-        tempAnchor.href = url;
-        anchorIdx++;
-        if (anchorIdx >= anchorCache[_DYN_LENGTH$1 ]) {
-            anchorIdx = 0;
-        }
-        _htmlAnchorIdx = anchorIdx;
-        return tempAnchor;
-    }
-    function urlParseHost(url, inclPort) {
-        var fullHost = urlParseFullHost(url, inclPort) || "";
-        if (fullHost) {
-            var match = fullHost[_DYN_MATCH ](/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
-            if (match != null && match[_DYN_LENGTH$1 ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
-                return match[2] + (match[3] || "");
-            }
-        }
-        return fullHost;
-    }
-    function urlParseFullHost(url, inclPort) {
-        var result = null;
-        if (url) {
-            var match = url[_DYN_MATCH ](/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
-            if (match != null && match[_DYN_LENGTH$1 ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
-                result = match[2] || "";
-                if (inclPort && match[_DYN_LENGTH$1 ] > 2) {
-                    var protocol = (match[1] || "")[_DYN_TO_LOWER_CASE ]();
-                    var port = match[3] || "";
-                    if (protocol === "http" && port === ":80") {
-                        port = "";
-                    }
-                    else if (protocol === "https" && port === ":443") {
-                        port = "";
-                    }
-                    result += port;
-                }
-            }
-        }
-        return result;
+        return measurements;
     }
-
-    function AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName) {
-        var target, name = commandName, data = commandName;
-        if (absoluteUrl && absoluteUrl[_DYN_LENGTH$1 ] > 0) {
-            var parsedUrl = urlParseUrl(absoluteUrl);
-            target = parsedUrl.host;
-            if (!name) {
-                if (parsedUrl[_DYN_PATHNAME ] != null) {
-                    var pathName = (parsedUrl.pathname[_DYN_LENGTH$1 ] === 0) ? "/" : parsedUrl[_DYN_PATHNAME ];
-                    if (pathName.charAt(0) !== "/") {
-                        pathName = "/" + pathName;
-                    }
-                    data = parsedUrl[_DYN_PATHNAME ];
-                    name = dataSanitizeString(logger, method ? method + " " + pathName : pathName);
-                }
-                else {
-                    name = dataSanitizeString(logger, absoluteUrl);
-                }
-            }
-        }
-        else {
-            target = commandName;
-            name = commandName;
-        }
-        return {
-            target: target,
-            name: name,
-            data: data
-        };
+    /*#__NO_SIDE_EFFECTS__*/
+    function dsPadNumber(num) {
+        var s = "00" + num;
+        return strSubstr(s, s[_DYN_LENGTH$1 ] - 3);
     }
+
     function dateTimeUtilsDuration(start, end) {
         var result = null;
         if (start !== 0 && end !== 0 && !isNullOrUndefined(start) && !isNullOrUndefined(end)) {
@@ -4095,43 +4707,6 @@
         }
         return result;
     }
-    function createDistributedTraceContextFromTrace(telemetryTrace, parentCtx) {
-        var trace = telemetryTrace || {};
-        return {
-            getName: function () {
-                return trace[_DYN_NAME ];
-            },
-            setName: function (newValue) {
-                parentCtx && parentCtx.setName(newValue);
-                trace[_DYN_NAME ] = newValue;
-            },
-            getTraceId: function () {
-                return trace.traceID;
-            },
-            setTraceId: function (newValue) {
-                parentCtx && parentCtx.setTraceId(newValue);
-                if (isValidTraceId(newValue)) {
-                    trace.traceID = newValue;
-                }
-            },
-            getSpanId: function () {
-                return trace.parentID;
-            },
-            setSpanId: function (newValue) {
-                parentCtx && parentCtx.setSpanId(newValue);
-                if (isValidSpanId(newValue)) {
-                    trace.parentID = newValue;
-                }
-            },
-            getTraceFlags: function () {
-                return trace.traceFlags;
-            },
-            setTraceFlags: function (newTraceFlags) {
-                parentCtx && parentCtx.setTraceFlags(newTraceFlags);
-                trace.traceFlags = newTraceFlags;
-            }
-        };
-    }
 
     var StorageType = ( /* @__PURE__ */createEnumStyle({
         LocalStorage: 0 ,
@@ -4140,7 +4715,7 @@
 
     var _canUseLocalStorage = undefined;
     var _canUseSessionStorage = undefined;
-    var _storagePrefix = "";
+    var _storagePrefix = STR_EMPTY;
     function _getVerifiedStorageObject(storageType) {
         try {
             if (isNullOrUndefined(getGlobal())) {
@@ -4171,7 +4746,7 @@
         _canUseSessionStorage = false;
     }
     function utlSetStoragePrefix(storagePrefix) {
-        _storagePrefix = storagePrefix || "";
+        _storagePrefix = storagePrefix || STR_EMPTY;
     }
     function utlEnableStorage() {
         _canUseLocalStorage = utlCanUseLocalStorage(true);
@@ -4231,24 +4806,24 @@
         return false;
     }
 
-    var Event$1 = /** @class */ (function () {
-        function Event(logger, name, properties, measurements) {
-            this.aiDataContract = {
-                ver: 1 ,
-                name: 1 ,
-                properties: 0 ,
-                measurements: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-        }
-        Event.envelopeType = "Microsoft.ApplicationInsights.{0}.Event";
-        Event.dataType = "EventData";
-        return Event;
-    }());
+    var EventDataType = "EventData";
+    var ExceptionDataType = "ExceptionData";
+    var MetricDataType = "MetricData";
+    var PageViewDataType = "PageviewData";
+    var PageViewPerformanceDataType = "PageviewPerformanceData";
+    var RemoteDependencyDataType = "RemoteDependencyData";
+    var TraceDataType = "MessageData";
+
+    /* #__NO_SIDE_EFFECTS__# */
+    function _AddPrefix(name) {
+        return "Microsoft.ApplicationInsights.{0}." + name;
+    }
+    var EventEnvelopeType = ( /*#__PURE__*/_AddPrefix("Event"));
+    var ExceptionEnvelopeType = ( /*#__PURE__*/_AddPrefix("Exception"));
+    var MetricEnvelopeType = ( /*#__PURE__*/_AddPrefix("Metric"));
+    var PageViewEnvelopeType = ( /*#__PURE__*/_AddPrefix("Pageview"));
+    var PageViewPerformanceEnvelopeType = ( /*#__PURE__*/_AddPrefix("PageviewPerformance"));
+    var TraceEnvelopeType = ( /*#__PURE__*/_AddPrefix("Message"));
 
     var STACKFRAME_BASE_SIZE = 58;
     var IS_FRAME = /^\s{0,50}(from\s|at\s|Line\s{1,5}\d{1,10}\s{1,5}of|\w{1,50}@\w{1,80}|[^\(\s\n]+:[0-9\?]+(?::[0-9\?]+)?)/;
@@ -4272,7 +4847,7 @@
         { re: EXTRACT_FILENAME, len: 2, fn: 1, hdl: _handleFilename }
     ];
     function _scrubAnonymous(frame) {
-        return frame.replace(/(\(anonymous\))/, "<anonymous>");
+        return frame[_DYN_REPLACE ](/(\(anonymous\))/, "<anonymous>");
     }
     function _ignoreNative(frame) {
         return strIndexOf(frame, "[native") < 0;
@@ -4363,7 +4938,7 @@
                 entry += "@" + lines[lp + 1];
                 lp++;
             }
-            stack.push(entry);
+            stack[_DYN_PUSH ](entry);
         }
         return {
             src: errorMessage,
@@ -4380,8 +4955,8 @@
                 else if (errorObj[strError] && errorObj[strError][strStack]) {
                     details = _convertStackObj(errorObj[strError][strStack]);
                 }
-                else if (errorObj["exception"] && errorObj.exception[strStack]) {
-                    details = _convertStackObj(errorObj.exception[strStack]);
+                else if (errorObj["exception"] && errorObj[_DYN_EXCEPTION ][strStack]) {
+                    details = _convertStackObj(errorObj[_DYN_EXCEPTION ][strStack]);
                 }
                 else if (_isStackDetails(errorObj)) {
                     details = errorObj;
@@ -4392,8 +4967,8 @@
                 else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
                     details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
                 }
-                else if (errorObj["reason"] && errorObj.reason[strStack]) {
-                    details = _convertStackObj(errorObj.reason[strStack]);
+                else if (errorObj["reason"] && errorObj[_DYN_REASON ][strStack]) {
+                    details = _convertStackObj(errorObj[_DYN_REASON ][strStack]);
                 }
                 else if (isString(errorObj)) {
                     details = _convertStackObj(errorObj);
@@ -4424,7 +4999,7 @@
         var stack = "";
         if (stackDetails) {
             if (stackDetails.obj) {
-                stack = stackDetails.obj.join("\n");
+                stack = stackDetails.obj[_DYN_JOIN ]("\n");
             }
             else {
                 stack = stackDetails.src || "";
@@ -4447,7 +5022,7 @@
                     var parsedFrame = _extractStackFrame(theFrame, level_1);
                     if (parsedFrame) {
                         totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
-                        parsedStack.push(parsedFrame);
+                        parsedStack[_DYN_PUSH ](parsedFrame);
                         level_1++;
                     }
                 }
@@ -4465,7 +5040,7 @@
                     size += lSize + rSize;
                     if (size > exceptionParsedStackThreshold) {
                         var howMany = acceptedRight - acceptedLeft + 1;
-                        parsedStack.splice(acceptedLeft, howMany);
+                        parsedStack[_DYN_SPLICE ](acceptedLeft, howMany);
                         break;
                     }
                     acceptedLeft = left;
@@ -4613,12 +5188,12 @@
                 ]
             };
         };
-        Exception.envelopeType = "Microsoft.ApplicationInsights.{0}.Exception";
-        Exception.dataType = "ExceptionData";
+        Exception.envelopeType = ExceptionEnvelopeType;
+        Exception.dataType = ExceptionDataType;
         Exception.formatError = _formatErrorCode;
         return Exception;
     }());
-    var exDetailsAiDataContract = objFreeze({
+    var exDetailsAiDataContract = ( /*#__PURE__*/objFreeze({
         id: 0 ,
         outerId: 0 ,
         typeName: 1 ,
@@ -4626,7 +5201,7 @@
         hasFullStack: 0 ,
         stack: 0 ,
         parsedStack: 2
-    });
+    }));
     function _toInterface() {
         var _self = this;
         var parsedStack = isArray(_self[_DYN_PARSED_STACK ])
@@ -4741,13 +5316,13 @@
         }
         return result;
     }
-    var stackFrameAiDataContract = objFreeze({
+    var stackFrameAiDataContract = ( /*#__PURE__*/objFreeze({
         level: 1 ,
         method: 1 ,
         assembly: 0 ,
         fileName: 0 ,
         line: 0
-    });
+    }));
     function _extractStackFrame(frame, level) {
         var _a;
         var theFrame;
@@ -4829,201 +5404,6 @@
         };
     }
 
-    var DataPoint = /** @class */ (function () {
-        function DataPoint() {
-            this.aiDataContract = {
-                name: 1 ,
-                kind: 0 ,
-                value: 1 ,
-                count: 0 ,
-                min: 0 ,
-                max: 0 ,
-                stdDev: 0
-            };
-            this.kind = 0 ;
-        }
-        return DataPoint;
-    }());
-
-    var Metric = /** @class */ (function () {
-        function Metric(logger, name, value, count, min, max, stdDev, properties, measurements) {
-            this.aiDataContract = {
-                ver: 1 ,
-                metrics: 1 ,
-                properties: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            var dataPoint = new DataPoint();
-            dataPoint[_DYN_COUNT ] = count > 0 ? count : undefined;
-            dataPoint.max = isNaN(max) || max === null ? undefined : max;
-            dataPoint.min = isNaN(min) || min === null ? undefined : min;
-            dataPoint[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            dataPoint.value = value;
-            dataPoint.stdDev = isNaN(stdDev) || stdDev === null ? undefined : stdDev;
-            _self.metrics = [dataPoint];
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-        }
-        Metric.envelopeType = "Microsoft.ApplicationInsights.{0}.Metric";
-        Metric.dataType = "MetricData";
-        return Metric;
-    }());
-
-    var strEmpty = "";
-    function msToTimeSpan(totalms) {
-        if (isNaN(totalms) || totalms < 0) {
-            totalms = 0;
-        }
-        totalms = mathRound(totalms);
-        var ms = strEmpty + totalms % 1000;
-        var sec = strEmpty + mathFloor(totalms / 1000) % 60;
-        var min = strEmpty + mathFloor(totalms / (1000 * 60)) % 60;
-        var hour = strEmpty + mathFloor(totalms / (1000 * 60 * 60)) % 24;
-        var days = mathFloor(totalms / (1000 * 60 * 60 * 24));
-        ms = ms[_DYN_LENGTH$1 ] === 1 ? "00" + ms : ms[_DYN_LENGTH$1 ] === 2 ? "0" + ms : ms;
-        sec = sec[_DYN_LENGTH$1 ] < 2 ? "0" + sec : sec;
-        min = min[_DYN_LENGTH$1 ] < 2 ? "0" + min : min;
-        hour = hour[_DYN_LENGTH$1 ] < 2 ? "0" + hour : hour;
-        return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
-    }
-    function isCrossOriginError(message, url, lineNumber, columnNumber, error) {
-        return !error && isString(message) && (message === "Script error." || message === "Script error");
-    }
-
-    var PageView = /** @class */ (function () {
-        function PageView(logger, name, url, durationMs, properties, measurements, id) {
-            this.aiDataContract = {
-                ver: 1 ,
-                name: 0 ,
-                url: 0 ,
-                duration: 0 ,
-                properties: 0 ,
-                measurements: 0 ,
-                id: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            _self.id = dataSanitizeId(logger, id);
-            _self.url = dataSanitizeUrl(logger, url);
-            _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            if (!isNaN(durationMs)) {
-                _self[_DYN_DURATION$1 ] = msToTimeSpan(durationMs);
-            }
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-        }
-        PageView.envelopeType = "Microsoft.ApplicationInsights.{0}.Pageview";
-        PageView.dataType = "PageviewData";
-        return PageView;
-    }());
-
-    var RemoteDependencyData = /** @class */ (function () {
-        function RemoteDependencyData(logger, id, absoluteUrl, commandName, value, success, resultCode, method, requestAPI, correlationContext, properties, measurements) {
-            if (requestAPI === void 0) { requestAPI = "Ajax"; }
-            this.aiDataContract = {
-                id: 1 ,
-                ver: 1 ,
-                name: 0 ,
-                resultCode: 0 ,
-                duration: 0 ,
-                success: 0 ,
-                data: 0 ,
-                target: 0 ,
-                type: 0 ,
-                properties: 0 ,
-                measurements: 0 ,
-                kind: 0 ,
-                value: 0 ,
-                count: 0 ,
-                min: 0 ,
-                max: 0 ,
-                stdDev: 0 ,
-                dependencyKind: 0 ,
-                dependencySource: 0 ,
-                commandName: 0 ,
-                dependencyTypeName: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            _self.id = id;
-            _self[_DYN_DURATION$1 ] = msToTimeSpan(value);
-            _self.success = success;
-            _self.resultCode = resultCode + "";
-            _self.type = dataSanitizeString(logger, requestAPI);
-            var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
-            _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
-            _self.target = dataSanitizeString(logger, dependencyFields.target);
-            if (correlationContext) {
-                _self.target = "".concat(_self.target, " | ").concat(correlationContext);
-            }
-            _self[_DYN_NAME ] = dataSanitizeString(logger, dependencyFields[_DYN_NAME ]);
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-        }
-        RemoteDependencyData.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
-        RemoteDependencyData.dataType = "RemoteDependencyData";
-        return RemoteDependencyData;
-    }());
-
-    var Trace = /** @class */ (function () {
-        function Trace(logger, message, severityLevel, properties, measurements) {
-            this.aiDataContract = {
-                ver: 1 ,
-                message: 1 ,
-                severityLevel: 0 ,
-                properties: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            message = message || strNotSpecified;
-            _self[_DYN_MESSAGE ] = dataSanitizeMessage(logger, message);
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-            if (severityLevel) {
-                _self[_DYN_SEVERITY_LEVEL ] = severityLevel;
-            }
-        }
-        Trace.envelopeType = "Microsoft.ApplicationInsights.{0}.Message";
-        Trace.dataType = "MessageData";
-        return Trace;
-    }());
-
-    var PageViewPerformance = /** @class */ (function () {
-        function PageViewPerformance(logger, name, url, unused, properties, measurements, cs4BaseData) {
-            this.aiDataContract = {
-                ver: 1 ,
-                name: 0 ,
-                url: 0 ,
-                duration: 0 ,
-                perfTotal: 0 ,
-                networkConnect: 0 ,
-                sentRequest: 0 ,
-                receivedResponse: 0 ,
-                domProcessing: 0 ,
-                properties: 0 ,
-                measurements: 0
-            };
-            var _self = this;
-            _self.ver = 2;
-            _self.url = dataSanitizeUrl(logger, url);
-            _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
-            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
-            if (cs4BaseData) {
-                _self.domProcessing = cs4BaseData.domProcessing;
-                _self[_DYN_DURATION$1 ] = cs4BaseData[_DYN_DURATION$1 ];
-                _self.networkConnect = cs4BaseData.networkConnect;
-                _self.perfTotal = cs4BaseData.perfTotal;
-                _self.receivedResponse = cs4BaseData.receivedResponse;
-                _self.sentRequest = cs4BaseData.sentRequest;
-            }
-        }
-        PageViewPerformance.envelopeType = "Microsoft.ApplicationInsights.{0}.PageviewPerformance";
-        PageViewPerformance.dataType = "PageviewPerformanceData";
-        return PageViewPerformance;
-    }());
-
     function createTelemetryItem(item, baseType, envelopeName, logger, customProperties, systemProperties) {
         envelopeName = dataSanitizeString(logger, envelopeName) || strNotSpecified;
         if (isNullOrUndefined(item) ||
@@ -5048,7 +5428,7 @@
         };
         if (!isNullOrUndefined(customProperties)) {
             objForEachKey(customProperties, function (prop, value) {
-                telemetryItem.data[prop] = value;
+                telemetryItem[_DYN_DATA ][prop] = value;
             });
         }
         return telemetryItem;
@@ -5061,23 +5441,20 @@
         }
         else {
             var doc = getDocument();
-            if (doc && doc.createEvent) {
-                event = doc.createEvent("Event");
+            if (doc && doc[_DYN_CREATE_EVENT ]) {
+                event = doc[_DYN_CREATE_EVENT ]("Event");
                 event.initEvent(eventName, true, true);
             }
         }
         return event;
     }
 
-    var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
     var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
 
     var _DYN_TO_STRING = "toString";
     var _DYN_IS_STORAGE_USE_DISAB0 = "isStorageUseDisabled";
     var _DYN__ADD_HOOK = "_addHook";
     var _DYN_CORE = "core";
-    var _DYN_DATA_TYPE = "dataType";
-    var _DYN_ENVELOPE_TYPE = "envelopeType";
     var _DYN_DIAG_LOG = "diagLog";
     var _DYN_TRACK = "track";
     var _DYN_TRACK_PAGE_VIEW = "trackPageView";
@@ -5103,6 +5480,7 @@
     var _DYN_IS_BROWSER_LINK_TRAC11 = "isBrowserLinkTrackingEnabled";
     var _DYN_LENGTH = "length";
     var _DYN_ENABLE_AUTO_ROUTE_TR12 = "enableAutoRouteTracking";
+    var _DYN_GET_TRACE_CTX = "getTraceCtx";
     var _DYN_ENABLE_UNHANDLED_PRO13 = "enableUnhandledPromiseRejectionTracking";
     var _DYN_AUTO_UNHANDLED_PROMI14 = "autoUnhandledPromiseInstrumented";
     var _DYN_GET_ENTRIES_BY_TYPE = "getEntriesByType";
@@ -5116,171 +5494,169 @@
     var _DYN_LOAD_EVENT_END = "loadEventEnd";
     var _DYN_RESPONSE_END = "responseEnd";
     var _DYN_CONNECT_END = "connectEnd";
+    var _DYN_PAGE_VISIT_TIME = "pageVisitTime";
 
-    var PageViewManager = /** @class */ (function () {
-        function PageViewManager(appInsights, overridePageViewDuration, core, pageViewPerformanceManager) {
-            dynamicProto(PageViewManager, this, function (_self) {
-                var queueTimer = null;
-                var itemQueue = [];
-                var pageViewPerformanceSent = false;
-                var firstPageViewSent = false;
-                var _logger;
-                if (core) {
-                    _logger = core.logger;
-                }
-                function _flushChannels(isAsync) {
-                    if (core) {
-                        core.flush(isAsync, function () {
-                        });
-                    }
-                }
-                function _startTimer() {
-                    if (!queueTimer) {
-                        queueTimer = scheduleTimeout((function () {
-                            queueTimer = null;
-                            var allItems = itemQueue.slice(0);
-                            var doFlush = false;
-                            itemQueue = [];
-                            arrForEach(allItems, function (item) {
-                                if (!item()) {
-                                    itemQueue.push(item);
-                                }
-                                else {
-                                    doFlush = true;
-                                }
-                            });
-                            if (itemQueue[_DYN_LENGTH ] > 0) {
-                                _startTimer();
-                            }
-                            if (doFlush) {
-                                _flushChannels(true);
-                            }
-                        }), 100);
-                    }
-                }
-                function _addQueue(cb) {
-                    itemQueue.push(cb);
-                    _startTimer();
-                }
-                _self[_DYN_TRACK_PAGE_VIEW ] = function (pageView, customProperties) {
-                    var name = pageView.name;
-                    if (isNullOrUndefined(name) || typeof name !== "string") {
-                        var doc = getDocument();
-                        name = pageView.name = doc && doc.title || "";
-                    }
-                    var uri = pageView.uri;
-                    if (isNullOrUndefined(uri) || typeof uri !== "string") {
-                        var location_1 = getLocation();
-                        uri = pageView.uri = location_1 && location_1[_DYN_HREF ] || "";
-                    }
-                    if (core && core[_DYN_CONFIG ]) {
-                        uri = pageView.uri = fieldRedaction(pageView.uri, core[_DYN_CONFIG ]);
-                    }
-                    if (!firstPageViewSent) {
-                        var perf = getPerformance();
-                        var navigationEntries = (perf && perf[_DYN_GET_ENTRIES_BY_TYPE ] && perf[_DYN_GET_ENTRIES_BY_TYPE ]("navigation"));
-                        if (navigationEntries && navigationEntries[0] && !isUndefined(perf.timeOrigin)) {
-                            var loadEventStart = navigationEntries[0].loadEventStart;
-                            pageView[_DYN_START_TIME ] = new Date(perf.timeOrigin + loadEventStart);
+    function createPageViewManager(appInsights, overridePageViewDuration, core, pageViewPerformanceManager) {
+        var _a;
+        var queueTimer = null;
+        var itemQueue = [];
+        var pageViewPerformanceSent = false;
+        var firstPageViewSent = false;
+        var _logger;
+        if (core) {
+            _logger = core.logger;
+        }
+        function _flushChannels(isAsync) {
+            if (core) {
+                core.flush(isAsync, function () {
+                });
+            }
+        }
+        function _startTimer() {
+            if (!queueTimer) {
+                queueTimer = scheduleTimeout((function () {
+                    queueTimer = null;
+                    var allItems = itemQueue.slice(0);
+                    var doFlush = false;
+                    itemQueue = [];
+                    arrForEach(allItems, function (item) {
+                        if (!item()) {
+                            itemQueue.push(item);
                         }
                         else {
-                            var duration_1 = ((customProperties || pageView[_DYN_PROPERTIES ] || {})[_DYN_DURATION ] || 0);
-                            pageView[_DYN_START_TIME ] = new Date(new Date().getTime() - duration_1);
+                            doFlush = true;
                         }
-                        firstPageViewSent = true;
+                    });
+                    if (itemQueue[_DYN_LENGTH ] > 0) {
+                        _startTimer();
                     }
-                    if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN15 ]()) {
-                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
+                    if (doFlush) {
                         _flushChannels(true);
-                        if (!isWebWorker()) {
-                            _throwInternal(_logger, 2 , 25 , "trackPageView: navigation timing API used for calculation of page duration is not supported in this browser. This page view will be collected without duration and timing info.");
-                        }
-                        return;
                     }
-                    var pageViewSent = false;
-                    var customDuration;
-                    var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI16 ]()[_DYN_NAVIGATION_START ];
-                    if (start > 0) {
-                        customDuration = dateTimeUtilsDuration(start, +new Date);
-                        if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT17 ](customDuration)) {
-                            customDuration = undefined;
-                        }
+                }), 100);
+            }
+        }
+        function _addQueue(cb) {
+            itemQueue.push(cb);
+            _startTimer();
+        }
+        return _a = {},
+            _a[_DYN_TRACK_PAGE_VIEW ] = function (pageView, customProperties) {
+                var name = pageView.name;
+                if (isNullOrUndefined(name) || typeof name !== "string") {
+                    var doc = getDocument();
+                    name = pageView.name = doc && doc.title || "";
+                }
+                var uri = pageView.uri;
+                if (isNullOrUndefined(uri) || typeof uri !== "string") {
+                    var location_1 = getLocation();
+                    uri = pageView.uri = location_1 && location_1[_DYN_HREF ] || "";
+                }
+                if (core && core[_DYN_CONFIG ]) {
+                    uri = pageView.uri = fieldRedaction(pageView.uri, core[_DYN_CONFIG ]);
+                }
+                if (!firstPageViewSent) {
+                    var perf = getPerformance();
+                    var navigationEntries = (perf && perf[_DYN_GET_ENTRIES_BY_TYPE ] && perf[_DYN_GET_ENTRIES_BY_TYPE ]("navigation"));
+                    if (navigationEntries && navigationEntries[0] && !isUndefined(perf.timeOrigin)) {
+                        var loadEventStart = navigationEntries[0].loadEventStart;
+                        pageView[_DYN_START_TIME ] = new Date(perf.timeOrigin + loadEventStart);
                     }
-                    var duration;
-                    if (!isNullOrUndefined(customProperties) &&
-                        !isNullOrUndefined(customProperties[_DYN_DURATION ])) {
-                        duration = customProperties[_DYN_DURATION ];
+                    else {
+                        var duration_1 = ((customProperties || pageView[_DYN_PROPERTIES ] || {})[_DYN_DURATION ] || 0);
+                        pageView[_DYN_START_TIME ] = new Date(new Date().getTime() - duration_1);
                     }
-                    if (overridePageViewDuration || !isNaN(duration)) {
-                        if (isNaN(duration)) {
-                            if (!customProperties) {
-                                customProperties = {};
-                            }
-                            customProperties[_DYN_DURATION ] = customDuration;
-                        }
-                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
-                        _flushChannels(true);
-                        pageViewSent = true;
+                    firstPageViewSent = true;
+                }
+                if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN15 ]()) {
+                    appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
+                    _flushChannels(true);
+                    if (!isWebWorker()) {
+                        _throwInternal(_logger, 2 , 25 , "trackPageView: navigation timing API used for calculation of page duration is not supported in this browser. This page view will be collected without duration and timing info.");
                     }
-                    var maxDurationLimit = 60000;
-                    if (!customProperties) {
-                        customProperties = {};
+                    return;
+                }
+                var pageViewSent = false;
+                var customDuration;
+                var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI16 ]()[_DYN_NAVIGATION_START ];
+                if (start > 0) {
+                    customDuration = dateTimeUtilsDuration(start, +new Date);
+                    if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT17 ](customDuration)) {
+                        customDuration = undefined;
                     }
-                    _addQueue(function () {
-                        var processed = false;
-                        try {
-                            if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN18 ]()) {
-                                processed = true;
-                                var pageViewPerformance = {
-                                    name: name,
-                                    uri: uri
-                                };
-                                pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P4 ](pageViewPerformance);
-                                if (!pageViewPerformance.isValid && !pageViewSent) {
-                                    customProperties[_DYN_DURATION ] = customDuration;
-                                    appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
-                                }
-                                else {
-                                    if (!pageViewSent) {
-                                        customProperties[_DYN_DURATION ] = pageViewPerformance.durationMs;
-                                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
-                                    }
-                                    if (!pageViewPerformanceSent) {
-                                        appInsights[_DYN_SEND_PAGE_VIEW_PERFO3 ](pageViewPerformance, customProperties);
-                                        pageViewPerformanceSent = true;
-                                    }
-                                }
+                }
+                var duration;
+                if (!isNullOrUndefined(customProperties) &&
+                    !isNullOrUndefined(customProperties[_DYN_DURATION ])) {
+                    duration = customProperties[_DYN_DURATION ];
+                }
+                if (overridePageViewDuration || !isNaN(duration)) {
+                    if (isNaN(duration)) {
+                        if (!customProperties) {
+                            customProperties = {};
+                        }
+                        customProperties[_DYN_DURATION ] = customDuration;
+                    }
+                    appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
+                    _flushChannels(true);
+                    pageViewSent = true;
+                }
+                var maxDurationLimit = 60000;
+                if (!customProperties) {
+                    customProperties = {};
+                }
+                _addQueue(function () {
+                    var processed = false;
+                    try {
+                        if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN18 ]()) {
+                            processed = true;
+                            var pageViewPerformance = {
+                                name: name,
+                                uri: uri
+                            };
+                            pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P4 ](pageViewPerformance);
+                            if (!pageViewPerformance.isValid && !pageViewSent) {
+                                customProperties[_DYN_DURATION ] = customDuration;
+                                appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                             }
-                            else if (start > 0 && dateTimeUtilsDuration(start, +new Date) > maxDurationLimit) {
-                                processed = true;
+                            else {
                                 if (!pageViewSent) {
-                                    customProperties[_DYN_DURATION ] = maxDurationLimit;
+                                    customProperties[_DYN_DURATION ] = pageViewPerformance.durationMs;
                                     appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                                 }
+                                if (!pageViewPerformanceSent) {
+                                    appInsights[_DYN_SEND_PAGE_VIEW_PERFO3 ](pageViewPerformance, customProperties);
+                                    pageViewPerformanceSent = true;
+                                }
                             }
                         }
-                        catch (e) {
-                            _throwInternal(_logger, 1 , 38 , "trackPageView failed on page load calculation: " + getExceptionName(e), { exception: dumpObj(e) });
+                        else if (start > 0 && dateTimeUtilsDuration(start, +new Date) > maxDurationLimit) {
+                            processed = true;
+                            if (!pageViewSent) {
+                                customProperties[_DYN_DURATION ] = maxDurationLimit;
+                                appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
+                            }
                         }
-                        return processed;
-                    });
-                };
-                _self.teardown = function (unloadCtx, unloadState) {
-                    if (queueTimer) {
-                        queueTimer.cancel();
-                        queueTimer = null;
-                        var allItems = itemQueue.slice(0);
-                        itemQueue = [];
-                        arrForEach(allItems, function (item) {
-                            if (item()) ;
-                        });
                     }
-                };
-            });
-        }
-        PageViewManager.__ieDyn=1;
-        return PageViewManager;
-    }());
+                    catch (e) {
+                        _throwInternal(_logger, 1 , 38 , "trackPageView failed on page load calculation: " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                    return processed;
+                });
+            },
+            _a.teardown = function (unloadCtx, unloadState) {
+                if (queueTimer) {
+                    queueTimer.cancel();
+                    queueTimer = null;
+                    var allItems = itemQueue.slice(0);
+                    itemQueue = [];
+                    arrForEach(allItems, function (item) {
+                        if (item()) ;
+                    });
+                }
+            },
+            _a;
+    }
 
     var MAX_DURATION_ALLOWED = 3600000;
     var botAgentNames = ["googlebot", "adsbot-google", "apis-google", "mediapartners-google"];
@@ -5342,143 +5718,136 @@
         }
         return true;
     }
-    var PageViewPerformanceManager = /** @class */ (function () {
-        function PageViewPerformanceManager(core) {
-            var _logger = safeGetLogger(core);
-            dynamicProto(PageViewPerformanceManager, this, function (_self) {
-                _self[_DYN_POPULATE_PAGE_VIEW_P4 ] = function (pageViewPerformance) {
-                    pageViewPerformance.isValid = false;
-                    var navigationTiming = _getPerformanceNavigationTiming();
-                    var timing = _getPerformanceTiming();
-                    var total = 0;
-                    var network = 0;
-                    var request = 0;
-                    var response = 0;
-                    var dom = 0;
-                    if (navigationTiming || timing) {
-                        if (navigationTiming) {
-                            total = navigationTiming[_DYN_DURATION ];
-                            network = navigationTiming[_DYN_START_TIME ] === 0 ? navigationTiming[_DYN_CONNECT_END ] : dateTimeUtilsDuration(navigationTiming[_DYN_START_TIME ], navigationTiming[_DYN_CONNECT_END ]);
-                            request = dateTimeUtilsDuration(navigationTiming.requestStart, navigationTiming[_DYN_RESPONSE_START ]);
-                            response = dateTimeUtilsDuration(navigationTiming[_DYN_RESPONSE_START ], navigationTiming[_DYN_RESPONSE_END ]);
-                            dom = dateTimeUtilsDuration(navigationTiming.responseEnd, navigationTiming[_DYN_LOAD_EVENT_END ]);
-                        }
-                        else {
-                            total = dateTimeUtilsDuration(timing[_DYN_NAVIGATION_START ], timing[_DYN_LOAD_EVENT_END ]);
-                            network = dateTimeUtilsDuration(timing[_DYN_NAVIGATION_START ], timing[_DYN_CONNECT_END ]);
-                            request = dateTimeUtilsDuration(timing.requestStart, timing[_DYN_RESPONSE_START ]);
-                            response = dateTimeUtilsDuration(timing[_DYN_RESPONSE_START ], timing[_DYN_RESPONSE_END ]);
-                            dom = dateTimeUtilsDuration(timing.responseEnd, timing[_DYN_LOAD_EVENT_END ]);
-                        }
-                        if (total === 0) {
-                            _throwInternal(_logger, 2 , 10 , "error calculating page view performance.", { total: total, network: network, request: request, response: response, dom: dom });
-                        }
-                        else if (!_self[_DYN_SHOULD_COLLECT_DURAT17 ](total, network, request, response, dom)) {
-                            _throwInternal(_logger, 2 , 45 , "Invalid page load duration value. Browser perf data won't be sent.", { total: total, network: network, request: request, response: response, dom: dom });
-                        }
-                        else if (total < mathFloor(network) + mathFloor(request) + mathFloor(response) + mathFloor(dom)) {
-                            _throwInternal(_logger, 2 , 8 , "client performance math error.", { total: total, network: network, request: request, response: response, dom: dom });
-                        }
-                        else {
-                            pageViewPerformance.durationMs = total;
-                            pageViewPerformance.perfTotal = pageViewPerformance[_DYN_DURATION ] = msToTimeSpan(total);
-                            pageViewPerformance.networkConnect = msToTimeSpan(network);
-                            pageViewPerformance.sentRequest = msToTimeSpan(request);
-                            pageViewPerformance.receivedResponse = msToTimeSpan(response);
-                            pageViewPerformance.domProcessing = msToTimeSpan(dom);
-                            pageViewPerformance.isValid = true;
-                        }
+    function createPageViewPerformanceManager(core) {
+        var _a;
+        var _logger = safeGetLogger(core);
+        return _a = {},
+            _a[_DYN_POPULATE_PAGE_VIEW_P4 ] = function (pageViewPerformance) {
+                pageViewPerformance.isValid = false;
+                var navigationTiming = _getPerformanceNavigationTiming();
+                var timing = _getPerformanceTiming();
+                var total = 0;
+                var network = 0;
+                var request = 0;
+                var response = 0;
+                var dom = 0;
+                if (navigationTiming || timing) {
+                    if (navigationTiming) {
+                        total = navigationTiming[_DYN_DURATION ];
+                        network = navigationTiming[_DYN_START_TIME ] === 0 ? navigationTiming[_DYN_CONNECT_END ] : dateTimeUtilsDuration(navigationTiming[_DYN_START_TIME ], navigationTiming[_DYN_CONNECT_END ]);
+                        request = dateTimeUtilsDuration(navigationTiming.requestStart, navigationTiming[_DYN_RESPONSE_START ]);
+                        response = dateTimeUtilsDuration(navigationTiming[_DYN_RESPONSE_START ], navigationTiming[_DYN_RESPONSE_END ]);
+                        dom = dateTimeUtilsDuration(navigationTiming.responseEnd, navigationTiming[_DYN_LOAD_EVENT_END ]);
                     }
-                };
-                _self[_DYN_GET_PERFORMANCE_TIMI16 ] = _getPerformanceTiming;
-                _self[_DYN_IS_PERFORMANCE_TIMIN15 ] = _isPerformanceTimingSupported;
-                _self[_DYN_IS_PERFORMANCE_TIMIN18 ] = _isPerformanceTimingDataReady;
-                _self[_DYN_SHOULD_COLLECT_DURAT17 ] = _shouldCollectDuration;
-            });
-        }
-        PageViewPerformanceManager.__ieDyn=1;
-        return PageViewPerformanceManager;
-    }());
-
-    var PageVisitTimeManager = /** @class */ (function () {
-        function PageVisitTimeManager(logger, pageVisitTimeTrackingHandler) {
-            var prevPageVisitDataKeyName = "prevPageVisitData";
-            dynamicProto(PageVisitTimeManager, this, function (_self) {
-                _self[_DYN_TRACK_PREVIOUS_PAGE_1 ] = function (currentPageName, currentPageUrl) {
-                    try {
-                        var prevPageVisitTimeData = restartPageVisitTimer(currentPageName, currentPageUrl);
-                        if (prevPageVisitTimeData) {
-                            pageVisitTimeTrackingHandler(prevPageVisitTimeData.pageName, prevPageVisitTimeData.pageUrl, prevPageVisitTimeData.pageVisitTime);
-                        }
+                    else {
+                        total = dateTimeUtilsDuration(timing[_DYN_NAVIGATION_START ], timing[_DYN_LOAD_EVENT_END ]);
+                        network = dateTimeUtilsDuration(timing[_DYN_NAVIGATION_START ], timing[_DYN_CONNECT_END ]);
+                        request = dateTimeUtilsDuration(timing.requestStart, timing[_DYN_RESPONSE_START ]);
+                        response = dateTimeUtilsDuration(timing[_DYN_RESPONSE_START ], timing[_DYN_RESPONSE_END ]);
+                        dom = dateTimeUtilsDuration(timing.responseEnd, timing[_DYN_LOAD_EVENT_END ]);
                     }
-                    catch (e) {
-                        _warnToConsole(logger, "Auto track page visit time failed, metric will not be collected: " + dumpObj(e));
+                    if (total === 0) {
+                        _throwInternal(_logger, 2 , 10 , "error calculating page view performance.", { total: total, network: network, request: request, response: response, dom: dom });
                     }
-                };
-                function restartPageVisitTimer(pageName, pageUrl) {
-                    var prevPageVisitData = null;
-                    try {
-                        prevPageVisitData = stopPageVisitTimer();
-                        if (utlCanUseSessionStorage()) {
-                            if (utlGetSessionStorage(logger, prevPageVisitDataKeyName) != null) {
-                                throwError("Cannot call startPageVisit consecutively without first calling stopPageVisit");
-                            }
-                            var currPageVisitDataStr = getJSON().stringify(new PageVisitData(pageName, pageUrl));
-                            utlSetSessionStorage(logger, prevPageVisitDataKeyName, currPageVisitDataStr);
-                        }
+                    else if (!_shouldCollectDuration(total, network, request, response, dom)) {
+                        _throwInternal(_logger, 2 , 45 , "Invalid page load duration value. Browser perf data won't be sent.", { total: total, network: network, request: request, response: response, dom: dom });
                     }
-                    catch (e) {
-                        _warnToConsole(logger, "Call to restart failed: " + dumpObj(e));
-                        prevPageVisitData = null;
+                    else if (total < mathFloor(network) + mathFloor(request) + mathFloor(response) + mathFloor(dom)) {
+                        _throwInternal(_logger, 2 , 8 , "client performance math error.", { total: total, network: network, request: request, response: response, dom: dom });
                     }
-                    return prevPageVisitData;
-                }
-                function stopPageVisitTimer() {
-                    var prevPageVisitData = null;
-                    try {
-                        if (utlCanUseSessionStorage()) {
-                            var pageVisitEndTime = utcNow();
-                            var pageVisitDataJsonStr = utlGetSessionStorage(logger, prevPageVisitDataKeyName);
-                            if (pageVisitDataJsonStr && hasJSON()) {
-                                prevPageVisitData = getJSON().parse(pageVisitDataJsonStr);
-                                prevPageVisitData.pageVisitTime = pageVisitEndTime - prevPageVisitData.pageVisitStartTime;
-                                utlRemoveSessionStorage(logger, prevPageVisitDataKeyName);
-                            }
-                        }
+                    else {
+                        pageViewPerformance.durationMs = total;
+                        pageViewPerformance.perfTotal = pageViewPerformance[_DYN_DURATION ] = msToTimeSpan(total);
+                        pageViewPerformance.networkConnect = msToTimeSpan(network);
+                        pageViewPerformance.sentRequest = msToTimeSpan(request);
+                        pageViewPerformance.receivedResponse = msToTimeSpan(response);
+                        pageViewPerformance.domProcessing = msToTimeSpan(dom);
+                        pageViewPerformance.isValid = true;
                     }
-                    catch (e) {
-                        _warnToConsole(logger, "Stop page visit timer failed: " + dumpObj(e));
-                        prevPageVisitData = null;
+                }
+            },
+            _a[_DYN_GET_PERFORMANCE_TIMI16 ] = _getPerformanceTiming,
+            _a[_DYN_IS_PERFORMANCE_TIMIN15 ] = _isPerformanceTimingSupported,
+            _a[_DYN_IS_PERFORMANCE_TIMIN18 ] = _isPerformanceTimingDataReady,
+            _a[_DYN_SHOULD_COLLECT_DURAT17 ] = _shouldCollectDuration,
+            _a;
+    }
+
+    function createPageVisitData(pageName, pageUrl) {
+        return {
+            pageVisitStartTime: utcNow(),
+            pageName: pageName,
+            pageUrl: pageUrl,
+            pageVisitTime: 0
+        };
+    }
+    function createPageVisitTimeManager(logger, pageVisitTimeTrackingHandler) {
+        var prevPageVisitDataKeyName = "prevPageVisitData";
+        function restartPageVisitTimer(pageName, pageUrl) {
+            var prevPageVisitData = null;
+            try {
+                prevPageVisitData = stopPageVisitTimer();
+                if (utlCanUseSessionStorage()) {
+                    if (utlGetSessionStorage(logger, prevPageVisitDataKeyName) != null) {
+                        throwError("Cannot call startPageVisit consecutively without first calling stopPageVisit");
                     }
-                    return prevPageVisitData;
+                    var currPageVisitDataStr = getJSON().stringify(createPageVisitData(pageName, pageUrl));
+                    utlSetSessionStorage(logger, prevPageVisitDataKeyName, currPageVisitDataStr);
                 }
-                objDefine(_self, "_logger", { g: function () { return logger; } });
-                objDefine(_self, "pageVisitTimeTrackingHandler", { g: function () { return pageVisitTimeTrackingHandler; } });
-            });
+            }
+            catch (e) {
+                _warnToConsole(logger, "Call to restart failed: " + dumpObj(e));
+                prevPageVisitData = null;
+            }
+            return prevPageVisitData;
         }
-        PageVisitTimeManager.__ieDyn=1;
-        return PageVisitTimeManager;
-    }());
-    var PageVisitData = /** @class */ (function () {
-        function PageVisitData(pageName, pageUrl) {
-            this.pageVisitStartTime = utcNow();
-            this.pageName = pageName;
-            this.pageUrl = pageUrl;
+        function stopPageVisitTimer() {
+            var prevPageVisitData = null;
+            try {
+                if (utlCanUseSessionStorage()) {
+                    var pageVisitEndTime = utcNow();
+                    var pageVisitDataJsonStr = utlGetSessionStorage(logger, prevPageVisitDataKeyName);
+                    if (pageVisitDataJsonStr && hasJSON()) {
+                        prevPageVisitData = getJSON().parse(pageVisitDataJsonStr);
+                        prevPageVisitData[_DYN_PAGE_VISIT_TIME ] = pageVisitEndTime - prevPageVisitData.pageVisitStartTime;
+                        utlRemoveSessionStorage(logger, prevPageVisitDataKeyName);
+                    }
+                }
+            }
+            catch (e) {
+                _warnToConsole(logger, "Stop page visit timer failed: " + dumpObj(e));
+                prevPageVisitData = null;
+            }
+            return prevPageVisitData;
         }
-        return PageVisitData;
-    }());
+        return {
+            trackPreviousPageVisit: function (currentPageName, currentPageUrl) {
+                try {
+                    var prevPageVisitTimeData = restartPageVisitTimer(currentPageName, currentPageUrl);
+                    if (prevPageVisitTimeData) {
+                        pageVisitTimeTrackingHandler(prevPageVisitTimeData.pageName, prevPageVisitTimeData.pageUrl, prevPageVisitTimeData[_DYN_PAGE_VISIT_TIME ]);
+                    }
+                }
+                catch (e) {
+                    _warnToConsole(logger, "Auto track page visit time failed, metric will not be collected: " + dumpObj(e));
+                }
+            },
+            _logger: logger,
+            pageVisitTimeTrackingHandler: pageVisitTimeTrackingHandler
+        };
+    }
 
-    var Timing = /** @class */ (function () {
-        function Timing(logger, name) {
-            var _self = this;
-            var _events = {};
-            _self.start = function (name) {
+    function createTiming(logger, name) {
+        var _events = {};
+        var timing = {
+            action: null,
+            start: function (name) {
                 if (typeof _events[name] !== "undefined") {
                     _throwInternal(logger, 2 , 62 , "start was called more than once for this event without calling stop.", { name: name, key: name }, true);
                 }
                 _events[name] = +new Date;
-            };
-            _self.stop = function (name, url, properties, measurements) {
+            },
+            stop: function (name, url, properties, measurements) {
                 var start = _events[name];
                 if (isNaN(start)) {
                     _throwInternal(logger, 2 , 63 , "stop was called without a corresponding start.", { name: name, key: name }, true);
@@ -5486,14 +5855,14 @@
                 else {
                     var end = +new Date;
                     var duration = dateTimeUtilsDuration(start, end);
-                    _self.action(name, url, duration, properties, measurements);
+                    timing.action(name, url, duration, properties, measurements);
                 }
                 delete _events[name];
                 _events[name] = undefined;
-            };
-        }
-        return Timing;
-    }());
+            }
+        };
+        return timing;
+    }
 
     var _a;
     var strEvent = "event";
@@ -5531,6 +5900,7 @@
         _a.disableFlushOnBeforeUnload = cfgDfBoolean(),
         _a.disableFlushOnUnload = cfgDfBoolean(false, "disableFlushOnBeforeUnload"),
         _a.expCfg = cfgDfMerge({ inclScripts: false, expLog: undefined, maxLogs: 50 }),
+        _a.routeTraceStrategy = 0 ,
         _a));
     function _chkConfigMilliseconds(value, defValue) {
         value = value || defValue;
@@ -5576,6 +5946,7 @@
             var _extConfig;
             var _autoTrackPageVisitTime;
             var _expCfg;
+            var _routeTraceStrategy;
             var _prevUri;
             var _currUri;
             var _evtNamespace;
@@ -5591,7 +5962,7 @@
                 };
                 _self.trackEvent = function (event, customProperties) {
                     try {
-                        var telemetryItem = createTelemetryItem(event, Event$1[_DYN_DATA_TYPE ], Event$1[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), customProperties);
+                        var telemetryItem = createTelemetryItem(event, EventDataType, EventEnvelopeType, _self[_DYN_DIAG_LOG ](), customProperties);
                         _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                     }
                     catch (e) {
@@ -5616,7 +5987,7 @@
                 };
                 _self.trackTrace = function (trace, customProperties) {
                     try {
-                        var telemetryItem = createTelemetryItem(trace, Trace[_DYN_DATA_TYPE ], Trace[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), customProperties);
+                        var telemetryItem = createTelemetryItem(trace, TraceDataType, TraceEnvelopeType, _self[_DYN_DIAG_LOG ](), customProperties);
                         _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                     }
                     catch (e) {
@@ -5625,7 +5996,7 @@
                 };
                 _self.trackMetric = function (metric, customProperties) {
                     try {
-                        var telemetryItem = createTelemetryItem(metric, Metric[_DYN_DATA_TYPE ], Metric[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), customProperties);
+                        var telemetryItem = createTelemetryItem(metric, MetricDataType, MetricEnvelopeType, _self[_DYN_DIAG_LOG ](), customProperties);
                         _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                     }
                     catch (e) {
@@ -5659,12 +6030,12 @@
                         var duration = ((properties || pageView[_DYN_PROPERTIES ] || {})[_DYN_DURATION ] || 0);
                         pageView[_DYN_START_TIME ] = new Date(new Date().getTime() - duration);
                     }
-                    var telemetryItem = createTelemetryItem(pageView, PageView[_DYN_DATA_TYPE ], PageView[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties, systemProperties);
+                    var telemetryItem = createTelemetryItem(pageView, PageViewDataType, PageViewEnvelopeType, _self[_DYN_DIAG_LOG ](), properties, systemProperties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                     _resetAjaxAttempts();
                 };
                 _self[_DYN_SEND_PAGE_VIEW_PERFO3 ] = function (pageViewPerformance, properties, systemProperties) {
-                    var telemetryItem = createTelemetryItem(pageViewPerformance, PageViewPerformance[_DYN_DATA_TYPE ], PageViewPerformance[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties, systemProperties);
+                    var telemetryItem = createTelemetryItem(pageViewPerformance, PageViewPerformanceDataType, PageViewPerformanceEnvelopeType, _self[_DYN_DIAG_LOG ](), properties, systemProperties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 };
                 _self.trackPageViewPerformance = function (pageViewPerformance, customProperties) {
@@ -5728,7 +6099,7 @@
                             exceptionPartB[_DYN_PROPERTIES ]["exceptionLog"] = logs.logs.slice(0, _expCfg.maxLogs).join("\n");
                         }
                     }
-                    var telemetryItem = createTelemetryItem(exceptionPartB, Exception[_DYN_DATA_TYPE ], Exception[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), customProperties, systemProperties);
+                    var telemetryItem = createTelemetryItem(exceptionPartB, ExceptionDataType, ExceptionEnvelopeType, _self[_DYN_DIAG_LOG ](), customProperties, systemProperties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 };
                 _self.trackException = function (exception, customProperties) {
@@ -5803,10 +6174,10 @@
                             _preInitTelemetryInitializers = null;
                         }
                         _populateDefaults(config);
-                        _pageViewPerformanceManager = new PageViewPerformanceManager(_self[_DYN_CORE ]);
-                        _pageViewManager = new PageViewManager(_self, _extConfig.overridePageViewDuration, _self[_DYN_CORE ], _pageViewPerformanceManager);
-                        _pageVisitTimeManager = new PageVisitTimeManager(_self[_DYN_DIAG_LOG ](), function (pageName, pageUrl, pageVisitTime) { return trackPageVisitTime(pageName, pageUrl, pageVisitTime); });
-                        _eventTracking = new Timing(_self[_DYN_DIAG_LOG ](), "trackEvent");
+                        _pageViewPerformanceManager = createPageViewPerformanceManager(_self[_DYN_CORE ]);
+                        _pageViewManager = createPageViewManager(_self, _extConfig.overridePageViewDuration, _self[_DYN_CORE ], _pageViewPerformanceManager);
+                        _pageVisitTimeManager = createPageVisitTimeManager(_self[_DYN_DIAG_LOG ](), function (pageName, pageUrl, pageVisitTime) { return trackPageVisitTime(pageName, pageUrl, pageVisitTime); });
+                        _eventTracking = createTiming(_self[_DYN_DIAG_LOG ]());
                         _eventTracking.action =
                             function (name, url, duration, properties, measurements) {
                                 if (!properties) {
@@ -5818,7 +6189,7 @@
                                 properties.duration = duration[_DYN_TO_STRING ]();
                                 _self.trackEvent({ name: name, properties: properties, measurements: measurements });
                             };
-                        _pageTracking = new Timing(_self[_DYN_DIAG_LOG ](), "trackPageView");
+                        _pageTracking = createTiming(_self[_DYN_DIAG_LOG ]());
                         _pageTracking.action = function (name, url, duration, properties, measurements) {
                             if (isNullOrUndefined(properties)) {
                                 properties = {};
@@ -5867,6 +6238,7 @@
                         _autoExceptionInstrumented = _autoExceptionInstrumented || config[_DYN_AUTO_EXCEPTION_INSTR9 ] || _extConfig[_DYN_AUTO_EXCEPTION_INSTR9 ];
                         _expCfg = _extConfig.expCfg;
                         _autoTrackPageVisitTime = _extConfig[_DYN_AUTO_TRACK_PAGE_VISI10 ];
+                        _routeTraceStrategy = _extConfig.routeTraceStrategy || 0 ;
                         if (config.storagePrefix) {
                             utlSetStoragePrefix(config.storagePrefix);
                         }
@@ -5889,7 +6261,7 @@
                     if (!_browserLinkInitializerAdded && _isBrowserLinkTrackingEnabled) {
                         var browserLinkPaths_1 = ["/browserLinkSignalR/", "/__browserLink/"];
                         var dropBrowserLinkRequests = function (envelope) {
-                            if (_isBrowserLinkTrackingEnabled && envelope.baseType === RemoteDependencyData[_DYN_DATA_TYPE ]) {
+                            if (_isBrowserLinkTrackingEnabled && envelope.baseType === RemoteDependencyDataType) {
                                 var remoteData = envelope.baseData;
                                 if (remoteData) {
                                     for (var i = 0; i < browserLinkPaths_1[_DYN_LENGTH ]; i++) {
@@ -5906,7 +6278,7 @@
                     }
                 }
                 function _sendCORSException(exception, properties) {
-                    var telemetryItem = createTelemetryItem(exception, Exception[_DYN_DATA_TYPE ], Exception[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties);
+                    var telemetryItem = createTelemetryItem(exception, ExceptionDataType, ExceptionEnvelopeType, _self[_DYN_DIAG_LOG ](), properties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 }
                 function _updateExceptionTracking() {
@@ -5942,22 +6314,6 @@
                         }
                     }));
                 }
-                function _getDistributedTraceCtx() {
-                    var distributedTraceCtx = null;
-                    if (_self[_DYN_CORE ] && _self[_DYN_CORE ].getTraceCtx) {
-                        distributedTraceCtx = _self[_DYN_CORE ].getTraceCtx(false);
-                    }
-                    if (!distributedTraceCtx) {
-                        var properties = _self[_DYN_CORE ].getPlugin(PropertiesPluginIdentifier);
-                        if (properties) {
-                            var context = properties.plugin.context;
-                            if (context) {
-                                distributedTraceCtx = createDistributedTraceContextFromTrace(context.telemetryTrace);
-                            }
-                        }
-                    }
-                    return distributedTraceCtx;
-                }
                 function _addHistoryListener(win, history, locn) {
                     if (_historyListenerAdded) {
                         return;
@@ -5980,14 +6336,18 @@
                             _currUri = fieldRedaction(_currUri, _self[_DYN_CORE ][_DYN_CONFIG ]);
                         }
                         if (_enableAutoRouteTracking) {
-                            var distributedTraceCtx = _getDistributedTraceCtx();
-                            if (distributedTraceCtx) {
-                                distributedTraceCtx.setTraceId(generateW3CId());
-                                var traceLocationName = "_unknown_";
-                                if (locn && locn.pathname) {
-                                    traceLocationName = locn.pathname + (locn.hash || "");
+                            var newContext = void 0;
+                            if (_self[_DYN_CORE ] && _self[_DYN_CORE ][_DYN_GET_TRACE_CTX ]) {
+                                var currentContext = _self[_DYN_CORE ][_DYN_GET_TRACE_CTX ](false);
+                                if (currentContext && _routeTraceStrategy === 1 ) {
+                                    newContext = createDistributedTraceContext(currentContext);
+                                }
+                                else {
+                                    newContext = _self[_DYN_CORE ][_DYN_GET_TRACE_CTX ](true);
                                 }
-                                distributedTraceCtx.setName(dataSanitizeString(_self[_DYN_DIAG_LOG ](), traceLocationName));
+                                newContext.traceId = generateW3CId();
+                                newContext.pageName = dataSanitizeString(_self[_DYN_DIAG_LOG ](), newContext.pageName || "_unknown_");
+                                _self[_DYN_CORE ].setTraceCtx(newContext);
                             }
                             scheduleTimeout((function (uri) {
                                 _self[_DYN_TRACK_PAGE_VIEW ]({ refUri: uri, properties: { duration: 0 } });
@@ -6074,7 +6434,7 @@
             });
             return _this;
         }
-        AnalyticsPlugin.Version = '3.3.12-nightly3.2602-18';
+        AnalyticsPlugin.Version = '3.4.0-beta';
         return AnalyticsPlugin;
     }(BaseTelemetryPlugin));