@microsoft/applicationinsights-common 3.4.0-nightlybeta3.2505-35 → 3.4.0-nightlybeta3.2507-23

package/dist/es5/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.4.0-nightlybeta3.2505-35
+ * Application Insights JavaScript SDK - Common, 3.4.0-nightlybeta3.2507-23
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -32,6 +32,7 @@
     var CALL = "call";
     var TO_STRING = "toString";
     var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
+    var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
     var ObjClass$1 = ( /*#__PURE__*/_pureAssign(Object));
     var ObjProto$1 = ( /*#__PURE__*/_pureRef(ObjClass$1, PROTOTYPE));
     var StrCls = ( /*#__PURE__*/_pureAssign(String));
@@ -103,6 +104,9 @@
     function _returnNothing() {
         return;
     }
+    function _returnEmptyArray() {
+        return [];
+    }
     var asString = ( /*#__PURE__*/_pureAssign(StrCls));
     var ERROR_TYPE = "[object Error]";
     /*#__NO_SIDE_EFFECTS__*/
@@ -184,7 +188,26 @@
             throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
         };
     }
+    function _objPropertyIsEnum(obj, propKey) {
+        var desc;
+        var fn = ObjClass$1.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$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    var _objGetOwnPropertySymbols = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -217,6 +240,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 = {};
@@ -251,6 +286,10 @@
         return _createKeyValueMap(values, 1 , 0 , objFreeze);
     }
     /*#__NO_SIDE_EFFECTS__*/
+    function createEnumKeyMap(values) {
+        return _createKeyValueMap(values, 0 , 0 , objFreeze);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function createSimpleMap(values) {
         var mapClass = {};
         objForEachKey(values, function (key, value) {
@@ -263,6 +302,21 @@
     function createTypeMap(values) {
         return createSimpleMap(values);
     }
+    var _wellKnownSymbolMap = ( /*#__PURE__*/createEnumKeyMap({
+        asyncIterator: 0 ,
+        hasInstance: 1 ,
+        isConcatSpreadable: 2 ,
+        iterator: 3 ,
+        match: 4 ,
+        matchAll: 5 ,
+        replace: 6 ,
+        search: 7 ,
+        species: 8 ,
+        split: 9 ,
+        toPrimitive: 10 ,
+        toStringTag: 11 ,
+        unscopables: 12
+    }));
     var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
     var _globalCfg;
     /*#__NO_SIDE_EFFECTS__*/
@@ -413,6 +467,7 @@
         }
         return _polySymbols;
     }
+    var _wellKnownSymbolCache;
     /*#__NO_SIDE_EFFECTS__*/
     function polyNewSymbol(description) {
         var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
@@ -445,11 +500,37 @@
         return registry.k[key];
     }
     /*#__NO_SIDE_EFFECTS__*/
+    function polyGetKnownSymbol(name) {
+        !_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
+        var result;
+        var knownName = _wellKnownSymbolMap[name];
+        if (knownName) {
+            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+        }
+        return result;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function createCachedValue(value) {
         return objDefineProp({
             toJSON: function () { return value; }
         }, "v", { value: value });
     }
+    var createDeferredCachedValue = getDeferred;
+    /*#__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) {
@@ -513,6 +594,13 @@
         return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
     }
     /*#__NO_SIDE_EFFECTS__*/
+    function getKnownSymbol(name, noPoly) {
+        var knownName = _wellKnownSymbolMap[name];
+        !_globalLazyTestHooks && _initTestHooks();
+        var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+        return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function newSymbol(description, noPoly) {
         !_globalLazyTestHooks && _initTestHooks();
         var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
@@ -620,6 +708,7 @@
         }
         return result;
     }
+    var strSplit = ( /*#__PURE__*/_unwrapFunction("split", StrProto));
     var _perf;
     /*#__NO_SIDE_EFFECTS__*/
     function getPerformance() {
@@ -759,7 +848,11 @@
     var _DYN_SPLICE = "splice";
     var _DYN_LOGGER = "logger";
     var _DYN_CANCEL = "cancel";
+    var _DYN_TRACE_ID = "traceId";
+    var _DYN_SPAN_ID = "spanId";
+    var _DYN_TRACE_FLAGS$1 = "traceFlags";
     var _DYN_NAME$1 = "name";
+    var _DYN_VALUE = "value";
     var _DYN_UNLOAD = "unload";
     var _DYN_VERSION = "version";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
@@ -769,10 +862,12 @@
     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_INDEX_OF = "indexOf";
-    var _DYN_TRACE_FLAGS = "traceFlags";
+    var _DYN_SET_TRACE_FLAGS = "setTraceFlags";
+    var _DYN_TRACE_STATE = "traceState";
     var _DYN_GET_ATTRIBUTE = "getAttribute";
 
     var aggregationErrorType;
@@ -1091,6 +1186,8 @@
     var UNDEFINED_VALUE = undefined;
     var STR_EMPTY = "";
     var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+    var STR_REDACTED = "REDACTED";
+    var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
 
     var rCamelCase = /-([a-z])/g;
     var rNormalizeInvalid = /([^\w\d_$])/g;
@@ -1140,6 +1237,7 @@
         }());
     }
 
+    var strLocation = "location";
     var strConsole = "console";
     var strJSON = "JSON";
     var strCrypto = "crypto";
@@ -1148,7 +1246,20 @@
     var strTrident = "trident/";
     var _isTrident = null;
     var _navUserAgentCheck = null;
+    var _enableMocks = false;
     var _beaconsSupported = null;
+    function getLocation(checkForMock) {
+        if (checkForMock && _enableMocks) {
+            var mockLocation = getInst("__mockLocation");
+            if (mockLocation) {
+                return mockLocation;
+            }
+        }
+        if (typeof location === strShimObject && location) {
+            return location;
+        }
+        return getInst(strLocation);
+    }
     function getConsole() {
         if (typeof console !== strShimUndefined) {
             return console;
@@ -1186,34 +1297,162 @@
         return _beaconsSupported;
     }
     function _getNamedValue(values, name) {
+        var items = [];
         if (values) {
-            for (var i = 0; i < values[_DYN_LENGTH$1 ]; i++) {
-                var value = values[i];
+            arrForEach(values, function (value) {
                 if (value[_DYN_NAME$1 ]) {
                     if (value[_DYN_NAME$1 ] === name) {
-                        return value;
+                        items[_DYN_PUSH ](value);
                     }
                 }
-            }
+            });
         }
-        return {};
+        return items;
     }
     function findMetaTag(name) {
+        var tags = findMetaTags(name);
+        if (tags[_DYN_LENGTH$1 ] > 0) {
+            return tags[0];
+        }
+        return null;
+    }
+    function findMetaTags(name) {
+        var tags = [];
         var doc = getDocument();
         if (doc && name) {
-            return _getNamedValue(doc.querySelectorAll("meta"), name).content;
+            arrForEach(_getNamedValue(doc.querySelectorAll("meta"), name), function (item) {
+                tags[_DYN_PUSH ](item.content);
+            });
         }
-        return null;
+        return tags;
     }
     function findNamedServerTiming(name) {
         var value;
-        var perf = getPerformance();
-        if (perf) {
-            var navPerf = perf.getEntriesByType("navigation") || [];
-            value = _getNamedValue((navPerf[_DYN_LENGTH$1 ] > 0 ? navPerf[0] : {}).serverTiming, name).description;
+        var serverTimings = findNamedServerTimings(name);
+        if (serverTimings[_DYN_LENGTH$1 ] > 0) {
+            value = serverTimings[0];
         }
         return value;
     }
+    function findNamedServerTimings(name) {
+        var values = [];
+        var perf = getPerformance();
+        if (perf && perf.getEntriesByType) {
+            arrForEach(perf.getEntriesByType("navigation") || [], function (navPerf) {
+                arrForEach(_getNamedValue(navPerf.serverTiming, name), function (value) {
+                    var desc = value.description;
+                    if (!isNullOrUndefined(desc)) {
+                        values[_DYN_PUSH ](desc);
+                    }
+                });
+            });
+        }
+        return values;
+    }
+    function redactUserInfo(url) {
+        return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
+    }
+    function redactQueryParameters(url, config) {
+        var sensitiveParams;
+        var questionMarkIndex = strIndexOf(url, "?");
+        if (questionMarkIndex === -1) {
+            return url;
+        }
+        if (config && config.redactQueryParams) {
+            sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
+        }
+        else {
+            sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
+        }
+        var baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
+        var queryString = strSubstring(url, questionMarkIndex + 1);
+        var fragment = STR_EMPTY;
+        var hashIndex = strIndexOf(queryString, "#");
+        if (hashIndex !== -1) {
+            fragment = strSubstring(queryString, hashIndex);
+            queryString = strSubstring(queryString, 0, hashIndex);
+        }
+        var hasPotentialSensitiveParam = false;
+        for (var i = 0; i < sensitiveParams[_DYN_LENGTH$1 ]; i++) {
+            var paramCheck = sensitiveParams[i] + "=";
+            if (strIndexOf(queryString, paramCheck) !== -1) {
+                hasPotentialSensitiveParam = true;
+                break;
+            }
+        }
+        if (!hasPotentialSensitiveParam) {
+            return url;
+        }
+        var resultParts = [];
+        var anyParamRedacted = false;
+        if (queryString && queryString[_DYN_LENGTH$1 ]) {
+            var pairs = queryString[_DYN_SPLIT$1 ]("&");
+            for (var i = 0; i < pairs[_DYN_LENGTH$1 ]; i++) {
+                var pair = pairs[i];
+                if (!pair) {
+                    continue;
+                }
+                var equalsIndex = strIndexOf(pair, "=");
+                if (equalsIndex === -1) {
+                    resultParts[_DYN_PUSH ](pair);
+                }
+                else {
+                    var paramName = pair[_DYN_SUBSTRING ](0, equalsIndex);
+                    var paramValue = pair[_DYN_SUBSTRING ](equalsIndex + 1);
+                    if (paramValue === STR_EMPTY) {
+                        resultParts[_DYN_PUSH ](pair);
+                    }
+                    else {
+                        var shouldRedact = false;
+                        for (var j = 0; j < sensitiveParams[_DYN_LENGTH$1 ]; j++) {
+                            if (paramName === sensitiveParams[j]) {
+                                shouldRedact = true;
+                                anyParamRedacted = true;
+                                break;
+                            }
+                        }
+                        if (shouldRedact) {
+                            resultParts[_DYN_PUSH ](paramName + "=" + STR_REDACTED);
+                        }
+                        else {
+                            resultParts[_DYN_PUSH ](pair);
+                        }
+                    }
+                }
+            }
+        }
+        if (!anyParamRedacted) {
+            return url;
+        }
+        return baseUrl + resultParts.join("&") + fragment;
+    }
+    function fieldRedaction(input, config) {
+        if (!input || input[_DYN_INDEX_OF ](" ") !== -1) {
+            return input;
+        }
+        var isRedactionDisabled = config && config.redactUrls === false;
+        if (isRedactionDisabled) {
+            return input;
+        }
+        var hasCredentials = strIndexOf(input, "@") !== -1;
+        var hasQueryParams = strIndexOf(input, "?") !== -1;
+        if (!hasCredentials && !hasQueryParams) {
+            return input;
+        }
+        try {
+            var result = input;
+            if (hasCredentials) {
+                result = redactUserInfo(input);
+            }
+            if (hasQueryParams) {
+                result = redactQueryParameters(result, config);
+            }
+            return result;
+        }
+        catch (e) {
+            return input;
+        }
+    }
 
     var UInt32Mask = 0x100000000;
     var MaxUInt32 = 0xffffffff;
@@ -1291,7 +1530,7 @@
         return result;
     }
 
-    var version = '3.4.0-nightlybeta3.2505-35';
+    var version = '3.4.0-nightlybeta3.2507-23';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -1957,6 +2196,390 @@
         return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
+    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 TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
+    var DEFAULT_VERSION = "00";
+    var INVALID_VERSION = "ff";
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    var SAMPLED_FLAG = 0x01;
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH$1 ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/i);
+        }
+        return false;
+    }
+    function _formatValue(value, len, defValue) {
+        if (_isValid(value, len)) {
+            return value;
+        }
+        return defValue;
+    }
+    function _formatFlags(value) {
+        if (isNaN(value) || value < 0 || value > 255) {
+            value = 0x01;
+        }
+        var result = value.toString(16);
+        while (result[_DYN_LENGTH$1 ] < 2) {
+            result = "0" + result;
+        }
+        return result;
+    }
+    function createTraceParent(traceId, spanId, flags, version) {
+        return {
+            version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+            traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
+            spanId: isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
+            traceFlags: (!isNullOrUndefined(flags) && flags >= 0 && flags <= 0xFF ? flags : 1 )
+        };
+    }
+    function parseTraceParent(value, selectIdx) {
+        if (!value) {
+            return null;
+        }
+        if (isArray(value)) {
+            value = value[0] || STR_EMPTY;
+        }
+        if (!value || !isString(value) || value[_DYN_LENGTH$1 ] > 8192) {
+            return null;
+        }
+        if (value[_DYN_INDEX_OF ](",") !== -1) {
+            var values = value[_DYN_SPLIT$1 ](",");
+            value = values[selectIdx > 0 && values[_DYN_LENGTH$1 ] > selectIdx ? selectIdx : 0];
+        }
+        TRACE_PARENT_REGEX.lastIndex = 0;
+        var match = TRACE_PARENT_REGEX.exec(strTrim(value));
+        if (!match ||
+            match[1] === INVALID_VERSION ||
+            match[2] === INVALID_TRACE_ID ||
+            match[3] === INVALID_SPAN_ID) {
+            return null;
+        }
+        return {
+            version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+            traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+            spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+            traceFlags: parseInt(match[4], 16)
+        };
+    }
+    function isValidTraceId(value) {
+        return _isValid(value, 32, INVALID_TRACE_ID);
+    }
+    function isValidSpanId(value) {
+        return _isValid(value, 16, INVALID_SPAN_ID);
+    }
+    function isValidTraceParent(value) {
+        if (!value ||
+            !_isValid(value[_DYN_VERSION ], 2, INVALID_VERSION) ||
+            !_isValid(value[_DYN_TRACE_ID ], 32, INVALID_TRACE_ID) ||
+            !_isValid(value[_DYN_SPAN_ID ], 16, INVALID_SPAN_ID) ||
+            !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS$1 ]), 2)) {
+            return false;
+        }
+        return true;
+    }
+    function isSampledFlag(value) {
+        if (isValidTraceParent(value)) {
+            return (value[_DYN_TRACE_FLAGS$1 ] & SAMPLED_FLAG) === SAMPLED_FLAG;
+        }
+        return false;
+    }
+    function formatTraceParent(value) {
+        if (value) {
+            var flags = _formatFlags(value[_DYN_TRACE_FLAGS$1 ]);
+            if (!_isValid(flags, 2)) {
+                flags = "01";
+            }
+            var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
+            if (version !== "00" && version !== "ff") {
+                version = DEFAULT_VERSION;
+            }
+            return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
+        }
+        return STR_EMPTY;
+    }
+    function findW3cTraceParent(selectIdx) {
+        var name = "traceparent";
+        var traceParent = parseTraceParent(findMetaTag(name), selectIdx);
+        if (!traceParent) {
+            traceParent = parseTraceParent(findNamedServerTiming(name), selectIdx);
+        }
+        return traceParent;
+    }
+    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 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 = 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 null;
+    }
+    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 items;
+    }
+    function _indexOf(items, key) {
+        for (var lp = 0; lp < items[_DYN_LENGTH$1 ]; lp++) {
+            if (items[lp].key === key) {
+                return lp;
+            }
+        }
+        return -1;
+    }
+    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;
+    }
+    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;
+    }
+    function createW3cTraceState(value, parent) {
+        var cachedItems = createDeferredCachedValue(function () { return safe(_parseTraceStateList, [value || STR_EMPTY]).v || []; });
+        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
+            }
+        });
+        objDefine(traceStateList, getKnownSymbol(11 ), { g: _toString });
+        return traceStateList;
+    }
+
     var _aiNamespace = null;
     function _getExtensionNamespace() {
         var target = getInst("Microsoft");
@@ -2155,160 +2778,148 @@
         _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
     }
 
-    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 TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
-    var DEFAULT_VERSION = "00";
-    var INVALID_VERSION = "ff";
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    var SAMPLED_FLAG = 0x01;
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH$1 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/i);
-        }
-        return false;
-    }
-    function _formatValue(value, len, defValue) {
-        if (_isValid(value, len)) {
-            return value;
-        }
-        return defValue;
-    }
-    function _formatFlags(value) {
-        if (isNaN(value) || value < 0 || value > 255) {
-            value = 0x01;
-        }
-        var result = value.toString(16);
-        while (result[_DYN_LENGTH$1 ] < 2) {
-            result = "0" + result;
-        }
-        return result;
-    }
-    function createTraceParent(traceId, spanId, flags, version) {
-        return {
-            version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
-            traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
-            spanId: isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
-            traceFlags: flags >= 0 && flags <= 0xFF ? flags : 1
-        };
-    }
-    function parseTraceParent(value, selectIdx) {
-        if (!value) {
-            return null;
+    createElmNodeData("plugin");
+    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 ]);
+    }
+    function createDistributedTraceContext(parent) {
+        var _a;
+        var parentCtx = null;
+        var spanContext = 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$1 ] : 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 {
+                spanContext = parent;
+            }
         }
-        if (isArray(value)) {
-            value = value[0] || "";
+        if (!pageName) {
+            pageName = "_unknown_";
+            var location_1 = getLocation();
+            if (location_1 && location_1.pathname) {
+                pageName = location_1.pathname + (location_1.hash || "");
+            }
         }
-        if (!value || !isString(value) || value[_DYN_LENGTH$1 ] > 8192) {
-            return null;
+        function _getName() {
+            return pageName;
         }
-        if (value[_DYN_INDEX_OF ](",") !== -1) {
-            var values = value[_DYN_SPLIT$1 ](",");
-            value = values[selectIdx > 0 && values[_DYN_LENGTH$1 ] > selectIdx ? selectIdx : 0];
+        function _setPageNameFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setName(newValue);
+                }
+                pageName = newValue;
+            };
         }
-        var match = TRACE_PARENT_REGEX.exec(strTrim(value));
-        if (!match ||
-            match[1] === INVALID_VERSION ||
-            match[2] === INVALID_TRACE_ID ||
-            match[3] === INVALID_SPAN_ID) {
-            return null;
+        function _getTraceId() {
+            return traceId;
         }
-        return {
-            version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
-            traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
-            spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
-            traceFlags: parseInt(match[4], 16)
-        };
-    }
-    function isValidTraceId(value) {
-        return _isValid(value, 32, INVALID_TRACE_ID);
-    }
-    function isValidSpanId(value) {
-        return _isValid(value, 16, INVALID_SPAN_ID);
-    }
-    function isValidTraceParent(value) {
-        if (!value ||
-            !_isValid(value[_DYN_VERSION ], 2, INVALID_VERSION) ||
-            !_isValid(value.traceId, 32, INVALID_TRACE_ID) ||
-            !_isValid(value.spanId, 16, INVALID_SPAN_ID) ||
-            !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS ]), 2)) {
-            return false;
+        function _setTraceIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setTraceId(newValue);
+                }
+                if (isValidTraceId(newValue)) {
+                    traceId = newValue;
+                }
+            };
         }
-        return true;
-    }
-    function isSampledFlag(value) {
-        if (isValidTraceParent(value)) {
-            return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
+        function _getSpanId() {
+            return spanId;
         }
-        return false;
-    }
-    function formatTraceParent(value) {
-        if (value) {
-            var flags = _formatFlags(value[_DYN_TRACE_FLAGS ]);
-            if (!_isValid(flags, 2)) {
-                flags = "01";
-            }
-            var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
-            if (version !== "00" && version !== "ff") {
-                version = DEFAULT_VERSION;
-            }
-            return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
+        function _setSpanIdFn(updateParent) {
+            return function (newValue) {
+                if (updateParent) {
+                    parentCtx && parentCtx.setSpanId(newValue);
+                }
+                if (isValidSpanId(newValue)) {
+                    spanId = newValue;
+                }
+            };
         }
-        return "";
-    }
-    function findW3cTraceParent(selectIdx) {
-        var name = "traceparent";
-        var traceParent = parseTraceParent(findMetaTag(name), selectIdx);
-        if (!traceParent) {
-            traceParent = parseTraceParent(findNamedServerTiming(name), selectIdx);
+        function _getTraceFlags() {
+            return traceFlags;
         }
-        return traceParent;
-    }
-    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;
+        function _setTraceFlagsFn(updateParent) {
+            return function (newTraceFlags) {
+                if (updateParent) {
+                    parentCtx && parentCtx[_DYN_SET_TRACE_FLAGS ](newTraceFlags);
                 }
-                if (async) {
-                    info.async = async;
-                }
-                if (defer) {
-                    info.defer = defer;
+                traceFlags = newTraceFlags;
+            };
+        }
+        function _getTraceState() {
+            if (!traceState) {
+                if (spanContext && spanContext[_DYN_TRACE_STATE ]) {
+                    traceState = createW3cTraceState(spanContext[_DYN_TRACE_STATE ].serialize() || STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
                 }
-                if (referrerPolicy) {
-                    info.referrerPolicy = referrerPolicy;
+                else {
+                    traceState = createW3cTraceState(STR_EMPTY, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
                 }
-                result[_DYN_PUSH ](info);
+            }
+            return traceState;
+        }
+        var traceCtx = (_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);
+        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; }
             }
         });
-        return result;
     }
 
     var strOnPrefix = "on";
@@ -2491,7 +3102,7 @@
     var strNotSpecified = "not_specified";
     var strIkey = "iKey";
 
-    var RequestHeaders = createValueMap({
+    var RequestHeaders = ( /* @__PURE__ */createValueMap({
         requestContextHeader: [0 , "Request-Context"],
         requestContextTargetKey: [1 , "appId"],
         requestContextAppIdFormat: [2 , "appId=cid-v1:"],
@@ -2501,7 +3112,7 @@
         sdkContextHeader: [6 , "Sdk-Context"],
         sdkContextHeaderAppIdRequest: [7 , "appId"],
         requestContextHeaderLowerCase: [8 , "request-context"]
-    });
+    }));
 
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH = "length";
@@ -2518,6 +3129,7 @@
     var _DYN_MATCH = "match";
     var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
     var _DYN_NAME = "name";
+    var _DYN_TRACE_FLAGS = "traceFlags";
     var _DYN_EXTENSION_CONFIG = "extensionConfig";
     var _DYN_PROPERTIES = "properties";
     var _DYN_MEASUREMENTS = "measurements";
@@ -2572,7 +3184,10 @@
         }
         return valueTrunc || value;
     }
-    function dataSanitizeUrl(logger, url) {
+    function dataSanitizeUrl(logger, url, config) {
+        if (isString(url)) {
+            url = fieldRedaction(url, config);
+        }
         return dataSanitizeInput(logger, url, 2048 , 66 );
     }
     function dataSanitizeMessage(logger, message) {
@@ -2843,56 +3458,33 @@
         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 traceCtx = createDistributedTraceContext(parentCtx);
+        if (telemetryTrace) {
+            traceCtx.pageName = telemetryTrace[_DYN_NAME ] || traceCtx.pageName || "";
+            traceCtx.traceId = telemetryTrace.traceID || traceCtx.traceId || "";
+            traceCtx.spanId = telemetryTrace.parentID || traceCtx.spanId || "";
+            traceCtx[_DYN_TRACE_FLAGS ] = (!isNullOrUndefined(telemetryTrace[_DYN_TRACE_FLAGS ]) ? telemetryTrace[_DYN_TRACE_FLAGS ] : traceCtx[_DYN_TRACE_FLAGS ]) || 0;
+        }
+        return traceCtx;
     }
 
-    var StorageType = createEnumStyle({
+    var StorageType = ( /* @__PURE__ */createEnumStyle({
         LocalStorage: 0 ,
         SessionStorage: 1
-    });
-    var DistributedTracingModes = createEnumStyle({
+    }));
+    var DistributedTracingModes = ( /* @__PURE__ */createEnumStyle({
         AI: 0 ,
         AI_AND_W3C: 1 ,
-        W3C: 2
-    });
-    var EventPersistence = createEnumStyle({
+        W3C: 2 ,
+        AI_AND_W3C_TRACE: 17 ,
+        W3C_TRACE: 18 ,
+        _BaseMask: 15 ,
+        _W3CTraceState: 16
+    }));
+    var EventPersistence = ( /* @__PURE__ */createEnumStyle({
         Normal: 1 ,
         Critical: 2
-    });
+    }));
 
     var _canUseLocalStorage = undefined;
     var _canUseSessionStorage = undefined;
@@ -4245,13 +4837,13 @@
         return Data;
     }());
 
-    var SeverityLevel = createEnumStyle({
+    var SeverityLevel = ( /* @__PURE__ */createEnumStyle({
         Verbose: 0 ,
         Information: 1 ,
         Warning: 2 ,
         Error: 3 ,
         Critical: 4
-    });
+    }));
 
     var ConfigurationManager = /** @class */ (function () {
         function ConfigurationManager() {