@microsoft/applicationinsights-core-js 3.4.0-nightlybeta3.2505-36 → 3.4.0-nightlybeta3.2507-22

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.4.0-nightlybeta3.2505-36
+ * Application Insights JavaScript SDK - Core, 3.4.0-nightlybeta3.2507-22
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -34,6 +34,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 = ( /*#__PURE__*/_pureRef(ObjClass$1, PROTOTYPE));
     var StrCls = ( /*#__PURE__*/_pureAssign(String));
@@ -144,6 +145,9 @@
     function _returnNothing() {
         return;
     }
+    function _returnEmptyArray() {
+        return [];
+    }
     function _returnFalse() {
         return false;
     }
@@ -234,7 +238,26 @@
             return thisArg[propName];
         };
     }
+    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",
@@ -280,6 +303,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 = {};
@@ -562,6 +597,22 @@
             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) {
@@ -978,6 +1029,7 @@
     function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
         return _doExtend(objDeepCopy(target) || {}, ArrSlice[CALL](arguments));
     }
+    var strSplit = ( /*#__PURE__*/_unwrapFunction("split", StrProto));
     var getLength = ( /*#__PURE__*/_unwrapProp(LENGTH));
     var _perf;
     /*#__NO_SIDE_EFFECTS__*/
@@ -1126,27 +1178,27 @@
     var createEnumStyle = createEnum;
     var createValueMap = createTypeMap;
 
-    var EventsDiscardedReason = createEnumStyle({
+    var EventsDiscardedReason = ( /* @__PURE__ */createEnumStyle({
         Unknown: 0 ,
         NonRetryableStatus: 1 ,
         InvalidEvent: 2 ,
         SizeLimitExceeded: 3 ,
         KillSwitch: 4 ,
         QueueFull: 5
-    });
-    var BatchDiscardedReason = createEnumStyle({
+    }));
+    var BatchDiscardedReason = ( /* @__PURE__ */createEnumStyle({
         Unknown: 0 ,
         NonRetryableStatus: 1 ,
         CleanStorage: 2 ,
         MaxInStorageTimeExceeded: 3
-    });
+    }));
 
-    var ActiveStatus = createEnumStyle({
+    var ActiveStatus = ( /* @__PURE__ */createEnumStyle({
         NONE: 0 ,
         PENDING: 3 ,
         INACTIVE: 1 ,
         ACTIVE: 2
-    });
+    }));
 
     var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_LENGTH = "length";
@@ -1162,7 +1214,11 @@
     var _DYN_IDENTIFIER = "identifier";
     var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
     var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
+    var _DYN_TRACE_ID = "traceId";
+    var _DYN_SPAN_ID = "spanId";
+    var _DYN_TRACE_FLAGS = "traceFlags";
     var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_TRACE_HDR_MODE = "traceHdrMode";
     var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
     var _DYN_GET_PLUGIN = "getPlugin";
     var _DYN_NAME = "name";
@@ -1187,10 +1243,11 @@
     var _DYN_USER_AGENT = "userAgent";
     var _DYN_SPLIT = "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_STATUS = "status";
-    var _DYN_INDEX_OF = "indexOf";
     var _DYN_GET_ALL_RESPONSE_HEA5 = "getAllResponseHeaders";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
     var _DYN_DATA = "data";
@@ -1200,7 +1257,8 @@
     var _DYN_HEADERS = "headers";
     var _DYN_URL_STRING = "urlString";
     var _DYN_TIMEOUT = "timeout";
-    var _DYN_TRACE_FLAGS = "traceFlags";
+    var _DYN_SET_TRACE_FLAGS = "setTraceFlags";
+    var _DYN_TRACE_STATE = "traceState";
     var _DYN_GET_ATTRIBUTE = "getAttribute";
 
     var aggregationErrorType;
@@ -1934,6 +1992,8 @@
     var STR_DOMAIN = "domain";
     var STR_PATH = "path";
     var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+    var STR_REDACTED = "REDACTED";
+    var DEFAULT_SENSITIVE_PARAMS = ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"];
 
     var strGetPrototypeOf = "getPrototypeOf";
     var rCamelCase = /-([a-z])/g;
@@ -2211,7 +2271,7 @@
                     var idx = headerEntry[_DYN_INDEX_OF ](": ");
                     if (idx !== -1) {
                         var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE ]();
-                        var value = strTrim(headerEntry.substring(idx + 1));
+                        var value = strTrim(headerEntry[_DYN_SUBSTRING ](idx + 1));
                         headers[header] = value;
                     }
                     else {
@@ -2407,34 +2467,58 @@
         return isSupported;
     }
     function _getNamedValue(values, name) {
+        var items = [];
         if (values) {
-            for (var i = 0; i < values[_DYN_LENGTH ]; i++) {
-                var value = values[i];
+            arrForEach(values, function (value) {
                 if (value[_DYN_NAME ]) {
                     if (value[_DYN_NAME ] === name) {
-                        return value;
+                        items[_DYN_PUSH ](value);
                     }
                 }
-            }
+            });
         }
-        return {};
+        return items;
     }
     function findMetaTag(name) {
+        var tags = findMetaTags(name);
+        if (tags[_DYN_LENGTH ] > 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 ] > 0 ? navPerf[0] : {}).serverTiming, name).description;
+        var serverTimings = findNamedServerTimings(name);
+        if (serverTimings[_DYN_LENGTH ] > 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 dispatchEvent(target, evnt) {
         if (target && target.dispatchEvent && evnt) {
             target.dispatchEvent(evnt);
@@ -2469,6 +2553,110 @@
         }
         return false;
     }
+    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$1;
+        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 ]; 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 ]) {
+            var pairs = queryString[_DYN_SPLIT ]("&");
+            for (var i = 0; i < pairs[_DYN_LENGTH ]; 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$1) {
+                        resultParts[_DYN_PUSH ](pair);
+                    }
+                    else {
+                        var shouldRedact = false;
+                        for (var j = 0; j < sensitiveParams[_DYN_LENGTH ]; 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;
@@ -2554,7 +2742,7 @@
         return result;
     }
 
-    var version = '3.4.0-nightlybeta3.2505-36';
+    var version = '3.4.0-nightlybeta3.2507-22';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -3205,29 +3393,559 @@
         _makeDynamicObject(theState, newTarget, "config", "Creating");
         return cfgHandler;
     }
-    function _logInvalidAccess(logger, message) {
-        if (logger) {
-            logger[_DYN_WARN_TO_CONSOLE ](message);
-            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+    function _logInvalidAccess(logger, message) {
+        if (logger) {
+            logger[_DYN_WARN_TO_CONSOLE ](message);
+            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+        }
+        else {
+            throwInvalidAccess(message);
+        }
+    }
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
+        }
+        return dynamicHandler;
+    }
+    function onConfigChange(config, configHandler, logger) {
+        var handler = config[CFG_HANDLER_LINK] || config;
+        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler[_DYN_WATCH ](configHandler);
+        }
+        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+    }
+
+    var Undefined = strShimUndefined;
+    function newGuid() {
+        var uuid = generateW3CId();
+        return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
+    }
+    function generateW3CId() {
+        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+        var oct = STR_EMPTY$1, 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 ] === 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 ] < 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$1;
+        }
+        if (!value || !isString(value) || value[_DYN_LENGTH ] > 8192) {
+            return null;
+        }
+        if (value[_DYN_INDEX_OF ](",") !== -1) {
+            var values = value[_DYN_SPLIT ](",");
+            value = values[selectIdx > 0 && values[_DYN_LENGTH ] > 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$1)[_DYN_TO_LOWER_CASE ](),
+            traceId: (match[2] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ](),
+            spanId: (match[3] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ](),
+            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 ]), 2)) {
+            return false;
+        }
+        return true;
+    }
+    function isSampledFlag(value) {
+        if (isValidTraceParent(value)) {
+            return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
+        }
+        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());
+        }
+        return STR_EMPTY$1;
+    }
+    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 ] >= 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 ] >= MAX_TRACE_STATE_MEMBERS) {
+                            return -1;
+                        }
+                    }
+                }
+            });
+        }
+        return items;
+    }
+    function _indexOf(items, key) {
+        for (var lp = 0; lp < items[_DYN_LENGTH ]; 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 ] > 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 ] > 0) {
+                isEmpty = true;
+                arrForEach(parent.keys, function (key) {
+                    if (arrIndexOf(delKeys, key) === -1) {
+                        isEmpty = false;
+                        return -1;
+                    }
+                });
+            }
+        }
+        return isEmpty;
+    }
+    function isW3cTraceState(value) {
+        return !!(value && isArray(value.keys) && isFunction(value.get) && isFunction(value.set) && isFunction(value.del) && isFunction(value.hdrs));
+    }
+    function createW3cTraceState(value, parent) {
+        var cachedItems = createDeferredCachedValue(function () { return safe(_parseTraceStateList, [value || STR_EMPTY$1]).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$1;
+            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 ];
+                    if (len + 1 + valLen >= maxLen) {
+                        results[_DYN_PUSH ](result);
+                        if (maxHeaders && results[_DYN_LENGTH ] <= maxHeaders) {
+                            return -1;
+                        }
+                        result = STR_EMPTY$1;
+                        len = 0;
+                    }
+                    if (result[_DYN_LENGTH ] > 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 ] > 0 ? headers[0] : STR_EMPTY$1;
+        }
+        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;
+    }
+    function snapshotW3cTraceState(traceState) {
+        var snapshot = createW3cTraceState(null, null);
+        if (traceState) {
+            var theKeys = traceState.keys;
+            for (var i = theKeys[_DYN_LENGTH ] - 1; i >= 0; i--) {
+                var key = theKeys[i];
+                var value = traceState.get(key);
+                if (!isNullOrUndefined(value) && isString(value)) {
+                    snapshot.set(key, value);
+                }
+            }
+        }
+        return snapshot;
+    }
+    function findW3cTraceState() {
+        var name = "tracestate";
+        var traceState = null;
+        var metaTags = findMetaTags(name);
+        if (metaTags[_DYN_LENGTH ] > 0) {
+            traceState = createW3cTraceState(metaTags.join(","));
         }
-        else {
-            throwInvalidAccess(message);
+        if (!traceState) {
+            var serverTimings = findNamedServerTimings(name);
+            if (serverTimings[_DYN_LENGTH ] > 0) {
+                traceState = createW3cTraceState(serverTimings.join(","));
+            }
         }
+        return traceState;
     }
-    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
-        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
-        if (defaultConfig) {
-            dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
+
+    var _otelTraceState;
+    function _initOTelTraceStateSymbol() {
+        if (!_otelTraceState) {
+            _otelTraceState = createCachedValue(symbolFor("otTraceState"));
+        }
+        return _otelTraceState;
+    }
+    function _createOTelTraceState(traceState) {
+        if (!_otelTraceState) {
+            _otelTraceState = _initOTelTraceStateSymbol();
+        }
+        var otTraceState = {
+            set: function (key, value) {
+                var newState = createW3cTraceState(STR_EMPTY$1, traceState);
+                newState.set(key, value);
+                return _createOTelTraceState(newState);
+            },
+            unset: function (key) {
+                var newState = createW3cTraceState(STR_EMPTY$1, 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 ] > 0) {
+                    return headers[0];
+                }
+                return STR_EMPTY$1;
+            }
+        };
+        objDefine(otTraceState, _otelTraceState.v, { g: function () { return traceState; } });
+        return otTraceState;
+    }
+    function isOTelTraceState(value) {
+        if (!_otelTraceState) {
+            _otelTraceState = _initOTelTraceStateSymbol();
         }
-        return dynamicHandler;
+        if (value && value[_otelTraceState.v]) {
+            return true;
+        }
+        return value && isFunction(value.serialize) && isFunction(value.unset) && isFunction(value.get) && isFunction(value.set);
     }
-    function onConfigChange(config, configHandler, logger) {
-        var handler = config[CFG_HANDLER_LINK] || config;
-        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-            return handler[_DYN_WATCH ](configHandler);
+    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$1, parentTraceState);
+            }
+            else {
+                traceState = createW3cTraceState(value.serialize());
+            }
         }
-        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+        else if (isW3cTraceState(value)) {
+            traceState = value;
+        }
+        else {
+            traceState = createW3cTraceState(isString(value) ? value : STR_EMPTY$1);
+        }
+        return _createOTelTraceState(traceState);
+    }
+
+    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;
+                }
+            }
+        });
     }
 
     function runTargetUnload(target, isAsync) {
@@ -4122,167 +4840,6 @@
         return _defaultPerfManager;
     }
 
-    var Undefined = strShimUndefined;
-    function newGuid() {
-        var uuid = generateW3CId();
-        return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
-    }
-    function generateW3CId() {
-        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY$1, 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 ] === 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 ] < 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;
-        }
-        if (isArray(value)) {
-            value = value[0] || "";
-        }
-        if (!value || !isString(value) || value[_DYN_LENGTH ] > 8192) {
-            return null;
-        }
-        if (value[_DYN_INDEX_OF ](",") !== -1) {
-            var values = value[_DYN_SPLIT ](",");
-            value = values[selectIdx > 0 && values[_DYN_LENGTH ] > selectIdx ? selectIdx : 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$1)[_DYN_TO_LOWER_CASE ](),
-            traceId: (match[2] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ](),
-            spanId: (match[3] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ](),
-            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;
-        }
-        return true;
-    }
-    function isSampledFlag(value) {
-        if (isValidTraceParent(value)) {
-            return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
-        }
-        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());
-        }
-        return "";
-    }
-    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 pluginStateData = createElmNodeData("plugin");
     function _getPluginState(plugin) {
         return pluginStateData.get(plugin, "state", {}, true);
@@ -4356,42 +4913,147 @@
         }
         return _doUnload();
     }
-    function createDistributedTraceContext(parentCtx) {
-        var trace = {};
-        return {
-            getName: function () {
-                return trace[_DYN_NAME ];
+    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$1;
+        var traceFlags = parent ? parent[_DYN_TRACE_FLAGS ] : UNDEFINED_VALUE;
+        var isRemote = parent ? parent.isRemote : false;
+        var pageName = STR_EMPTY$1;
+        var traceState = null;
+        if (parent) {
+            if (isDistributedTraceContext(parent)) {
+                parentCtx = parent;
+                pageName = parentCtx.getName();
+            }
+            else {
+                spanContext = parent;
+            }
+        }
+        if (!pageName) {
+            pageName = "_unknown_";
+            var location_1 = getLocation();
+            if (location_1 && location_1.pathname) {
+                pageName = location_1.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 (spanContext && spanContext[_DYN_TRACE_STATE ]) {
+                    traceState = createW3cTraceState(spanContext[_DYN_TRACE_STATE ].serialize() || STR_EMPTY$1, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
+                }
+                else {
+                    traceState = createW3cTraceState(STR_EMPTY$1, parentCtx ? parentCtx[_DYN_TRACE_STATE ] : undefined);
+                }
+            }
+            return traceState;
+        }
+        var traceCtx = (_a = {
+                getName: _getName,
+                setName: _setPageNameFn(true),
+                getTraceId: _getTraceId,
+                setTraceId: _setTraceIdFn(true),
+                getSpanId: _getSpanId,
+                setSpanId: _setSpanIdFn(true),
+                getTraceFlags: _getTraceFlags
             },
-            setName: function (newValue) {
-                parentCtx && parentCtx.setName(newValue);
-                trace[_DYN_NAME ] = newValue;
+            _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)
             },
-            getTraceId: function () {
-                return trace.traceId;
+            traceId: {
+                g: _getTraceId,
+                s: _setTraceIdFn(false)
             },
-            setTraceId: function (newValue) {
-                parentCtx && parentCtx.setTraceId(newValue);
-                if (isValidTraceId(newValue)) {
-                    trace.traceId = newValue;
-                }
+            spanId: {
+                g: _getSpanId,
+                s: _setSpanIdFn(false)
             },
-            getSpanId: function () {
-                return trace.spanId;
+            traceFlags: {
+                g: _getTraceFlags,
+                s: _setTraceFlagsFn(false)
             },
-            setSpanId: function (newValue) {
-                parentCtx && parentCtx.setSpanId(newValue);
-                if (isValidSpanId(newValue)) {
-                    trace.spanId = newValue;
-                }
+            isRemote: {
+                v: isRemote,
+                w: false
             },
-            getTraceFlags: function () {
-                return trace[_DYN_TRACE_FLAGS ];
+            traceState: {
+                g: _getTraceState
             },
-            setTraceFlags: function (newTraceFlags) {
-                parentCtx && parentCtx.setTraceFlags(newTraceFlags);
-                trace[_DYN_TRACE_FLAGS ] = newTraceFlags;
+            parentCtx: {
+                g: function () { return parentCtx; }
             }
-        };
+        });
     }
 
     var strTelemetryPluginChain = "TelemetryPluginChain";
@@ -4477,27 +5139,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])) {
@@ -5047,6 +5708,7 @@
         _a[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE,
         _a.loggingLevelConsole = 0 ,
         _a.diagnosticLogInterval = UNDEFINED_VALUE,
+        _a.traceHdrMode = 3 ,
         _a));
     function _createPerfManager(core, notificationMgr) {
         return new PerfManager(notificationMgr);
@@ -5166,6 +5828,21 @@
             }
         }, "toJSON", { v: function () { return "aicore::onCfgChange<" + JSON.stringify(unloadHook) + ">"; } });
     }
+    function _getParentTraceCtx(mode) {
+        var spanContext = null;
+        var parentTrace = (mode & 1 ) ? findW3cTraceParent() : null;
+        var parentTraceState = (mode & 2 ) ? findW3cTraceState() : null;
+        if (parentTrace || parentTraceState) {
+            spanContext = createOTelSpanContext({
+                traceId: parentTrace ? parentTrace[_DYN_TRACE_ID ] : null,
+                spanId: parentTrace ? parentTrace[_DYN_SPAN_ID ] : null,
+                traceFlags: parentTrace ? parentTrace[_DYN_TRACE_FLAGS ] : UNDEFINED_VALUE,
+                isRemote: true,
+                traceState: parentTraceState ? createOTelTraceState(parentTraceState) : null
+            });
+        }
+        return spanContext;
+    }
     var AppInsightsCore = /** @class */ (function () {
         function AppInsightsCore() {
             var _configHandler;
@@ -5182,6 +5859,8 @@
             var _channels;
             var _isUnloading;
             var _telemetryInitializerPlugin;
+            var _serverOTelCtx;
+            var _serverTraceHdrMode;
             var _internalLogsEventName;
             var _evtNamespace;
             var _unloadHandlers;
@@ -5228,6 +5907,10 @@
                         objForEachKey(extCfg, function (key) {
                             details.ref(extCfg, key);
                         });
+                        if (rootCfg[_DYN_TRACE_HDR_MODE ] !== _serverTraceHdrMode) {
+                            _serverOTelCtx = _getParentTraceCtx(rootCfg[_DYN_TRACE_HDR_MODE ]);
+                            _serverTraceHdrMode = rootCfg[_DYN_TRACE_HDR_MODE ];
+                        }
                     }));
                     _notificationManager = notificationManager;
                     _debugListener = _initDebugListener(_configHandler, _hookContainer, _notificationManager && _self[_DYN_GET_NOTIFY_MGR ](), _debugListener);
@@ -5595,8 +6278,8 @@
                 };
                 _self.flush = _flushChannels;
                 _self.getTraceCtx = function (createNew) {
-                    if (!_traceCtx) {
-                        _traceCtx = createDistributedTraceContext();
+                    if ((!_traceCtx && createNew !== false) || createNew === true) {
+                        _traceCtx = createDistributedTraceContext(_serverOTelCtx);
                     }
                     return _traceCtx;
                 };
@@ -5691,6 +6374,8 @@
                     cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH ]);
                     arrAppend(cfgExtensions, _extensions);
                     _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
+                    _serverOTelCtx = null;
+                    _serverTraceHdrMode = 0 ;
                     _eventQueue = [];
                     runTargetUnload(_notificationManager, false);
                     _notificationManager = null;
@@ -6796,12 +7481,12 @@
         removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
     }
 
-    var LoggingSeverity = createEnumStyle({
+    var LoggingSeverity = ( /* @__PURE__ */createEnumStyle({
         DISABLED: 0 ,
         CRITICAL: 1 ,
         WARNING: 2 ,
         DEBUG: 3
-    });
+    }));
 
     var aiInstrumentHooks = "_aiHooks";
     var cbNames = [
@@ -7031,6 +7716,7 @@
     exports.createClassFromInterface = createClassFromInterface;
     exports.createCookieMgr = createCookieMgr;
     exports.createCustomDomEvent = createCustomDomEvent;
+    exports.createDistributedTraceContext = createDistributedTraceContext;
     exports.createDynamicConfig = createDynamicConfig;
     exports.createEnumStyle = createEnumStyle;
     exports.createProcessTelemetryContext = createProcessTelemetryContext;
@@ -7039,6 +7725,7 @@
     exports.createUnloadHandlerContainer = createUnloadHandlerContainer;
     exports.createUnloadHookContainer = createUnloadHookContainer;
     exports.createValueMap = createValueMap;
+    exports.createW3cTraceState = createW3cTraceState;
     exports.dateNow = utcNow;
     exports.deepFreeze = objDeepFreeze;
     exports.detachEvent = detachEvent;
@@ -7048,10 +7735,12 @@
     exports.dumpObj = dumpObj;
     exports.eventOff = eventOff;
     exports.eventOn = eventOn;
+    exports.fieldRedaction = fieldRedaction;
     exports.findAllScripts = findAllScripts;
     exports.findMetaTag = findMetaTag;
     exports.findNamedServerTiming = findNamedServerTiming;
     exports.findW3cTraceParent = findW3cTraceParent;
+    exports.findW3cTraceState = findW3cTraceState;
     exports.forceDynamicConversion = forceDynamicConversion;
     exports.formatErrorMessageXdr = formatErrorMessageXdr;
     exports.formatErrorMessageXhr = formatErrorMessageXhr;
@@ -7110,6 +7799,7 @@
     exports.isValidSpanId = isValidSpanId;
     exports.isValidTraceId = isValidTraceId;
     exports.isValidTraceParent = isValidTraceParent;
+    exports.isW3cTraceState = isW3cTraceState;
     exports.isXhrSupported = isXhrSupported;
     exports.mergeEvtNamespace = mergeEvtNamespace;
     exports.mwcRandom32 = mwcRandom32;
@@ -7148,6 +7838,7 @@
     exports.setEnableEnvMocks = setEnableEnvMocks;
     exports.setGblPerfMgr = setGblPerfMgr;
     exports.setValue = setValue;
+    exports.snapshotW3cTraceState = snapshotW3cTraceState;
     exports.sortPlugins = sortPlugins;
     exports.strContains = strContains;
     exports.strEndsWith = strEndsWith;