@microsoft/applicationinsights-web-basic 3.0.0-beta.2210-01 → 3.0.0-beta.2210-02

package/browser/{aib.3.0.0-beta.2210-01.js → aib.3.0.0-beta.2210-02.js}

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.0.0-beta.2210-01
+ * Application Insights JavaScript Web SDK - Basic, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -266,7 +266,6 @@
     var ObjAssign = ObjClass$1["assign"];
     var ObjCreate = ObjClass$1["create"];
     var ObjDefineProperty = ObjClass$1["defineProperty"];
-    var ObjHasOwnProperty = ObjProto$1[strShimHasOwnProperty];
 
     var _cachedGlobal$1 = null;
     function getGlobal$1(useCached) {
@@ -362,13 +361,18 @@
     var STRING = "string";
     var UNDEFINED = "undefined";
     var HAS_OWN_PROPERTY = "hasOwnProperty";
+    var SYMBOL = "Symbol";
+    var POLYFILL_TAG = "_polyfill";
     var INDEX_OF = "indexOf";
     var LENGTH = "length";
+    var DONE = "done";
+    var VALUE = "value";
     var ObjClass = Object;
     var ObjProto = ObjClass[PROTOTYPE];
     var StrCls = String;
     var StrProto = StrCls[PROTOTYPE];
     var ArrCls = Array;
+    var ArrProto = ArrCls[PROTOTYPE];
 
     function _safeCheck(cb, defValue) {
         var result = defValue;
@@ -481,7 +485,7 @@
         return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
     }
 
-    function objForEachKey(theObject, callbackfn, thisArg) {
+    function objForEachKey$1(theObject, callbackfn, thisArg) {
         if (theObject && isObject(theObject)) {
             for (var prop in theObject) {
                 if (objHasOwn(theObject, prop)) {
@@ -523,9 +527,30 @@
         }
         return ObjClass.keys(value);
     }
+    function objDeepCopy(source) {
+        if (isArray(source)) {
+            var result_1 = [];
+            arrForEach(source, function (value) {
+                result_1.push(objDeepCopy(value));
+            });
+            return result_1;
+        }
+        if (isObject(source)) {
+            return objCopyProps({}, source);
+        }
+        return source;
+    }
+    function objCopyProps(target, source) {
+        if (!isNullOrUndefined(source)) {
+            objForEachKey$1(source, function (key, value) {
+                target[key] = objDeepCopy(value);
+            });
+        }
+        return target;
+    }
     function objDeepFreeze(value) {
         if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
+            objForEachKey$1(value, function (key, value) {
                 if (isArray(value) || isObject(value)) {
                     _objFreeze(value);
                 }
@@ -537,7 +562,7 @@
 
     function createEnum(values) {
         var theEnum = {};
-        objForEachKey(values, function (field, value) {
+        objForEachKey$1(values, function (field, value) {
             theEnum[field] = value;
             theEnum[value] = field;
         });
@@ -545,7 +570,7 @@
     }
     function createSimpleMap(values) {
         var mapClass = {};
-        objForEachKey(values, function (field, value) {
+        objForEachKey$1(values, function (field, value) {
             mapClass[field] = value[1];
             mapClass[value[0]] = value[1];
         });
@@ -555,6 +580,65 @@
         return createSimpleMap(values);
     }
 
+    var POLY_GLOBAL_REGISTORT = "__polySymbols$ts_utils";
+    var _polySymbols;
+    function _globalSymbolRegistry() {
+        if (!_polySymbols) {
+            var gbl = getGlobal();
+            _polySymbols = gbl[POLY_GLOBAL_REGISTORT] = gbl[POLY_GLOBAL_REGISTORT] || { k: {}, s: {} };
+        }
+        return _polySymbols;
+    }
+    function polyNewSymbol(description) {
+        var theSymbol = {
+            description: "" + description,
+            toString: function () { return SYMBOL + "(" + description + ")"; }
+        };
+        theSymbol[POLYFILL_TAG] = true;
+        return theSymbol;
+    }
+    function polySymbolFor(key) {
+        var registry = _globalSymbolRegistry();
+        if (!objHasOwn(registry, key)) {
+            var newSymbol = polyNewSymbol(key);
+            registry.k[key] = newSymbol;
+            registry.s[newSymbol] = "" + key;
+        }
+        return registry.k[key];
+    }
+
+    var _hasSymbol = _safeCheck(function () { return isDefined(Symbol); }, false);
+    var _symbol = getInst(SYMBOL);
+    var _symbolFor = _symbol && _safeCheck(function () { return _symbol["for"]; }, null);
+    _symbol && _safeCheck(function () { return _symbol["keyFor"]; }, null);
+    function newSymbol(description, noPoly) {
+        return _hasSymbol ? Symbol(description) : (!noPoly ? polyNewSymbol(description) : null);
+    }
+    var symbolFor = _symbolFor || polySymbolFor;
+
+    function isIterator(value) {
+        return !!value && isFunction(value.next);
+    }
+
+    function arrAppend(target, elms) {
+        if (!isUndefined(elms) && target) {
+            if (isArray(elms)) {
+                ArrProto.push.apply(target, elms);
+            }
+            else if (isIterator(elms)) {
+                var value = elms.next();
+                while (!value[DONE]) {
+                    target.push(value[VALUE]);
+                    value = elms.next();
+                }
+            }
+            else {
+                target.push(elms);
+            }
+        }
+        return target;
+    }
+
     function dumpObj(object, format) {
         var objectTypeDump = objToString(object);
         var propertyValueDump = "";
@@ -600,7 +684,7 @@
                 d.__proto__ = b;
             }) ||
             function (d, b) {
-                objForEachKey(b, function (key, value) {
+                objForEachKey$1(b, function (key, value) {
                     d[key] = value;
                 });
             };
@@ -635,6 +719,20 @@
         throw new _unsupportedError(message);
     }
 
+    function _doExtend(target, theArgs) {
+        arrForEach(theArgs, function (theArg) {
+            objCopyProps(target, theArg);
+        });
+        return target;
+    }
+    function deepExtend(target) {
+        var theArgs = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            theArgs[_i - 1] = arguments[_i];
+        }
+        return _doExtend(objDeepCopy(target) || {}, theArgs);
+    }
+
     var _objDefineProperty$1 = ObjClass["defineProperty"];
     function objDefineProp(target, key, descriptor) {
         if (_objDefineProperty$1) {
@@ -681,6 +779,8 @@
 
     var strIndexOf = _unwrapFunction(INDEX_OF);
 
+    var asString = StrCls;
+
     function _createTrimFn(exp) {
         return function _doTrim(value) {
             if (isNullOrUndefined(value)) {
@@ -700,51 +800,55 @@
     var createEnumStyle = createEnum;
     var createValueMap = createTypeMap;
 
+    var _DYN_LENGTH$2 = "length";
+    var _DYN_NOTIFY = "notify";
+    var _DYN_THROW_INTERNAL = "throwInternal";
+    var _DYN_WATCH = "watch";
+    var _DYN_LOGGER = "logger";
+    var _DYN_CONFIGURABLE = "configurable";
+    var _DYN_ENUMERABLE = "enumerable";
+    var _DYN_APPLY = "apply";
+    var _DYN_INDEX_OF$1 = "indexOf";
+    var _DYN_PUSH$1 = "push";
     var _DYN_INITIALIZE$1 = "initialize";
-    var _DYN_NAME$2 = "name";
-    var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
     var _DYN_IDENTIFIER = "identifier";
-    var _DYN_PUSH$1 = "push";
+    var _DYN_SPLICE = "splice";
     var _DYN_IS_INITIALIZED = "isInitialized";
-    var _DYN_CONFIG = "config";
-    var _DYN_INSTRUMENTATION_KEY$1 = "instrumentationKey";
-    var _DYN_LOGGER = "logger";
-    var _DYN_LENGTH$2 = "length";
+    var _DYN_NAME$2 = "name";
     var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
     var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
     var _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
     var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
     var _DYN_ON_COMPLETE = "onComplete";
+    var _DYN_CALL = "call";
     var _DYN_GET_PLUGIN = "getPlugin";
     var _DYN_FLUSH = "flush";
+    var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
     var _DYN__EXTENSIONS = "_extensions";
-    var _DYN_SPLICE = "splice";
     var _DYN_TEARDOWN = "teardown";
     var _DYN_MESSAGE_ID = "messageId";
     var _DYN_MESSAGE$1 = "message";
     var _DYN_IS_ASYNC = "isAsync";
+    var _DYN_DIAG_LOG$1 = "diagLog";
     var _DYN__DO_TEARDOWN = "_doTeardown";
     var _DYN_UPDATE = "update";
     var _DYN_GET_NEXT = "getNext";
-    var _DYN_DIAG_LOG$1 = "diagLog";
     var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
     var _DYN_CREATE_NEW = "createNew";
-    var _DYN_COOKIE_CFG = "cookieCfg";
-    var _DYN_INDEX_OF$1 = "indexOf";
+    var _DYN_CONFIG = "config";
     var _DYN_SUBSTRING$1 = "substring";
     var _DYN_USER_AGENT = "userAgent";
     var _DYN_SPLIT$1 = "split";
     var _DYN_NODE_TYPE = "nodeType";
-    var _DYN_APPLY = "apply";
     var _DYN_REPLACE = "replace";
-    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_ENABLE_DEBUG_EXCEPTI5 = "enableDebugExceptions";
     var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
     var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
     var _DYN_TYPE = "type";
     var _DYN_HANDLER = "handler";
-    var _DYN_CALL = "call";
     var _DYN_LISTENERS = "listeners";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
     var _DYN_GET_CTX = "getCtx";
@@ -754,6 +858,7 @@
     var _DYN_SPAN_ID = "spanId";
     var _DYN_TRACE_FLAGS = "traceFlags";
 
+    var UNDEFINED_VALUE$1 = undefined;
     var STR_EMPTY = "";
     var STR_CHANNELS = "channels";
     var STR_CORE = "core";
@@ -770,66 +875,19 @@
     var STR_ERROR_TO_CONSOLE = "errorToConsole";
     var STR_WARN_TO_CONSOLE = "warnToConsole";
     var STR_GET_PERF_MGR = "getPerfMgr";
+    var STR_DOMAIN = "domain";
+    var STR_PATH = "path";
+    var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
 
-    var listenerFuncs = ["eventsSent", "eventsDiscarded", "eventsSendRequest", "perfEvent"];
-    var _aiNamespace = null;
-    var _debugListener;
-    function _listenerProxyFunc(name, config) {
-        return function () {
-            var args = arguments;
-            var dbgExt = getDebugExt(config);
-            if (dbgExt) {
-                var listener = dbgExt.listener;
-                if (listener && listener[name]) {
-                    listener[name][_DYN_APPLY ](listener, args);
-                }
-            }
-        };
-    }
-    function _getExtensionNamespace() {
-        var target = getInst("Microsoft");
-        if (target) {
-            _aiNamespace = target["ApplicationInsights"];
-        }
-        return _aiNamespace;
-    }
-    function getDebugExt(config) {
-        var ns = _aiNamespace;
-        if (!ns && config.disableDbgExt !== true) {
-            ns = _aiNamespace || _getExtensionNamespace();
-        }
-        return ns ? ns["ChromeDbgExt"] : null;
-    }
-    function getDebugListener(config) {
-        if (!_debugListener) {
-            _debugListener = {};
-            for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH$2 ]; lp++) {
-                _debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
-            }
-        }
-        return _debugListener;
-    }
-
-    var cString = "String";
-    var cObject = "Object";
-    var strToISOString = "toISOString";
     var strToString = "toString";
     var strGetPrototypeOf = "getPrototypeOf";
     var strConstructor = "constructor";
-    var DateProto = Date[strShimPrototype];
-    var _dateToISOString = DateProto[strToISOString] || _polyfillRequired("Date", strToISOString);
-    ObjProto$1[strToString] || _polyfillRequired(cObject, strToString);
-    var _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
+    var _fnToString = ObjClass$1[strToString];
     var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass$1);
     var rCamelCase = /-([a-z])/g;
     var rNormalizeInvalid = /([^\w\d_$])/g;
     var rLeadingNumeric = /^(\d+[\w\d_$])/;
-    function _polyfillRequired(object, name) {
-        return function () {
-            throwUnsupported("Polyfill required for [" + name + "]");
-        };
-    }
-    var _getObjProto = Object[strGetPrototypeOf] || _polyfillRequired(cObject, strGetPrototypeOf);
+    var _getObjProto = Object[strGetPrototypeOf];
     function isNotNullOrUndefined(value) {
         return !isNullOrUndefined(value);
     }
@@ -846,6 +904,7 @@
         }
         return value;
     }
+    var objForEachKey = objForEachKey$1;
     function strContains(value, search) {
         if (value && search) {
             return strIndexOf(value, search) !== -1;
@@ -860,7 +919,7 @@
                 result = true;
             }
             else {
-                if (proto[strConstructor] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor)) {
+                if (proto[strConstructor] && objHasOwnProperty(proto, strConstructor)) {
                     proto = proto[strConstructor];
                 }
                 result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
@@ -869,7 +928,7 @@
         return result;
     }
     function toISOString(date) {
-        return _dateToISOString[_DYN_CALL ](date);
+        return date && date.toISOString() || "";
     }
     function dateNow() {
         var dt = Date;
@@ -906,9 +965,6 @@
         }
         return theValue;
     }
-    function getCfgValue(theValue, defaultValue) {
-        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-    }
     function _createProxyFunction(source, funcName) {
         var srcFunc = null;
         var src = null;
@@ -983,7 +1039,7 @@
             var isArgArray = isArray(arg);
             var isArgObj = isObject(arg);
             for (var prop in arg) {
-                var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty[_DYN_CALL ](arg, prop)));
+                var propOk = (isArgArray && (prop in arg)) || (isArgObj && objHasOwn(arg, prop));
                 if (!propOk) {
                     continue;
                 }
@@ -1009,6 +1065,122 @@
         return extended;
     }
 
+    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+    function _cfgDeepCopy(source) {
+        if (source) {
+            if (isArray(source)) {
+                var result_1 = [];
+                result_1[_DYN_LENGTH$2 ] = source[_DYN_LENGTH$2 ];
+                arrForEach(source, function (value, idx) {
+                    result_1[idx] = _cfgDeepCopy(value);
+                });
+                return result_1;
+            }
+            if (isPlainObject(source)) {
+                var target_1 = {};
+                objForEachKey$1(source, function (key, value) {
+                    target_1[key] = _cfgDeepCopy(value);
+                });
+                return target_1;
+            }
+        }
+        return source;
+    }
+    function getDynamicConfigHandler(value) {
+        if (value) {
+            var handler = value[CFG_HANDLER_LINK] || value;
+            if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+                return handler;
+            }
+        }
+        return null;
+    }
+    function throwInvalidAccess(message) {
+        throwTypeError("InvalidAccess:" + message);
+    }
+
+    function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+        var defValue;
+        var isDefaultValid = cfgDefaults.dfVal || isDefined;
+        if (theConfig && cfgDefaults.fb) {
+            var fallbacks = cfgDefaults.fb;
+            if (!isArray(fallbacks)) {
+                fallbacks = [fallbacks];
+            }
+            for (var lp = 0; lp < fallbacks[_DYN_LENGTH$2 ]; lp++) {
+                var fallback = fallbacks[lp];
+                var fbValue = theConfig[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                else {
+                    fbValue = dynamicHandler.cfg[fallback];
+                    if (isDefaultValid(fbValue)) {
+                        defValue = fbValue;
+                    }
+                    dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+                }
+                if (isDefaultValid(defValue)) {
+                    break;
+                }
+            }
+        }
+        if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+            defValue = cfgDefaults.v;
+        }
+        return defValue;
+    }
+    function _applyDefaultValue(theConfig, name, defaultValue) {
+        var dynamicHandler = theConfig[CFG_HANDLER_LINK];
+        if (!dynamicHandler) {
+            throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
+        }
+        var isValid;
+        var setFn;
+        var defValue;
+        var cfgDefaults = defaultValue;
+        if (cfgDefaults && isObject(cfgDefaults) && (cfgDefaults.isVal || cfgDefaults.set || cfgDefaults.fb || objHasOwn(cfgDefaults, "v"))) {
+            isValid = cfgDefaults.isVal;
+            setFn = cfgDefaults.set;
+            defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+        }
+        else {
+            defValue = defaultValue;
+        }
+        var theValue = defValue;
+        var usingDefault = true;
+        var cfgValue = theConfig[name];
+        if (cfgValue || !isNullOrUndefined(cfgValue)) {
+            theValue = cfgValue;
+            usingDefault = false;
+        }
+        if (!usingDefault) {
+            if (isValid && theValue !== defValue && !isValid(theValue)) {
+                theValue = defValue;
+                usingDefault = true;
+            }
+            if (setFn) {
+                theValue = setFn(theValue, defValue, theConfig);
+                usingDefault = theValue === defValue;
+            }
+        }
+        if (theValue && usingDefault && (isPlainObject(theValue) || isArray(theValue))) {
+            theValue = _cfgDeepCopy(theValue);
+        }
+        dynamicHandler.set(theConfig, name, theValue);
+    }
+    function applyDefaults(theConfig, defaultValues) {
+        if (defaultValues) {
+            if (theConfig && !theConfig[CFG_HANDLER_LINK] && (isPlainObject(theConfig) || isArray(theConfig))) {
+                throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
+            }
+            objForEachKey(defaultValues, function (name, value) {
+                _applyDefaultValue(theConfig, name, value);
+            });
+        }
+        return theConfig;
+    }
+
     var strDocumentMode = "documentMode";
     var strLocation = "location";
     var strConsole = "console";
@@ -1124,33 +1296,494 @@
                 isSupported = _hasProperty(request, "keepalive");
             }
         }
-        catch (e) {
+        catch (e) {
+        }
+        return isSupported;
+    }
+    function useXDomainRequest() {
+        if (_useXDomainRequest === null) {
+            _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
+            if (_useXDomainRequest && isXhrSupported()) {
+                _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
+            }
+        }
+        return _useXDomainRequest;
+    }
+    function isXhrSupported() {
+        var isSupported = false;
+        try {
+            var xmlHttpRequest = getInst(strXMLHttpRequest);
+            isSupported = !!xmlHttpRequest;
+        }
+        catch (e) {
+        }
+        return isSupported;
+    }
+
+    var UInt32Mask = 0x100000000;
+    var MaxUInt32 = 0xffffffff;
+    var _mwcSeeded = false;
+    var _mwcW = 123456789;
+    var _mwcZ = 987654321;
+    function _mwcSeed(seedValue) {
+        if (seedValue < 0) {
+            seedValue >>>= 0;
+        }
+        _mwcW = (123456789 + seedValue) & MaxUInt32;
+        _mwcZ = (987654321 - seedValue) & MaxUInt32;
+        _mwcSeeded = true;
+    }
+    function _autoSeedMwc() {
+        try {
+            var now = dateNow() & 0x7fffffff;
+            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+        }
+        catch (e) {
+        }
+    }
+    function random32(signed) {
+        var value = 0;
+        var c = getCrypto() || getMsCrypto();
+        if (c && c.getRandomValues) {
+            value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
+        }
+        if (value === 0 && isIE()) {
+            if (!_mwcSeeded) {
+                _autoSeedMwc();
+            }
+            value = mwcRandom32() & MaxUInt32;
+        }
+        if (value === 0) {
+            value = Math.floor((UInt32Mask * Math.random()) | 0);
+        }
+        if (!signed) {
+            value >>>= 0;
+        }
+        return value;
+    }
+    function mwcRandom32(signed) {
+        _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
+        _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
+        var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
+        if (!signed) {
+            value >>>= 0;
+        }
+        return value;
+    }
+    function newId(maxLength) {
+        if (maxLength === void 0) { maxLength = 22; }
+        var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var number = random32() >>> 0;
+        var chars = 0;
+        var result = STR_EMPTY;
+        while (result[_DYN_LENGTH$2 ] < maxLength) {
+            chars++;
+            result += base64chars.charAt(number & 0x3F);
+            number >>>= 6;
+            if (chars === 5) {
+                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+                chars = 0;
+            }
+        }
+        return result;
+    }
+
+    var _objDefineProperty = ObjDefineProperty;
+    var version = "3.0.0-beta.2210-02";
+    var instanceName = "." + newId(6);
+    var _dataUid = 0;
+    function _createAccessor(target, prop, value) {
+        var _a;
+        if (_objDefineProperty) {
+            try {
+                _objDefineProperty(target, prop, (_a = {
+                        value: value
+                    },
+                    _a[_DYN_ENUMERABLE ] = false,
+                    _a[_DYN_CONFIGURABLE ] = true,
+                    _a));
+                return true;
+            }
+            catch (e) {
+            }
+        }
+        return false;
+    }
+    function _canAcceptData(target) {
+        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
+    }
+    function _getCache(data, target) {
+        var theCache = target[data.id];
+        if (!theCache) {
+            theCache = {};
+            try {
+                if (_canAcceptData(target)) {
+                    if (!_createAccessor(target, data.id, theCache)) {
+                        target[data.id] = theCache;
+                    }
+                }
+            }
+            catch (e) {
+            }
+        }
+        return theCache;
+    }
+    function createUniqueNamespace(name, includeVersion) {
+        if (includeVersion === void 0) { includeVersion = false; }
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+    }
+    function createElmNodeData(name) {
+        var data = {
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+            accept: function (target) {
+                return _canAcceptData(target);
+            },
+            get: function (target, name, defValue, addDefault) {
+                var theCache = target[data.id];
+                if (!theCache) {
+                    if (addDefault) {
+                        theCache = _getCache(data, target);
+                        theCache[normalizeJsName(name)] = defValue;
+                    }
+                    return defValue;
+                }
+                return theCache[normalizeJsName(name)];
+            },
+            kill: function (target, name) {
+                if (target && target[name]) {
+                    try {
+                        delete target[name];
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        };
+        return data;
+    }
+
+    var arrayMethodsToPatch = [
+        "push",
+        "pop",
+        "shift",
+        "unshift",
+        "splice"
+    ];
+    function _patchArray(state, target) {
+        if (isArray(target)) {
+            arrForEach(arrayMethodsToPatch, function (method) {
+                var orgMethod = target[method];
+                target[method] = function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    var result = orgMethod[_DYN_APPLY ](this, args);
+                    _makeDynamicObject(state, target);
+                    return result;
+                };
+            });
+        }
+    }
+    function _makeDynamicProperty(state, theConfig, name, value) {
+        var detail = {
+            n: name,
+            h: [],
+            add: function (handler) {
+                if (handler && handler.fn && detail.h[_DYN_INDEX_OF$1 ](handler) === -1) {
+                    detail.h[_DYN_PUSH$1 ](handler);
+                }
+            }
+        };
+        var checkDynamic = true;
+        function _getProperty() {
+            if (checkDynamic) {
+                if (value && !value[CFG_HANDLER_LINK] && (isPlainObject(value) || isArray(value))) {
+                    value = _makeDynamicObject(state, value);
+                }
+                checkDynamic = false;
+            }
+            var activeHandler = state.act;
+            if (activeHandler) {
+                detail.add(activeHandler);
+            }
+            return value;
+        }
+        _getProperty[state.prop] = true;
+        function _setProperty(newValue) {
+            if (value !== newValue) {
+                if (!!_setProperty[state.ro] && state.upd) {
+                    throwInvalidAccess("[" + name + "] is sealed from " + dumpObj(theConfig));
+                }
+                if (value && value[CFG_HANDLER_LINK]) {
+                    if (isPlainObject(value)) {
+                        objForEachKey$1(value, function (key) {
+                            value[key] = UNDEFINED_VALUE$1;
+                        });
+                    }
+                    else if (isArray(value)) {
+                        arrForEach(value, function (propValue, idx) {
+                            value[idx] = UNDEFINED_VALUE$1;
+                        });
+                    }
+                }
+                checkDynamic = false;
+                if (isPlainObject(newValue) || isArray(newValue)) {
+                    _makeDynamicObject(state, newValue);
+                }
+                value = newValue;
+                state.add(detail);
+            }
+        }
+        objDefineAccessors(theConfig, detail.n, _getProperty, _setProperty, true);
+    }
+    function _setDynamicProperty(state, target, name, value) {
+        if (target) {
+            var isDynamic = false;
+            var propDesc = objGetOwnPropertyDescriptor(target, name);
+            if (propDesc && propDesc.get) {
+                isDynamic = !!propDesc.get[state.prop];
+            }
+            if (!isDynamic) {
+                _makeDynamicProperty(state, target, name, value);
+            }
+            else {
+                target[name] = value;
+            }
+        }
+        return value;
+    }
+    function _makeDynamicObject(state, target ) {
+        var _a;
+        objForEachKey$1( target, function (key, value) {
+            _setDynamicProperty(state, target, key, value);
+        });
+        if (!target[CFG_HANDLER_LINK]) {
+            objDefineProp(target, CFG_HANDLER_LINK, (_a = {},
+                _a[_DYN_CONFIGURABLE ] = false,
+                _a[_DYN_ENUMERABLE ] = false,
+                _a.get = function () {
+                    return state.hdlr;
+                },
+                _a));
+            _patchArray(state, target);
+        }
+        return target;
+    }
+
+    var symPrefix = "[[ai_";
+    var symPostfix = "]]";
+    function _insertWatcher(watchers, theDetail) {
+        if (theDetail && theDetail.h && theDetail.h[_DYN_LENGTH$2 ] > 0) {
+            arrForEach(theDetail.h, function (handler) {
+                if (handler && handler.fn && watchers[_DYN_INDEX_OF$1 ](handler) === -1) {
+                    watchers[_DYN_PUSH$1 ](handler);
+                }
+            });
+        }
+    }
+    function _createState(cfgHandler) {
+        var _a;
+        var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
+        var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
+        var _waitingHandlers = null;
+        var _watcherTimer = null;
+        var theState;
+        function _useHandler(activeHandler, callback) {
+            var prevWatcher = theState.act;
+            try {
+                theState.act = activeHandler;
+                callback({
+                    cfg: cfgHandler.cfg,
+                    hdlr: cfgHandler
+                });
+            }
+            catch (e) {
+                var message = "Watcher [" + dumpObj(callback) + "] failed [" + dumpObj(e) + "]";
+                var logger = cfgHandler[_DYN_LOGGER ];
+                if (logger) {
+                    cfgHandler.logger[_DYN_THROW_INTERNAL ](1 , 107 , message);
+                }
+                else {
+                    throwInvalidAccess(message);
+                }
+            }
+            finally {
+                theState.act = prevWatcher || null;
+            }
+        }
+        function _notifyWatchers() {
+            if (_waitingHandlers) {
+                var notifyHandlers = _waitingHandlers;
+                _waitingHandlers = null;
+                if (_watcherTimer) {
+                    clearTimeout(_watcherTimer);
+                    _watcherTimer = null;
+                }
+                arrForEach(notifyHandlers, function (handler) {
+                    if (handler.fn) {
+                        _useHandler(handler, handler.fn);
+                    }
+                });
+                if (_waitingHandlers) {
+                    _notifyWatchers();
+                }
+            }
+        }
+        function _addWatcher(detail) {
+            if (detail && detail.h[_DYN_LENGTH$2 ] > 0) {
+                if (!_waitingHandlers) {
+                    _waitingHandlers = [];
+                }
+                if (!_watcherTimer) {
+                    _watcherTimer = setTimeout(function () {
+                        _watcherTimer = null;
+                        _notifyWatchers();
+                    }, 0);
+                }
+                _insertWatcher(_waitingHandlers, detail);
+            }
+        }
+        theState = (_a = {
+                prop: dynamicPropertySymbol,
+                ro: dynamicPropertyReadOnly,
+                hdlr: cfgHandler,
+                add: _addWatcher
+            },
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.use = _useHandler,
+            _a);
+        return theState;
+    }
+
+    function _createAndUseHandler(state, configHandler) {
+        var handler = {
+            fn: configHandler,
+            rm: function () {
+                handler.fn = null;
+                state = null;
+                configHandler = null;
+            }
+        };
+        state.use(handler, configHandler);
+        return handler;
+    }
+    function _createDynamicHandler(logger, target, inPlace) {
+        var _a, _b;
+        var dynamicConfig = getDynamicConfigHandler(target);
+        if (dynamicConfig) {
+            return dynamicConfig;
+        }
+        var uid = createUniqueNamespace("dyncfg", true);
+        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+        var theState;
+        function _notifyWatchers() {
+            theState[_DYN_NOTIFY ]();
+        }
+        function _setValue(target, name, value) {
+            return _setDynamicProperty(theState, target, name, value);
+        }
+        function _watch(configHandler) {
+            return _createAndUseHandler(theState, configHandler);
+        }
+        function _block(configHandler) {
+            theState.use(null, configHandler);
+        }
+        var cfgHandler = (_a = {
+                uid: null,
+                cfg: newTarget
+            },
+            _a[_DYN_LOGGER ] = logger,
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.set = _setValue,
+            _a[_DYN_WATCH ] = _watch,
+            _a._block = _block,
+            _a);
+        objDefineProp(cfgHandler, "uid", (_b = {},
+            _b[_DYN_CONFIGURABLE ] = false,
+            _b[_DYN_ENUMERABLE ] = false,
+            _b.writable = false,
+            _b.value = uid,
+            _b));
+        theState = _createState(cfgHandler);
+        _makeDynamicObject(theState, newTarget);
+        return cfgHandler;
+    }
+    function _logInvalidAccess(logger, message) {
+        if (logger) {
+            logger[STR_WARN_TO_CONSOLE ](message);
+            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+        }
+        else {
+            throwInvalidAccess(message);
         }
-        return isSupported;
     }
-    function useXDomainRequest() {
-        if (_useXDomainRequest === null) {
-            _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
-            if (_useXDomainRequest && isXhrSupported()) {
-                _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamic = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            applyDefaults(dynamic.cfg, defaultConfig);
+        }
+        return dynamic;
+    }
+    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));
+        createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+    }
+
+    var listenerFuncs = ["eventsSent", "eventsDiscarded", "eventsSendRequest", "perfEvent"];
+    var _aiNamespace = null;
+    var _debugListener;
+    function _listenerProxyFunc(name, config) {
+        return function () {
+            var args = arguments;
+            var dbgExt = getDebugExt(config);
+            if (dbgExt) {
+                var listener = dbgExt.listener;
+                if (listener && listener[name]) {
+                    listener[name][_DYN_APPLY ](listener, args);
+                }
             }
+        };
+    }
+    function _getExtensionNamespace() {
+        var target = getInst("Microsoft");
+        if (target) {
+            _aiNamespace = target["ApplicationInsights"];
         }
-        return _useXDomainRequest;
+        return _aiNamespace;
     }
-    function isXhrSupported() {
-        var isSupported = false;
-        try {
-            var xmlHttpRequest = getInst(strXMLHttpRequest);
-            isSupported = !!xmlHttpRequest;
+    function getDebugExt(config) {
+        var ns = _aiNamespace;
+        if (!ns && config.disableDbgExt !== true) {
+            ns = _aiNamespace || _getExtensionNamespace();
         }
-        catch (e) {
+        return ns ? ns["ChromeDbgExt"] : null;
+    }
+    function getDebugListener(config) {
+        if (!_debugListener) {
+            _debugListener = {};
+            for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH$2 ]; lp++) {
+                _debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
+            }
         }
-        return isSupported;
+        return _debugListener;
     }
 
+    var _a$4;
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
+    var defaultValues$2 = (_a$4 = {
+            loggingLevelConsole: 0,
+            loggingLevelTelemetry: 1,
+            maxMessageLimit: 25
+        },
+        _a$4[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = false,
+        _a$4);
     function _sanitizeDiagnosticText(text) {
         if (text) {
             return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
@@ -1206,8 +1839,8 @@
                 _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
                 _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
                 _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
-                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
-                _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
+                _self[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = function () { return _enableDebugExceptions; };
+                _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
                     var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
                     if (_enableDebugExceptions) {
@@ -1280,10 +1913,14 @@
                     }
                 }
                 function _setDefaultsFromConfig(config) {
-                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
-                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
-                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
-                    _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
+                    var handler = createDynamicConfig(config, defaultValues$2, _self);
+                    handler[_DYN_WATCH ](function (details) {
+                        var config = details.cfg;
+                        _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                        _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                        _maxInternalMessageLimit = config.maxMessageLimit;
+                        _enableDebugExceptions = config[_DYN_ENABLE_DEBUG_EXCEPTI5 ];
+                    });
                 }
                 function _areInternalMessagesThrottled() {
                     return _messageCount >= _maxInternalMessageLimit;
@@ -1304,7 +1941,7 @@
     }
     function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
         if (isUserAct === void 0) { isUserAct = false; }
-        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
+        _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
     }
     function _warnToConsole(logger, message) {
         _getLogger(logger)[STR_WARN_TO_CONSOLE ](message);
@@ -1453,151 +2090,11 @@
         return _defaultPerfManager;
     }
 
-    var UInt32Mask = 0x100000000;
-    var MaxUInt32 = 0xffffffff;
-    var _mwcSeeded = false;
-    var _mwcW = 123456789;
-    var _mwcZ = 987654321;
-    function _mwcSeed(seedValue) {
-        if (seedValue < 0) {
-            seedValue >>>= 0;
-        }
-        _mwcW = (123456789 + seedValue) & MaxUInt32;
-        _mwcZ = (987654321 - seedValue) & MaxUInt32;
-        _mwcSeeded = true;
-    }
-    function _autoSeedMwc() {
-        try {
-            var now = dateNow() & 0x7fffffff;
-            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
-        }
-        catch (e) {
-        }
-    }
-    function random32(signed) {
-        var value = 0;
-        var c = getCrypto() || getMsCrypto();
-        if (c && c.getRandomValues) {
-            value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
-        }
-        if (value === 0 && isIE()) {
-            if (!_mwcSeeded) {
-                _autoSeedMwc();
-            }
-            value = mwcRandom32() & MaxUInt32;
-        }
-        if (value === 0) {
-            value = Math.floor((UInt32Mask * Math.random()) | 0);
-        }
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function mwcRandom32(signed) {
-        _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
-        _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
-        var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function newId(maxLength) {
-        if (maxLength === void 0) { maxLength = 22; }
-        var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        var number = random32() >>> 0;
-        var chars = 0;
-        var result = STR_EMPTY;
-        while (result[_DYN_LENGTH$2 ] < maxLength) {
-            chars++;
-            result += base64chars.charAt(number & 0x3F);
-            number >>>= 6;
-            if (chars === 5) {
-                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-                chars = 0;
-            }
-        }
-        return result;
-    }
-
-    var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2210-01";
-    var instanceName = "." + newId(6);
-    var _dataUid = 0;
-    function _createAccessor(target, prop, value) {
-        if (_objDefineProperty) {
-            try {
-                _objDefineProperty(target, prop, {
-                    value: value,
-                    enumerable: false,
-                    configurable: true
-                });
-                return true;
-            }
-            catch (e) {
-            }
-        }
-        return false;
-    }
-    function _canAcceptData(target) {
-        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
-    }
-    function _getCache(data, target) {
-        var theCache = target[data.id];
-        if (!theCache) {
-            theCache = {};
-            try {
-                if (_canAcceptData(target)) {
-                    if (!_createAccessor(target, data.id, theCache)) {
-                        target[data.id] = theCache;
-                    }
-                }
-            }
-            catch (e) {
-            }
-        }
-        return theCache;
-    }
-    function createUniqueNamespace(name, includeVersion) {
-        if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
-    }
-    function createElmNodeData(name) {
-        var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
-            accept: function (target) {
-                return _canAcceptData(target);
-            },
-            get: function (target, name, defValue, addDefault) {
-                var theCache = target[data.id];
-                if (!theCache) {
-                    if (addDefault) {
-                        theCache = _getCache(data, target);
-                        theCache[normalizeJsName(name)] = defValue;
-                    }
-                    return defValue;
-                }
-                return theCache[normalizeJsName(name)];
-            },
-            kill: function (target, name) {
-                if (target && target[name]) {
-                    try {
-                        delete target[name];
-                    }
-                    catch (e) {
-                    }
-                }
-            }
-        };
-        return data;
-    }
-
     var INVALID_TRACE_ID = "00000000000000000000000000000000";
     var INVALID_SPAN_ID = "0000000000000000";
     function _isValid(value, len, invalidValue) {
         if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/);
+            return !!value.match(/^[\da-f]*$/i);
         }
         return false;
     }
@@ -1620,9 +2117,7 @@
         while (proxy) {
             var thePlugin = proxy[_DYN_GET_PLUGIN ]();
             if (thePlugin) {
-                if (lastPlugin &&
-                    isFunction(lastPlugin[_DYN_SET_NEXT_PLUGIN ]) &&
-                    isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
+                if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN ] && thePlugin[STR_PROCESS_TELEMETRY ]) {
                     lastPlugin[_DYN_SET_NEXT_PLUGIN ](thePlugin);
                 }
                 var isInitialized = false;
@@ -1641,7 +2136,7 @@
             }
         }
         arrForEach(initPlugins, function (thePlugin) {
-            var core = processContext[STR_CORE]();
+            var core = processContext[STR_CORE ]();
             thePlugin[_DYN_INITIALIZE$1 ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
             pluginState = _getPluginState(thePlugin);
             if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
@@ -1655,8 +2150,8 @@
         return plugins.sort(function (extA, extB) {
             var result = 0;
             if (extB) {
-                var bHasProcess = isFunction(extB[STR_PROCESS_TELEMETRY]);
-                if (isFunction(extA[STR_PROCESS_TELEMETRY])) {
+                var bHasProcess = extB[STR_PROCESS_TELEMETRY];
+                if (extA[STR_PROCESS_TELEMETRY]) {
                     result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;
                 }
                 else if (bHasProcess) {
@@ -1720,9 +2215,12 @@
         }
         return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
     }
-    function _createInternalContext(telemetryChain, config, core, startAt) {
+    function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
         var _nextProxy = null;
         var _onComplete = [];
+        if (!dynamicConfig) {
+            dynamicConfig = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
+        }
         if (startAt !== null) {
             _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
         }
@@ -1733,12 +2231,12 @@
                     return core;
                 },
                 diagLog: function () {
-                    return safeGetLogger(core, config);
+                    return safeGetLogger(core, dynamicConfig.cfg);
                 },
                 getCfg: function () {
-                    return config;
+                    return dynamicConfig.cfg;
                 },
-                getExtCfg: _getExtCfg,
+                getExtCfg: _resolveExtCfg,
                 getConfig: _getConfig,
                 hasNext: function () {
                     return !!_nextProxy;
@@ -1785,48 +2283,51 @@
             }
             return nextProxy;
         }
-        function _getExtCfg(identifier, defaultValue, mergeDefault) {
-            if (defaultValue === void 0) { defaultValue = {}; }
-            if (mergeDefault === void 0) { mergeDefault = 0 ; }
-            var theConfig;
-            if (config) {
-                var extConfig = config[STR_EXTENSION_CONFIG ];
-                if (extConfig && identifier) {
-                    theConfig = extConfig[identifier];
-                }
-            }
-            if (!theConfig) {
-                theConfig = defaultValue;
-            }
-            else if (isObject(defaultValue)) {
-                if (mergeDefault !== 0 ) {
-                    var newConfig_1 = objExtend(true, defaultValue, theConfig);
-                    if (config && mergeDefault === 2 ) {
-                        objForEachKey(defaultValue, function (field) {
-                            if (isNullOrUndefined(newConfig_1[field])) {
-                                var cfgValue = config[field];
-                                if (!isNullOrUndefined(cfgValue)) {
-                                    newConfig_1[field] = cfgValue;
-                                }
-                            }
-                        });
+        function _getExtCfg(identifier, createIfMissing) {
+            var idCfg = null;
+            if (dynamicConfig.cfg && identifier) {
+                var extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+                if (!extCfg && createIfMissing) {
+                    dynamicConfig.set(dynamicConfig.cfg, "extensionConfig", {});
+                    extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+                }
+                if (extCfg) {
+                    idCfg = extCfg[identifier];
+                    if (!idCfg && createIfMissing) {
+                        dynamicConfig.set(extCfg, identifier, {});
+                        idCfg = extCfg[identifier];
                     }
-                    theConfig = newConfig_1;
                 }
             }
-            return theConfig;
+            return idCfg;
+        }
+        function _resolveExtCfg(identifier, defaultValues) {
+            var newConfig = _getExtCfg(identifier, true);
+            if (defaultValues) {
+                objForEachKey(defaultValues, function (field, defaultValue) {
+                    if (isNullOrUndefined(newConfig[field])) {
+                        var cfgValue = dynamicConfig.cfg[field];
+                        if (cfgValue || !isNullOrUndefined(cfgValue)) {
+                            newConfig[field] = cfgValue;
+                        }
+                    }
+                    _applyDefaultValue(newConfig, field, defaultValue);
+                });
+            }
+            return applyDefaults(newConfig, defaultValues);
         }
         function _getConfig(identifier, field, defaultValue) {
             if (defaultValue === void 0) { defaultValue = false; }
             var theValue;
-            var extConfig = _getExtCfg(identifier, null);
-            if (extConfig && !isNullOrUndefined(extConfig[field])) {
+            var extConfig = _getExtCfg(identifier, false);
+            var rootConfig = dynamicConfig.cfg;
+            if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
                 theValue = extConfig[field];
             }
-            else if (config && !isNullOrUndefined(config[field])) {
-                theValue = config[field];
+            else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
+                theValue = rootConfig[field];
             }
-            return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+            return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
         }
         function _iterateChain(cb) {
             var nextPlugin;
@@ -1839,27 +2340,30 @@
         }
         return context;
     }
-    function createProcessTelemetryContext(telemetryChain, config, core, startAt) {
+    function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
+        var config = createDynamicConfig(cfg);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(env) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+            if (nextPlugin) {
+                nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+            }
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
             if (plugins === void 0) { plugins = null; }
             if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
-            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config, core, startAt);
+            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
         }
         context[_DYN_PROCESS_NEXT ] = _processNext;
         context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = core[_DYN_CONFIG ] || {};
+        var config = createDynamicConfig(core[_DYN_CONFIG ]);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(unloadState) {
@@ -1870,7 +2374,7 @@
         function _createNew(plugins, startAt) {
             if (plugins === void 0) { plugins = null; }
             if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
             return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
@@ -1879,7 +2383,7 @@
         return context;
     }
     function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = core[_DYN_CONFIG ] || {};
+        var config = createDynamicConfig(core[_DYN_CONFIG ]);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(updateState) {
@@ -1892,7 +2396,7 @@
         function _createNew(plugins, startAt) {
             if (plugins === void 0) { plugins = null; }
             if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
             return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
@@ -2251,11 +2755,11 @@
         return channelQueue;
     }
 
+    var _a$3, _b$1;
     var strToGMTString = "toGMTString";
     var strToUTCString = "toUTCString";
     var strCookie = "cookie";
     var strExpires = "expires";
-    var strEnabled = "enabled";
     var strIsCookieUseDisabled = "isCookieUseDisabled";
     var strDisableCookiesUsage = "disableCookiesUsage";
     var strConfigCookieMgr = "_ckMgr";
@@ -2265,28 +2769,24 @@
     var _doc = getDocument();
     var _cookieCache = {};
     var _globalCookieConfig = {};
+    var defaultConfig$1 = objDeepFreeze((_a$3 = {},
+        _a$3[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+        _a$3.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+        _a$3.enabled = UNDEFINED_VALUE$1,
+        _a$3));
+    var rootDefaultConfig = (_b$1 = {
+            cookieCfg: {},
+            cookieDomain: UNDEFINED_VALUE$1,
+            cookiePath: UNDEFINED_VALUE$1
+        },
+        _b$1[strDisableCookiesUsage] = UNDEFINED_VALUE$1,
+        _b$1);
     function _isMgrEnabled(cookieMgr) {
         if (cookieMgr) {
             return cookieMgr.isEnabled();
         }
         return true;
     }
-    function _createCookieMgrConfig(rootConfig) {
-        var cookieMgrCfg = rootConfig[_DYN_COOKIE_CFG ] = rootConfig[_DYN_COOKIE_CFG ] || {};
-        setValue(cookieMgrCfg, "domain", rootConfig.cookieDomain, isNotNullOrUndefined, isNullOrUndefined);
-        setValue(cookieMgrCfg, "path", rootConfig.cookiePath || "/", null, isNullOrUndefined);
-        if (isNullOrUndefined(cookieMgrCfg[strEnabled])) {
-            var cookieEnabled = void 0;
-            if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
-                cookieEnabled = !rootConfig[strIsCookieUseDisabled];
-            }
-            if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
-                cookieEnabled = !rootConfig[strDisableCookiesUsage];
-            }
-            cookieMgrCfg[strEnabled] = cookieEnabled;
-        }
-        return cookieMgrCfg;
-    }
     function _isIgnoredCookie(cookieMgrCfg, name) {
         if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
             return cookieMgrCfg.ignoreCookies[_DYN_INDEX_OF$1 ](name) !== -1;
@@ -2302,10 +2802,35 @@
         return _isIgnoredCookie(cookieMgrCfg, name);
     }
     function createCookieMgr(rootConfig, logger) {
-        var cookieMgrConfig = _createCookieMgrConfig(rootConfig || _globalCookieConfig);
-        var _path = cookieMgrConfig.path || "/";
-        var _domain = cookieMgrConfig.domain;
-        var _enabled = cookieMgrConfig[strEnabled] !== false;
+        var cookieMgrConfig;
+        var _path;
+        var _domain;
+        var _enabled;
+        var _getCookieFn;
+        var _setCookieFn;
+        var _delCookieFn;
+        rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
+        onConfigChange(rootConfig, function (details) {
+            applyDefaults(details.cfg, rootDefaultConfig);
+            cookieMgrConfig = applyDefaults(details.cfg.cookieCfg, defaultConfig$1);
+            var isEnabled = cookieMgrConfig.enabled;
+            if (isNullOrUndefined(isEnabled)) {
+                var cookieEnabled = void 0;
+                if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
+                    cookieEnabled = !rootConfig[strIsCookieUseDisabled];
+                }
+                if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+                    cookieEnabled = !rootConfig[strDisableCookiesUsage];
+                }
+                isEnabled = cookieEnabled;
+            }
+            _path = cookieMgrConfig[STR_PATH ] || "/";
+            _domain = cookieMgrConfig[STR_DOMAIN ];
+            _enabled = isEnabled !== false;
+            _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
+            _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+            _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
+        }, logger);
         var cookieMgr = {
             isEnabled: function () {
                 var enabled = _enabled && areCookiesSupported(logger);
@@ -2328,7 +2853,7 @@
                         theValue = strTrim(value[_DYN_SUBSTRING$1 ](0, idx));
                         values = _extractParts(value[_DYN_SUBSTRING$1 ](idx + 1));
                     }
-                    setValue(values, "domain", domain || _domain, isTruthy, isUndefined);
+                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
                     if (!isNullOrUndefined(maxAgeSec)) {
                         var _isIE = isIE();
                         if (isUndefined(values[strExpires])) {
@@ -2354,9 +2879,8 @@
                             setValue(values, "SameSite", "None", null, isUndefined);
                         }
                     }
-                    setValue(values, "path", path || _path, null, isUndefined);
-                    var setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
-                    setCookieFn(name, _formatCookieValue(theValue, values));
+                    setValue(values, STR_PATH, path || _path, null, isUndefined);
+                    _setCookieFn(name, _formatCookieValue(theValue, values));
                     result = true;
                 }
                 return result;
@@ -2364,7 +2888,7 @@
             get: function (name) {
                 var value = STR_EMPTY;
                 if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                    value = (cookieMgrConfig.getCookie || _getCookieValue)(name);
+                    value = _getCookieFn(name);
                 }
                 return value;
             },
@@ -2380,14 +2904,13 @@
                 var result = false;
                 if (areCookiesSupported(logger)) {
                     var values = (_a = {},
-                        _a["path"] = path ? path : "/",
+                        _a[STR_PATH] = path ? path : "/",
                         _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
                         _a);
                     if (!isIE()) {
                         values["max-age"] = "0";
                     }
-                    var delCookie = cookieMgrConfig.delCookie || _setCookieValue;
-                    delCookie(name, _formatCookieValue(STR_EMPTY, values));
+                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
                     result = true;
                 }
                 return result;
@@ -2436,7 +2959,7 @@
     }
     function _formatCookieValue(value, values) {
         var cookieValue = value || STR_EMPTY;
-        objForEachKey(values, function (name, theValue) {
+        objForEachKey$1(values, function (name, theValue) {
             cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
         });
         return cookieValue;
@@ -2480,8 +3003,81 @@
         if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
             return true;
         }
-        return false;
-    }
+        return false;
+    }
+
+    var defaultValues$1 = {
+        perfEvtsSendAll: false
+    };
+    function _runListeners(listeners, name, isAsync, callback) {
+        arrForEach(listeners, function (listener) {
+            if (listener && listener[name]) {
+                if (isAsync) {
+                    setTimeout(function () { return callback(listener); }, 0);
+                }
+                else {
+                    try {
+                        callback(listener);
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        });
+    }
+    var NotificationManager = /** @class */ (function () {
+        function NotificationManager(config) {
+            this.listeners = [];
+            var perfEvtsSendAll;
+            var cfgHandler = createDynamicConfig(config, defaultValues$1);
+            cfgHandler[_DYN_WATCH ](function (details) {
+                perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
+            });
+            dynamicProto(NotificationManager, this, function (_self) {
+                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
+                    _self.listeners[_DYN_PUSH$1 ](listener);
+                };
+                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
+                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    while (index > -1) {
+                        _self.listeners[_DYN_SPLICE ](index, 1);
+                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    }
+                };
+                _self[STR_EVENTS_SENT ] = function (events) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
+                        listener[STR_EVENTS_SENT ](events);
+                    });
+                };
+                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
+                        listener[STR_EVENTS_DISCARDED ](events, reason);
+                    });
+                };
+                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
+                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
+                    });
+                };
+                _self[STR_PERF_EVENT ] = function (perfEvent) {
+                    if (perfEvent) {
+                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
+                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
+                                if (perfEvent[_DYN_IS_ASYNC ]) {
+                                    setTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
+                                }
+                                else {
+                                    listener[STR_PERF_EVENT ](perfEvent);
+                                }
+                            });
+                        }
+                    }
+                };
+            });
+        }
+        NotificationManager.__ieDyn=1;
+        return NotificationManager;
+    }());
 
     function createUnloadHandlerContainer() {
         var handlers = [];
@@ -2507,7 +3103,11 @@
         };
     }
 
+    var _a$2;
     var strGetPlugin = "getPlugin";
+    var defaultValues = (_a$2 = {},
+        _a$2[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: [] },
+        _a$2);
     var BaseTelemetryPlugin = /** @class */ (function () {
         function BaseTelemetryPlugin() {
             var _self = this;
@@ -2543,7 +3143,12 @@
                             var oldHooks = _hooks;
                             _hooks = [];
                             arrForEach(oldHooks, function (fn) {
-                                fn.rm();
+                                try {
+                                    (fn.rm || fn.remove)[_DYN_CALL ](fn);
+                                }
+                                catch (e) {
+                                    _throwInternal(theUnloadCtx[_DYN_DIAG_LOG$1 ](), 2 , 73 , "Unloading:" + dumpObj(e));
+                                }
                             });
                             if (result === true) {
                                 theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
@@ -2586,12 +3191,7 @@
                 };
                 _self._addHook = function (hooks) {
                     if (hooks) {
-                        if (isArray(hooks)) {
-                            _hooks = _hooks.concat(hooks);
-                        }
-                        else {
-                            _hooks[_DYN_PUSH$1 ](hooks);
-                        }
+                        arrAppend(_hooks, hooks);
                     }
                 };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
@@ -2632,9 +3232,7 @@
                 return itemCtx;
             }
             function _setDefaults(config, core, pluginChain) {
-                if (config) {
-                    setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
-                }
+                createDynamicConfig(config, defaultValues, core[_DYN_LOGGER ]);
                 if (!pluginChain && core) {
                     pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
                 }
@@ -2699,7 +3297,7 @@
                                 }
                             }
                             catch (e) {
-                                _throwInternal(itemCtx[_DYN_DIAG_LOG$1 ](), 1 , 64 , "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: dumpObj(e) }, true);
+                                _throwInternal(itemCtx[_DYN_DIAG_LOG$1 ](), 2 , 64 , "Telemetry initializer failed: " + getExceptionName(e), { exception: dumpObj(e) }, true);
                             }
                         }
                     }
@@ -2721,13 +3319,21 @@
         return TelemetryInitializerPlugin;
     }(BaseTelemetryPlugin));
 
+    var _a$1;
     var strValidationError = "Plugins must provide initialize method";
     var strNotificationManager = "_notificationManager";
     var strSdkUnloadingError = "SDK is still unloading...";
     var strSdkNotInitialized = "SDK is not initialized";
-    var defaultInitConfig = {
-        loggingLevelConsole: 1
-    };
+    var defaultConfig = objDeepFreeze((_a$1 = {
+            cookieCfg: {}
+        },
+        _a$1[STR_EXTENSIONS] = [],
+        _a$1[STR_CHANNELS] = [],
+        _a$1[STR_EXTENSION_CONFIG] = {},
+        _a$1[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE$1,
+        _a$1.loggingLevelConsole = 0 ,
+        _a$1.diagnosticLogInterval = UNDEFINED_VALUE$1,
+        _a$1));
     function _createPerfManager(core, notificationMgr) {
         return new PerfManager(notificationMgr);
     }
@@ -2769,19 +3375,63 @@
         });
         return exists;
     }
-    function _createDummyNotificationManager() {
-        var _a;
-        return objCreateFn((_a = {},
-            _a[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) { },
-            _a[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) { },
-            _a[STR_EVENTS_SENT ] = function (events) { },
-            _a[STR_EVENTS_DISCARDED ] = function (events, reason) { },
-            _a[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) { },
-            _a));
-    }
-    var BaseCore = /** @class */ (function () {
-        function BaseCore() {
-            var _config;
+    function _deepMergeConfig(details, target, newValues, merge) {
+        if (newValues) {
+            objForEachKey(newValues, function (key, value) {
+                if (merge) {
+                    if (isPlainObject(value) && isPlainObject(target[key])) {
+                        _deepMergeConfig(details, target[key], value, merge);
+                    }
+                }
+                if (merge && isPlainObject(value) && isPlainObject(target[key])) {
+                    _deepMergeConfig(details, target[key], value, merge);
+                }
+                else {
+                    details.hdlr.set(target, key, value);
+                }
+            });
+        }
+    }
+    function _findWatcher(listeners, newWatcher) {
+        var theListener = null;
+        var idx = -1;
+        arrForEach(listeners, function (listener, lp) {
+            if (listener.w === newWatcher) {
+                theListener = listener;
+                idx = lp;
+                return -1;
+            }
+        });
+        return { i: idx, l: theListener };
+    }
+    function _addDelayedCfgListener(listeners, newWatcher) {
+        var theListener = _findWatcher(listeners, newWatcher).l;
+        if (!theListener) {
+            theListener = {
+                w: newWatcher,
+                rm: function () {
+                    var fnd = _findWatcher(listeners, newWatcher);
+                    if (fnd.i !== -1) {
+                        listeners[_DYN_SPLICE ](fnd.i, 1);
+                    }
+                }
+            };
+            listeners[_DYN_PUSH$1 ](theListener);
+        }
+        return theListener;
+    }
+    function _registerDelayedCfgListener(config, listeners, logger) {
+        arrForEach(listeners, function (listener) {
+            var unloadHdl = onConfigChange(config, listener.w, logger);
+            delete listener.w;
+            listener.rm = function () {
+                unloadHdl.rm();
+            };
+        });
+    }
+    var AppInsightsCore = /** @class */ (function () {
+        function AppInsightsCore() {
+            var _configHandler;
             var _isInitialized;
             var _eventQueue;
             var _notificationManager;
@@ -2799,10 +3449,13 @@
             var _internalLogsEventName;
             var _evtNamespace;
             var _unloadHandlers;
+            var _hooks;
             var _debugListener;
             var _traceCtx;
+            var _instrumentationKey;
+            var _cfgListeners;
             var _internalLogPoller = 0;
-            dynamicProto(BaseCore, this, function (_self) {
+            dynamicProto(AppInsightsCore, this, function (_self) {
                 _initDefaults();
                 _self[_DYN_IS_INITIALIZED ] = function () { return _isInitialized; };
                 _self[_DYN_INITIALIZE$1 ] = function (config, extensions, logger, notificationManager) {
@@ -2810,29 +3463,33 @@
                         throwError(strSdkUnloadingError);
                     }
                     if (_self[_DYN_IS_INITIALIZED ]()) {
-                        throwError("Core should not be initialized more than once");
-                    }
-                    _config = config || {};
-                    _self[_DYN_CONFIG ] = _config;
-                    if (isNullOrUndefined(config[_DYN_INSTRUMENTATION_KEY$1 ])) {
-                        throwError("Please provide instrumentation key");
-                    }
+                        throwError("Core cannot be initialized more than once");
+                    }
+                    _configHandler = createDynamicConfig(config, defaultConfig, logger || _self[_DYN_LOGGER ], false);
+                    config = _configHandler.cfg;
+                    _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                        _instrumentationKey = details.cfg.instrumentationKey;
+                        if (isNullOrUndefined(_instrumentationKey)) {
+                            throwError("Please provide instrumentation key");
+                        }
+                    }));
                     _notificationManager = notificationManager;
                     _self[strNotificationManager] = notificationManager;
                     _initDebugListener();
                     _initPerfManager();
                     _initExtConfig();
-                    if (logger) {
-                        _self[_DYN_LOGGER ] = logger;
-                    }
-                    var cfgExtensions = getSetValue(_config, STR_EXTENSIONS, []);
+                    _self[_DYN_LOGGER ] = logger || new DiagnosticLogger(config);
+                    _configHandler[_DYN_LOGGER ] = _self[_DYN_LOGGER ];
+                    var cfgExtensions = config[STR_EXTENSIONS ];
                     _configExtensions = [];
                     _configExtensions[_DYN_PUSH$1 ].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), cfgExtensions));
-                    _channelConfig = getSetValue(_config, STR_CHANNELS, []);
+                    _channelConfig = config[STR_CHANNELS ];
                     _initPluginChain(null);
                     if (!_channelQueue || _channelQueue[_DYN_LENGTH$2 ] === 0) {
                         throwError("No " + STR_CHANNELS + " available");
                     }
+                    _registerDelayedCfgListener(config, _cfgListeners, _self[_DYN_LOGGER ]);
+                    _cfgListeners = null;
                     _isInitialized = true;
                     _self.releaseQueue();
                 };
@@ -2846,21 +3503,33 @@
                     return objFreeze(controls);
                 };
                 _self.track = function (telemetryItem) {
-                    telemetryItem.iKey = telemetryItem.iKey || _config[_DYN_INSTRUMENTATION_KEY$1 ];
-                    telemetryItem[_DYN_TIME ] = telemetryItem[_DYN_TIME ] || toISOString(new Date());
-                    telemetryItem.ver = telemetryItem.ver || "4.0";
-                    if (!_isUnloading && _self[_DYN_IS_INITIALIZED ]()) {
-                        _createTelCtx()[_DYN_PROCESS_NEXT ](telemetryItem);
-                    }
-                    else {
-                        _eventQueue[_DYN_PUSH$1 ](telemetryItem);
-                    }
+                    doPerf(_self[STR_GET_PERF_MGR ](), function () { return "AppInsightsCore:track"; }, function () {
+                        if (telemetryItem === null) {
+                            _notifyInvalidEvent(telemetryItem);
+                            throwError("Invalid telemetry item");
+                        }
+                        if (!telemetryItem[_DYN_NAME$2 ] && isNullOrUndefined(telemetryItem[_DYN_NAME$2 ])) {
+                            _notifyInvalidEvent(telemetryItem);
+                            throwError("telemetry name required");
+                        }
+                        telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;
+                        telemetryItem[_DYN_TIME ] = telemetryItem[_DYN_TIME ] || toISOString(new Date());
+                        telemetryItem.ver = telemetryItem.ver || "4.0";
+                        if (!_isUnloading && _self[_DYN_IS_INITIALIZED ]()) {
+                            _createTelCtx()[_DYN_PROCESS_NEXT ](telemetryItem);
+                        }
+                        else {
+                            _eventQueue[_DYN_PUSH$1 ](telemetryItem);
+                        }
+                    }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
                 };
                 _self[_DYN_GET_PROCESS_TEL_CONT0 ] = _createTelCtx;
                 _self[_DYN_GET_NOTIFY_MGR ] = function () {
                     if (!_notificationManager) {
-                        _notificationManager = _createDummyNotificationManager();
-                        _self[strNotificationManager] = _notificationManager;
+                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                            _notificationManager = new NotificationManager(details.cfg);
+                            _self[strNotificationManager] = _notificationManager;
+                        }));
                     }
                     return _notificationManager;
                 };
@@ -2876,7 +3545,9 @@
                 };
                 _self.getCookieMgr = function () {
                     if (!_cookieManager) {
-                        _cookieManager = createCookieMgr(_config, _self[_DYN_LOGGER ]);
+                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                            _cookieManager = createCookieMgr(details.cfg, _self[_DYN_LOGGER ]);
+                        }));
                     }
                     return _cookieManager;
                 };
@@ -2885,12 +3556,14 @@
                 };
                 _self[STR_GET_PERF_MGR ] = function () {
                     if (!_perfManager && !_cfgPerfManager) {
-                        if (getCfgValue(_config.enablePerfMgr)) {
-                            var createPerfMgr = getCfgValue(_config[STR_CREATE_PERF_MGR ]);
-                            if (isFunction(createPerfMgr)) {
-                                _cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR ]());
+                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                            if (details.cfg.enablePerfMgr) {
+                                var createPerfMgr = details.cfg[STR_CREATE_PERF_MGR ];
+                                if (isFunction(createPerfMgr)) {
+                                    _cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR ]());
+                                }
                             }
-                        }
+                        }));
                     }
                     return _perfManager || _cfgPerfManager || getGblPerfMgr();
                 };
@@ -2911,16 +3584,18 @@
                 };
                 _self.pollInternalLogs = function (eventName) {
                     _internalLogsEventName = eventName || null;
-                    var interval = getCfgValue(_config.diagnosticLogInterval);
-                    if (!interval || !(interval > 0)) {
-                        interval = 10000;
-                    }
-                    if (_internalLogPoller) {
-                        clearInterval(_internalLogPoller);
-                    }
-                    _internalLogPoller = setInterval(function () {
-                        _flushInternalLogs();
-                    }, interval);
+                    _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                        var interval = details.cfg.diagnosticLogInterval;
+                        if (!interval || !(interval > 0)) {
+                            interval = 10000;
+                        }
+                        if (_internalLogPoller) {
+                            clearInterval(_internalLogPoller);
+                        }
+                        _internalLogPoller = setInterval(function () {
+                            _flushInternalLogs();
+                        }, interval);
+                    }));
                     return _internalLogPoller;
                 };
                 _self[_DYN_STOP_POLLING_INTERNA3 ] = function () {
@@ -2948,6 +3623,16 @@
                         _a);
                     var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
                     processUnloadCtx[_DYN_ON_COMPLETE ](function () {
+                        var oldHooks = _hooks;
+                        _hooks = [];
+                        arrForEach(oldHooks, function (fn) {
+                            try {
+                                (fn.rm || fn.remove)[_DYN_CALL ](fn);
+                            }
+                            catch (e) {
+                                _throwInternal(_self[_DYN_LOGGER ], 2 , 73 , "Unloading:" + dumpObj(e));
+                            }
+                        });
                         _initDefaults();
                         unloadComplete && unloadComplete(unloadState);
                     }, _self);
@@ -3005,6 +3690,35 @@
                         _addPlugin();
                     }
                 };
+                _self.updateCfg = function (newConfig, mergeExisting) {
+                    if (mergeExisting === void 0) { mergeExisting = true; }
+                    var updateState = {
+                        reason: 1 ,
+                        cfg: _configHandler.cfg,
+                        oldCfg: deepExtend({}, _configHandler.cfg),
+                        newConfig: deepExtend({}, newConfig),
+                        merge: mergeExisting
+                    };
+                    newConfig = updateState.newConfig;
+                    var cfg = _configHandler.cfg;
+                    newConfig[STR_EXTENSIONS ] = cfg[STR_EXTENSIONS ];
+                    newConfig[STR_CHANNELS ] = cfg[STR_CHANNELS ];
+                    _configHandler._block(function (details) {
+                        var theConfig = details.cfg;
+                        _deepMergeConfig(details, theConfig, newConfig, mergeExisting);
+                        if (!mergeExisting) {
+                            objForEachKey(theConfig, function (key) {
+                                if (!objHasOwn(newConfig, key)) {
+                                    details.hdlr.set(theConfig, key, UNDEFINED_VALUE$1);
+                                }
+                            });
+                        }
+                        applyDefaults(theConfig, defaultConfig);
+                        _initExtConfig();
+                    });
+                    _configHandler[_DYN_NOTIFY ]();
+                    _doUpdate(updateState);
+                };
                 _self.evtNamespace = function () {
                     return _evtNamespace;
                 };
@@ -3018,12 +3732,38 @@
                 _self.setTraceCtx = function (traceCtx) {
                     _traceCtx = traceCtx || null;
                 };
+                _self.addUnloadHook = _addUnloadHook;
                 proxyFunctionAs(_self, "addUnloadCb", function () { return _unloadHandlers; }, "add");
+                _self.onCfgChange = function (handler) {
+                    var unloadHook;
+                    if (!_isInitialized) {
+                        unloadHook = _addDelayedCfgListener(_cfgListeners, handler);
+                    }
+                    else {
+                        unloadHook = onConfigChange(_configHandler.cfg, handler, _self[_DYN_LOGGER ]);
+                    }
+                    return {
+                        rm: function () {
+                            unloadHook.rm();
+                        }
+                    };
+                };
                 function _initDefaults() {
+                    var _a;
                     _isInitialized = false;
-                    _config = objExtend(true, {}, defaultInitConfig);
-                    _self[_DYN_CONFIG ] = _config;
-                    _self[_DYN_LOGGER ] = new DiagnosticLogger(_config);
+                    _configHandler = createDynamicConfig({}, defaultConfig, _self[_DYN_LOGGER ]);
+                    _configHandler.cfg[_DYN_LOGGING_LEVEL_CONSOL4 ] = 1 ;
+                    objDefineProp(_self, "config", (_a = {},
+                        _a[_DYN_CONFIGURABLE ] = true,
+                        _a[_DYN_ENUMERABLE ] = true,
+                        _a.get = function () { return _configHandler.cfg; },
+                        _a.set = function (newValue) {
+                            if (_self[_DYN_IS_INITIALIZED ]()) {
+                                _self.updateCfg(newValue, false);
+                            }
+                        },
+                        _a));
+                    _self[_DYN_LOGGER ] = new DiagnosticLogger(_configHandler.cfg);
                     _self[_DYN__EXTENSIONS ] = [];
                     _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
                     _eventQueue = [];
@@ -3042,9 +3782,12 @@
                     _evtNamespace = createUniqueNamespace("AIBaseCore", true);
                     _unloadHandlers = createUnloadHandlerContainer();
                     _traceCtx = null;
+                    _instrumentationKey = null;
+                    _hooks = [];
+                    _cfgListeners = [];
                 }
                 function _createTelCtx() {
-                    return createProcessTelemetryContext(_getPluginChain(), _config, _self);
+                    return createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
                 }
                 function _initPluginChain(updateState) {
                     var theExtensions = _validateExtensions(_self[_DYN_LOGGER ], ChannelControllerPriority, _configExtensions);
@@ -3069,7 +3812,7 @@
                     allExtensions[_DYN_PUSH$1 ](_channelControl);
                     _coreExtensions[_DYN_PUSH$1 ](_channelControl);
                     _self[_DYN__EXTENSIONS ] = sortPlugins(allExtensions);
-                    _channelControl[_DYN_INITIALIZE$1 ](_config, _self, allExtensions);
+                    _channelControl[_DYN_INITIALIZE$1 ](_configHandler.cfg, _self, allExtensions);
                     initializePlugins(_createTelCtx(), allExtensions);
                     _self[_DYN__EXTENSIONS ] = objFreeze(sortPlugins(_coreExtensions || [])).slice();
                     if (updateState) {
@@ -3127,13 +3870,13 @@
                         if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {
                             extensions[_DYN_PUSH$1 ](_telemetryInitializerPlugin);
                         }
-                        _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _config, _self);
+                        _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _configHandler.cfg, _self);
                     }
                     return _pluginChain;
                 }
                 function _removePlugins(thePlugins, unloadState, removeComplete) {
                     if (thePlugins && thePlugins[_DYN_LENGTH$2 ] > 0) {
-                        var unloadChain = createTelemetryProxyChain(thePlugins, _config, _self);
+                        var unloadChain = createTelemetryProxyChain(thePlugins, _configHandler.cfg, _self);
                         var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);
                         unloadCtx[_DYN_ON_COMPLETE ](function () {
                             var removed = false;
@@ -3178,7 +3921,7 @@
                             var _a;
                             var item = (_a = {},
                                 _a[_DYN_NAME$2 ] = _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID ],
-                                _a.iKey = getCfgValue(_config[_DYN_INSTRUMENTATION_KEY$1 ]),
+                                _a.iKey = _instrumentationKey,
                                 _a.time = toISOString(new Date()),
                                 _a.baseType = _InternalLogMessage.dataType,
                                 _a.baseData = { message: logMessage[_DYN_MESSAGE$1 ] },
@@ -3196,28 +3939,31 @@
                     return true;
                 }
                 function _initDebugListener() {
-                    var disableDbgExt = getCfgValue(_config.disableDbgExt);
-                    if (disableDbgExt === true && _debugListener) {
-                        _notificationManager[_DYN_REMOVE_NOTIFICATION_2 ](_debugListener);
-                        _debugListener = null;
-                    }
-                    if (_notificationManager && !_debugListener && disableDbgExt !== true) {
-                        _debugListener = getDebugListener(_config);
-                        _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 ](_debugListener);
-                    }
+                    _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                        var disableDbgExt = details.cfg.disableDbgExt;
+                        if (disableDbgExt === true && _debugListener) {
+                            _notificationManager[_DYN_REMOVE_NOTIFICATION_2 ](_debugListener);
+                            _debugListener = null;
+                        }
+                        if (_notificationManager && !_debugListener && disableDbgExt !== true) {
+                            _debugListener = getDebugListener(details.cfg);
+                            _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 ](_debugListener);
+                        }
+                    }));
                 }
                 function _initPerfManager() {
-                    var enablePerfMgr = getCfgValue(_config.enablePerfMgr);
-                    if (!enablePerfMgr && _cfgPerfManager) {
-                        _cfgPerfManager = null;
-                    }
-                    if (enablePerfMgr) {
-                        getSetValue(_config, STR_CREATE_PERF_MGR, _createPerfManager);
-                    }
+                    _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
+                        var enablePerfMgr = details.cfg.enablePerfMgr;
+                        if (!enablePerfMgr && _cfgPerfManager) {
+                            _cfgPerfManager = null;
+                        }
+                        if (enablePerfMgr) {
+                            getSetValue(details.cfg, STR_CREATE_PERF_MGR, _createPerfManager);
+                        }
+                    }));
                 }
                 function _initExtConfig() {
-                    var extConfig = getSetValue(_config, STR_EXTENSION_CONFIG, {});
-                    extConfig.NotificationManager = _notificationManager;
+                    _configHandler.cfg[STR_EXTENSION_CONFIG ].NotificationManager = _notificationManager;
                 }
                 function _doUpdate(updateState) {
                     var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);
@@ -3234,114 +3980,22 @@
                         throwError(message);
                     }
                 }
-            });
-        }
-        BaseCore.__ieDyn=1;
-        return BaseCore;
-    }());
-
-    function _runListeners(listeners, name, isAsync, callback) {
-        arrForEach(listeners, function (listener) {
-            if (listener && listener[name]) {
-                if (isAsync) {
-                    setTimeout(function () { return callback(listener); }, 0);
-                }
-                else {
-                    try {
-                        callback(listener);
-                    }
-                    catch (e) {
-                    }
-                }
-            }
-        });
-    }
-    var NotificationManager = /** @class */ (function () {
-        function NotificationManager(config) {
-            this.listeners = [];
-            var perfEvtsSendAll = !!(config || {}).perfEvtsSendAll;
-            dynamicProto(NotificationManager, this, function (_self) {
-                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
-                    _self.listeners[_DYN_PUSH$1 ](listener);
-                };
-                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
-                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
-                    while (index > -1) {
-                        _self.listeners[_DYN_SPLICE ](index, 1);
-                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
-                    }
-                };
-                _self[STR_EVENTS_SENT ] = function (events) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
-                        listener[STR_EVENTS_SENT ](events);
-                    });
-                };
-                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
-                        listener[STR_EVENTS_DISCARDED ](events, reason);
-                    });
-                };
-                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
-                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
-                    });
-                };
-                _self[STR_PERF_EVENT ] = function (perfEvent) {
-                    if (perfEvent) {
-                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
-                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
-                                if (perfEvent[_DYN_IS_ASYNC ]) {
-                                    setTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
-                                }
-                                else {
-                                    listener[STR_PERF_EVENT ](perfEvent);
-                                }
-                            });
-                        }
-                    }
-                };
-            });
-        }
-        NotificationManager.__ieDyn=1;
-        return NotificationManager;
-    }());
-
-    var AppInsightsCore = /** @class */ (function (_super) {
-        __extendsFn(AppInsightsCore, _super);
-        function AppInsightsCore() {
-            var _this = _super.call(this) || this;
-            dynamicProto(AppInsightsCore, _this, function (_self, _base) {
-                _self[_DYN_INITIALIZE$1 ] = function (config, extensions, logger, notificationManager) {
-                    _base[_DYN_INITIALIZE$1 ](config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
-                };
-                _self.track = function (telemetryItem) {
-                    doPerf(_self[STR_GET_PERF_MGR ](), function () { return "AppInsightsCore:track"; }, function () {
-                        if (telemetryItem === null) {
-                            _notifyInvalidEvent(telemetryItem);
-                            throwError("Invalid telemetry item");
-                        }
-                        _validateTelemetryItem(telemetryItem);
-                        _base.track(telemetryItem);
-                    }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
-                };
-                function _validateTelemetryItem(telemetryItem) {
-                    if (isNullOrUndefined(telemetryItem[_DYN_NAME$2 ])) {
-                        _notifyInvalidEvent(telemetryItem);
-                        throwError("telemetry name required");
-                    }
-                }
                 function _notifyInvalidEvent(telemetryItem) {
                     var manager = _self[_DYN_GET_NOTIFY_MGR ]();
                     if (manager) {
                         manager[STR_EVENTS_DISCARDED ]([telemetryItem], 2 );
                     }
                 }
+                function _addUnloadHook(hooks) {
+                    if (hooks) {
+                        arrAppend(_hooks, hooks);
+                    }
+                }
             });
-            return _this;
         }
         AppInsightsCore.__ieDyn=1;
         return AppInsightsCore;
-    }(BaseCore));
+    }());
 
     var strOnPrefix = "on";
     var strAttachEvent = "attachEvent";
@@ -3358,7 +4012,7 @@
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
         if (name && name[_DYN_REPLACE ]) {
-            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
+            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
         }
         return name;
     }
@@ -3517,112 +4171,6 @@
         }
     }
 
-    var _a$1;
-    var FAILED = "Failed";
-    var FAILED_MONITOR_AJAX = FAILED + "MonitorAjax";
-    var TRACK = "Track";
-    var START = "Start";
-    var STOP = "Stop";
-    var EVENT = "Event";
-    var AUTH_CONTEXT = "AuthContext";
-    var EXCEPTION = "Exception";
-    var LOCAL = "Local";
-    var SESSION = "Session";
-    var STORAGE = "Storage";
-    var BROWSER = "Browser";
-    var CANNOT = "Cannot";
-    var BUFFER = "Buffer";
-    var INSTRUMENTATION_KEY = "InstrumentationKey";
-    createEnumStyle({
-        CRITICAL: 1 ,
-        WARNING: 2
-    });
-    var _InternalMessageId = createEnumStyle((_a$1 = {},
-        _a$1[BROWSER + "DoesNotSupport" + LOCAL + STORAGE] = 0 ,
-        _a$1[BROWSER + CANNOT + "Read" + LOCAL + STORAGE] = 1 ,
-        _a$1[BROWSER + CANNOT + "Read" + SESSION + STORAGE] = 2 ,
-        _a$1[BROWSER + CANNOT + "Write" + LOCAL + STORAGE] = 3 ,
-        _a$1[BROWSER + CANNOT + "Write" + SESSION + STORAGE] = 4 ,
-        _a$1[BROWSER + FAILED + "RemovalFrom" + LOCAL + STORAGE] = 5 ,
-        _a$1[BROWSER + FAILED + "RemovalFrom" + SESSION + STORAGE] = 6 ,
-        _a$1[CANNOT + "SendEmptyTelemetry"] = 7 ,
-        _a$1.ClientPerformanceMathError = 8 ,
-        _a$1["ErrorParsingAI" + SESSION + "Cookie"] = 9 ,
-        _a$1.ErrorPVCalc = 10 ,
-        _a$1[EXCEPTION + "WhileLoggingError"] = 11 ,
-        _a$1[FAILED + "AddingTelemetryTo" + BUFFER] = 12 ,
-        _a$1[FAILED_MONITOR_AJAX + "Abort"] = 13 ,
-        _a$1[FAILED_MONITOR_AJAX + "Dur"] = 14 ,
-        _a$1[FAILED_MONITOR_AJAX + "Open"] = 15 ,
-        _a$1[FAILED_MONITOR_AJAX + "RSC"] = 16 ,
-        _a$1[FAILED_MONITOR_AJAX + "Send"] = 17 ,
-        _a$1[FAILED_MONITOR_AJAX + "GetCorrelationHeader"] = 18 ,
-        _a$1[FAILED + "ToAddHandlerForOnBeforeUnload"] = 19 ,
-        _a$1[FAILED + "ToSendQueuedTelemetry"] = 20 ,
-        _a$1[FAILED + "ToReportDataLoss"] = 21 ,
-        _a$1["Flush" + FAILED] = 22 ,
-        _a$1.MessageLimitPerPVExceeded = 23 ,
-        _a$1.MissingRequiredFieldSpecification = 24 ,
-        _a$1.NavigationTimingNotSupported = 25 ,
-        _a$1.OnError = 26 ,
-        _a$1[SESSION + "RenewalDateIsZero"] = 27 ,
-        _a$1.SenderNotInitialized = 28 ,
-        _a$1[START + TRACK + EVENT + FAILED] = 29 ,
-        _a$1[STOP + TRACK + EVENT + FAILED] = 30 ,
-        _a$1[START + TRACK + FAILED] = 31 ,
-        _a$1[STOP + TRACK + FAILED] = 32 ,
-        _a$1.TelemetrySampledAndNotSent = 33 ,
-        _a$1[TRACK + EVENT + FAILED] = 34 ,
-        _a$1[TRACK + EXCEPTION + FAILED] = 35 ,
-        _a$1[TRACK + "Metric" + FAILED] = 36 ,
-        _a$1[TRACK + "PV" + FAILED] = 37 ,
-        _a$1[TRACK + "PV" + FAILED + "Calc"] = 38 ,
-        _a$1[TRACK + "Trace" + FAILED] = 39 ,
-        _a$1["Transmission" + FAILED] = 40 ,
-        _a$1[FAILED + "ToSet" + STORAGE + BUFFER] = 41 ,
-        _a$1[FAILED + "ToRestore" + STORAGE + BUFFER] = 42 ,
-        _a$1.InvalidBackendResponse = 43 ,
-        _a$1[FAILED + "ToFixDepricatedValues"] = 44 ,
-        _a$1.InvalidDurationValue = 45 ,
-        _a$1.TelemetryEnvelopeInvalid = 46 ,
-        _a$1.CreateEnvelopeError = 47 ,
-        _a$1[CANNOT + "SerializeObject"] = 48 ,
-        _a$1[CANNOT + "SerializeObjectNonSerializable"] = 49 ,
-        _a$1.CircularReferenceDetected = 50 ,
-        _a$1["Clear" + AUTH_CONTEXT + FAILED] = 51 ,
-        _a$1[EXCEPTION + "Truncated"] = 52 ,
-        _a$1.IllegalCharsInName = 53 ,
-        _a$1.ItemNotInArray = 54 ,
-        _a$1.MaxAjaxPerPVExceeded = 55 ,
-        _a$1.MessageTruncated = 56 ,
-        _a$1.NameTooLong = 57 ,
-        _a$1.SampleRateOutOfRange = 58 ,
-        _a$1["Set" + AUTH_CONTEXT + FAILED] = 59 ,
-        _a$1["Set" + AUTH_CONTEXT + FAILED + "AccountName"] = 60 ,
-        _a$1.StringValueTooLong = 61 ,
-        _a$1.StartCalledMoreThanOnce = 62 ,
-        _a$1.StopCalledWithoutStart = 63 ,
-        _a$1["TelemetryInitializer" + FAILED] = 64 ,
-        _a$1.TrackArgumentsNotSpecified = 65 ,
-        _a$1.UrlTooLong = 66 ,
-        _a$1[SESSION + STORAGE + BUFFER + "Full"] = 67 ,
-        _a$1[CANNOT + "AccessCookie"] = 68 ,
-        _a$1.IdTooLong = 69 ,
-        _a$1.InvalidEvent = 70 ,
-        _a$1[FAILED_MONITOR_AJAX + "SetRequestHeader"] = 71 ,
-        _a$1["Send" + BROWSER + "InfoOnUserInit"] = 72 ,
-        _a$1["Plugin" + EXCEPTION] = 73 ,
-        _a$1["Notification" + EXCEPTION] = 74 ,
-        _a$1.SnippetScriptLoadFailure = 99 ,
-        _a$1["Invalid" + INSTRUMENTATION_KEY] = 100 ,
-        _a$1[CANNOT + "ParseAiBlobValue"] = 101 ,
-        _a$1.InvalidContentBlob = 102 ,
-        _a$1[TRACK + "PageAction" + EVENT + FAILED] = 103 ,
-        _a$1[FAILED + "AddingCustomDefinedRequestContext"] = 104 ,
-        _a$1["InMemory" + STORAGE + BUFFER + "Full"] = 105 ,
-        _a$1[INSTRUMENTATION_KEY + "Deprecation"] = 106 ,
-        _a$1));
-
     var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
     var SampleRate = "sampleRate";
     var ProcessLegacy = "ProcessLegacy";
@@ -3738,7 +4286,7 @@
     function dataSanitizeProperties(logger, properties) {
         if (properties) {
             var tempProps_1 = {};
-            objForEachKey(properties, function (prop, value) {
+            objForEachKey$1(properties, function (prop, value) {
                 if (isObject(value) && hasJSON()) {
                     try {
                         value = getJSON()[_DYN_STRINGIFY$1 ](value);
@@ -3758,7 +4306,7 @@
     function dataSanitizeMeasurements(logger, measurements) {
         if (measurements) {
             var tempMeasurements_1 = {};
-            objForEachKey(measurements, function (measure, value) {
+            objForEachKey$1(measurements, function (measure, value) {
                 measure = dataSanitizeKeyAndAddUniqueness(logger, measure, tempMeasurements_1);
                 tempMeasurements_1[measure] = value;
             });
@@ -3809,7 +4357,7 @@
     function urlParseHost(url, inclPort) {
         var fullHost = urlParseFullHost(url, inclPort) || "";
         if (fullHost) {
-            var match = fullHost.match(/(www[0-9]?\.)?(.[^/:]+)(\:[\d]+)?/i);
+            var match = fullHost.match(/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
             if (match != null && match[_DYN_LENGTH$1 ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 return match[2] + (match[3] || "");
             }
@@ -3819,7 +4367,7 @@
     function urlParseFullHost(url, inclPort) {
         var result = null;
         if (url) {
-            var match = url.match(/(\w*):\/\/(.[^/:]+)(\:[\d]+)?/i);
+            var match = url.match(/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
             if (match != null && match[_DYN_LENGTH$1 ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 result = match[2] || "";
                 if (inclPort && match[_DYN_LENGTH$1 ] > 2) {
@@ -4764,6 +5312,7 @@
     var _DYN_ON_LINE = "onLine";
     var _DYN_ENQUEUE = "enqueue";
     var _DYN_COUNT = "count";
+    var _DYN_EVENTS_LIMIT_IN_MEM = "eventsLimitInMem";
     var _DYN_PUSH = "push";
     var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson";
     var _DYN_CLEAR = "clear";
@@ -4774,36 +5323,31 @@
     var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
     var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE";
     var _DYN_NAME_PREFIX = "namePrefix";
-    var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
     var _DYN_TRIGGER_SEND = "triggerSend";
     var _DYN_DIAG_LOG = "diagLog";
+    var _DYN__SENDER = "_sender";
+    var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
     var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon";
     var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled";
-    var _DYN__SENDER = "_sender";
-    var _DYN__SENDER_CONFIG = "_senderConfig";
     var _DYN__BUFFER = "_buffer";
     var _DYN_ENABLE_SESSION_STORA4 = "enableSessionStorageBuffer";
     var _DYN_SAMPLING_PERCENTAGE = "samplingPercentage";
     var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
-    var _DYN_ENDPOINT_URL = "endpointUrl";
     var _DYN_CUSTOM_HEADERS = "customHeaders";
     var _DYN_DISABLE_XHR = "disableXhr";
     var _DYN_ONUNLOAD_DISABLE_FET5 = "onunloadDisableFetch";
-    var _DYN_DISABLE_TELEMETRY = "disableTelemetry";
+    var _DYN_CONVERT_UNDEFINED = "convertUndefined";
+    var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
     var _DYN_BASE_TYPE = "baseType";
     var _DYN_SAMPLE_RATE = "sampleRate";
-    var _DYN_CONVERT_UNDEFINED = "convertUndefined";
     var _DYN__XHR_READY_STATE_CHA6 = "_xhrReadyStateChange";
     var _DYN__ON_ERROR = "_onError";
     var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess";
     var _DYN__ON_SUCCESS = "_onSuccess";
     var _DYN_ITEMS_ACCEPTED = "itemsAccepted";
     var _DYN_ITEMS_RECEIVED = "itemsReceived";
-    var _DYN_IS_RETRY_DISABLED = "isRetryDisabled";
     var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
-    var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
     var _DYN_EVENTS_SEND_REQUEST = "eventsSendRequest";
-    var _DYN_DISABLE_INSTRUMENTAT7 = "disableInstrumentationKeyValidation";
     var _DYN_GET_SAMPLING_SCORE = "getSamplingScore";
     var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore";
 
@@ -4861,12 +5405,12 @@
         var tgs = {};
         for (var i = itmTags[_DYN_LENGTH ] - 1; i >= 0; i--) {
             var tg = itmTags[i];
-            objForEachKey(tg, function (key, value) {
+            objForEachKey$1(tg, function (key, value) {
                 tgs[key] = value;
             });
             itmTags.splice(i, 1);
         }
-        objForEachKey(itmTags, function (tg, value) {
+        objForEachKey$1(itmTags, function (tg, value) {
             tgs[tg] = value;
         });
         var theTags = __assignFn(__assignFn({}, envTags), tgs);
@@ -4877,7 +5421,7 @@
     }
     function _extractPropsAndMeasurements(data, properties, measurements) {
         if (!isNullOrUndefined(data)) {
-            objForEachKey(data, function (key, value) {
+            objForEachKey$1(data, function (key, value) {
                 if (isNumber(value)) {
                     measurements[key] = value;
                 }
@@ -4892,7 +5436,7 @@
     }
     function _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue) {
         if (!isNullOrUndefined(properties)) {
-            objForEachKey(properties, function (key, value) {
+            objForEachKey$1(properties, function (key, value) {
                 properties[key] = value || customUndefinedValue;
             });
         }
@@ -4916,7 +5460,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: "3.0.0-beta.2210-01"
+        Version: "3.0.0-beta.2210-02"
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -5023,7 +5567,7 @@
         }
         if (!isNullOrUndefined(bd[strProperties])) {
             var pageTags = bd[strProperties];
-            objForEachKey(pageTags, function (key, value) {
+            objForEachKey$1(pageTags, function (key, value) {
                 properties[key] = value;
             });
         }
@@ -5154,7 +5698,7 @@
             };
             dynamicProto(BaseSendBuffer, this, function (_self) {
                 _self[_DYN_ENQUEUE ] = function (payload) {
-                    if (_self[_DYN_COUNT ]() >= config.eventsLimitInMem()) {
+                    if (_self[_DYN_COUNT ]() >= config[_DYN_EVENTS_LIMIT_IN_MEM ]) {
                         if (!_bufferFullMessageSent) {
                             _throwInternal(logger, 2 , 105 , "Maximum in-memory buffer size reached: " + _self[_DYN_COUNT ](), true);
                             _bufferFullMessageSent = true;
@@ -5171,7 +5715,7 @@
                     for (var lp = 0; lp < _buffer[_DYN_LENGTH ]; lp++) {
                         size += _buffer[lp][_DYN_LENGTH ];
                     }
-                    if (!config[_DYN_EMIT_LINE_DELIMITED_0 ]()) {
+                    if (!config[_DYN_EMIT_LINE_DELIMITED_0 ]) {
                         size += 2;
                     }
                     return size;
@@ -5185,7 +5729,7 @@
                 };
                 _self[_DYN_BATCH_PAYLOADS ] = function (payload) {
                     if (payload && payload[_DYN_LENGTH ] > 0) {
-                        var batch = config[_DYN_EMIT_LINE_DELIMITED_0 ]() ?
+                        var batch = config[_DYN_EMIT_LINE_DELIMITED_0 ] ?
                             payload.join("\n") :
                             "[" + payload.join(",") + "]";
                         return batch;
@@ -5273,7 +5817,7 @@
                 function _getBuffer(key) {
                     var prefixedKey = key;
                     try {
-                        prefixedKey = config[_DYN_NAME_PREFIX ] && config[_DYN_NAME_PREFIX ]() ? config[_DYN_NAME_PREFIX ]() + "_" + prefixedKey : prefixedKey;
+                        prefixedKey = config[_DYN_NAME_PREFIX ] ? config[_DYN_NAME_PREFIX ] + "_" + prefixedKey : prefixedKey;
                         var bufferJson = utlGetSessionStorage(logger, prefixedKey);
                         if (bufferJson) {
                             var buffer_1 = getJSON().parse(bufferJson);
@@ -5293,7 +5837,7 @@
                 function _setBuffer(key, buffer) {
                     var prefixedKey = key;
                     try {
-                        prefixedKey = config[_DYN_NAME_PREFIX ] && config[_DYN_NAME_PREFIX ]() ? config[_DYN_NAME_PREFIX ]() + "_" + prefixedKey : prefixedKey;
+                        prefixedKey = config[_DYN_NAME_PREFIX ] ? config[_DYN_NAME_PREFIX ] + "_" + prefixedKey : prefixedKey;
                         var bufferJson = JSON[_DYN_STRINGIFY ](buffer);
                         utlSetSessionStorage(logger, prefixedKey, bufferJson);
                     }
@@ -5360,7 +5904,7 @@
                         return output;
                     }
                     source[circularReferenceCheck] = true;
-                    objForEachKey(source.aiDataContract, function (field, contract) {
+                    objForEachKey$1(source.aiDataContract, function (field, contract) {
                         var isRequired = (isFunction(contract)) ? (contract() & 1 ) : (contract & 1 );
                         var isHidden = (isFunction(contract)) ? (contract() & 4 ) : (contract & 4 );
                         var isArray = contract & 2 ;
@@ -5411,7 +5955,7 @@
                     var output;
                     if (map) {
                         output = {};
-                        objForEachKey(map, function (field, value) {
+                        objForEachKey$1(map, function (field, value) {
                             if (expectedType === "string") {
                                 if (value === undefined) {
                                     output[field] = "undefined";
@@ -5537,7 +6081,8 @@
         return Sample;
     }());
 
-    var _a;
+    var _a, _b;
+    var UNDEFINED_VALUE = undefined;
     var FetchSyncRequestSizeLimitBytes = 65000;
     function _getResponseText(xhr) {
         try {
@@ -5547,47 +6092,41 @@
         }
         return null;
     }
-    function _getDefaultAppInsightsChannelConfig() {
-        var _a;
-        var defaultValue;
-        var defaultCustomHeaders;
-        return _a = {
-                endpointUrl: function () { return DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH; }
-            },
-            _a[_DYN_EMIT_LINE_DELIMITED_0 ] = function () { return false; },
-            _a[_DYN_MAX_BATCH_INTERVAL ] = function () { return 15000; },
-            _a[_DYN_MAX_BATCH_SIZE_IN_BY1 ] = function () { return 102400; },
-            _a[_DYN_DISABLE_TELEMETRY ] = function () { return false; },
-            _a[_DYN_ENABLE_SESSION_STORA4 ] = function () { return true; },
-            _a[_DYN_IS_RETRY_DISABLED ] = function () { return false; },
-            _a[_DYN_IS_BEACON_API_DISABL3 ] = function () { return true; },
-            _a[_DYN_DISABLE_XHR ] = function () { return false; },
-            _a[_DYN_ONUNLOAD_DISABLE_FET5 ] = function () { return false; },
-            _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = function () { return false; },
-            _a[_DYN_INSTRUMENTATION_KEY ] = function () { return defaultValue; },
-            _a[_DYN_NAME_PREFIX ] = function () { return defaultValue; },
-            _a[_DYN_SAMPLING_PERCENTAGE ] = function () { return 100; },
-            _a[_DYN_CUSTOM_HEADERS ] = function () { return defaultCustomHeaders; },
-            _a[_DYN_CONVERT_UNDEFINED ] = function () { return defaultValue; },
-            _a.eventsLimitInMem = function () { return 10000; },
-            _a;
-    }
-    var EnvelopeTypeCreator = (_a = {},
-        _a[Event.dataType] = EventEnvelopeCreator,
-        _a[Trace.dataType] = TraceEnvelopeCreator,
-        _a[PageView.dataType] = PageViewEnvelopeCreator,
-        _a[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator,
-        _a[Exception.dataType] = ExceptionEnvelopeCreator,
-        _a[Metric.dataType] = MetricEnvelopeCreator,
-        _a[RemoteDependencyData.dataType] = DependencyEnvelopeCreator,
-        _a);
+    var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
+            endpointUrl: { isVal: isTruthy, v: DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH }
+        },
+        _a[_DYN_EMIT_LINE_DELIMITED_0 ] = false,
+        _a[_DYN_MAX_BATCH_INTERVAL ] = 15000,
+        _a[_DYN_MAX_BATCH_SIZE_IN_BY1 ] = 102400,
+        _a.disableTelemetry = false,
+        _a[_DYN_ENABLE_SESSION_STORA4 ] = true,
+        _a.isRetryDisabled = false,
+        _a.isBeaconApiDisabled = true,
+        _a[_DYN_DISABLE_XHR ] = false,
+        _a[_DYN_ONUNLOAD_DISABLE_FET5 ] = false,
+        _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = false,
+        _a[_DYN_INSTRUMENTATION_KEY ] = UNDEFINED_VALUE,
+        _a[_DYN_NAME_PREFIX ] = UNDEFINED_VALUE,
+        _a[_DYN_SAMPLING_PERCENTAGE ] = 100,
+        _a[_DYN_CUSTOM_HEADERS ] = UNDEFINED_VALUE,
+        _a[_DYN_CONVERT_UNDEFINED ] = UNDEFINED_VALUE,
+        _a[_DYN_EVENTS_LIMIT_IN_MEM ] = 10000,
+        _a));
+    var EnvelopeTypeCreator = (_b = {},
+        _b[Event.dataType] = EventEnvelopeCreator,
+        _b[Trace.dataType] = TraceEnvelopeCreator,
+        _b[PageView.dataType] = PageViewEnvelopeCreator,
+        _b[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator,
+        _b[Exception.dataType] = ExceptionEnvelopeCreator,
+        _b[Metric.dataType] = MetricEnvelopeCreator,
+        _b[RemoteDependencyData.dataType] = DependencyEnvelopeCreator,
+        _b);
     var Sender = /** @class */ (function (_super) {
         __extendsFn(Sender, _super);
         function Sender() {
             var _this = _super.call(this) || this;
             _this.priority = 1001;
             _this.identifier = BreezeChannelIdentifier;
-            _this._senderConfig = _getDefaultAppInsightsChannelConfig();
             var _consecutiveErrors;
             var _retryAt;
             var _lastSend;
@@ -5601,6 +6140,16 @@
             var _syncUnloadSender;
             var _offlineListener;
             var _evtNamespace;
+            var _endpointUrl;
+            var _orgEndpointUrl;
+            var _maxBatchSizeInBytes;
+            var _beaconSupported;
+            var _customHeaders;
+            var _disableTelemetry;
+            var _instrumentationKey;
+            var _convertUndefined;
+            var _isRetryDisabled;
+            var _maxBatchInterval;
             dynamicProto(Sender, _this, function (_self, _base) {
                 _initDefaults();
                 _self.pause = function () {
@@ -5611,7 +6160,7 @@
                     if (_paused) {
                         _paused = false;
                         _retryAt = null;
-                        if (_self._buffer.size() > _self._senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 ]()) {
+                        if (_self[_DYN__BUFFER ].size() > _maxBatchSizeInBytes) {
                             _self[_DYN_TRIGGER_SEND ](true, null, 10 );
                         }
                         _setupTimer();
@@ -5631,7 +6180,7 @@
                 };
                 _self.onunloadFlush = function () {
                     if (!_paused) {
-                        if ((_self._senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ]() === false || _self[_DYN__SENDER_CONFIG ][_DYN_IS_BEACON_API_DISABL3 ]() === false) && isBeaconsSupported()) {
+                        if (_beaconSupported) {
                             try {
                                 _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
                             }
@@ -5652,7 +6201,6 @@
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 28 , "Sender is already initialized");
                     }
                     _base.initialize(config, core, extensions, pluginChain);
-                    var ctx = _self._getTelCtx();
                     var identifier = _self.identifier;
                     _serializer = new Serializer(core.logger);
                     _consecutiveErrors = 0;
@@ -5663,64 +6211,86 @@
                     var diagLog = _self[_DYN_DIAG_LOG ]();
                     _evtNamespace = mergeEvtNamespace(createUniqueNamespace("Sender"), core.evtNamespace && core.evtNamespace());
                     _offlineListener = createOfflineListener(_evtNamespace);
-                    var defaultConfig = _getDefaultAppInsightsChannelConfig();
-                    objForEachKey(defaultConfig, function (field, value) {
-                        _self[_DYN__SENDER_CONFIG ][field] = function () {
-                            var theValue = ctx.getConfig(identifier, field, value());
-                            if (!theValue && field === "endpointUrl") {
-                                theValue = value();
+                    _self._addHook(onConfigChange(config, function () {
+                        var ctx = createProcessTelemetryContext(null, config, core);
+                        var senderConfig = ctx.getExtCfg(identifier, defaultAppInsightsChannelConfig);
+                        objDefineProp(_self, "_senderConfig", {
+                            enumerable: true,
+                            configurable: true,
+                            get: function () {
+                                return senderConfig;
                             }
-                            return theValue;
-                        };
-                    });
-                    _self._buffer = (_self[_DYN__SENDER_CONFIG ][_DYN_ENABLE_SESSION_STORA4 ]() && utlCanUseSessionStorage())
-                        ? new SessionStorageSendBuffer(diagLog, _self[_DYN__SENDER_CONFIG ]) : new ArraySendBuffer(diagLog, _self[_DYN__SENDER_CONFIG ]);
-                    _self._sample = new Sample(_self[_DYN__SENDER_CONFIG ][_DYN_SAMPLING_PERCENTAGE ](), diagLog);
-                    if (!_validateInstrumentationKey(config)) {
-                        _throwInternal(diagLog, 1 , 100 , "Invalid Instrumentation key " + config[_DYN_INSTRUMENTATION_KEY ]);
-                    }
-                    if (!isInternalApplicationInsightsEndpoint(_self._senderConfig.endpointUrl()) && _self._senderConfig.customHeaders() && _self._senderConfig.customHeaders()[_DYN_LENGTH ] > 0) {
-                        arrForEach(_self[_DYN__SENDER_CONFIG ][_DYN_CUSTOM_HEADERS ](), function (customHeader) {
-                            _this.addHeader(customHeader.header, customHeader.value);
                         });
-                    }
-                    var senderConfig = _self[_DYN__SENDER_CONFIG ];
-                    var sendPostFunc = null;
-                    if (!senderConfig[_DYN_DISABLE_XHR ]() && useXDomainRequest()) {
-                        sendPostFunc = _xdrSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && isXhrSupported()) {
-                        sendPostFunc = _xhrSender;
-                    }
-                    if (!sendPostFunc && isFetchSupported()) {
-                        sendPostFunc = _fetchSender;
-                    }
-                    _fallbackSender = sendPostFunc || _xhrSender;
-                    if (!senderConfig[_DYN_IS_BEACON_API_DISABL3 ]() && isBeaconsSupported()) {
-                        sendPostFunc = _beaconSender;
-                    }
-                    _self[_DYN__SENDER ] = sendPostFunc || _xhrSender;
-                    if (!senderConfig[_DYN_ONUNLOAD_DISABLE_FET5 ]() && isFetchSupported(true)) {
-                        _syncUnloadSender = _fetchKeepAliveSender;
-                    }
-                    else if (isBeaconsSupported()) {
-                        _syncUnloadSender = _beaconSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && useXDomainRequest()) {
-                        _syncUnloadSender = _xdrSender;
-                    }
-                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && isXhrSupported()) {
-                        _syncUnloadSender = _xhrSender;
-                    }
-                    else {
-                        _syncUnloadSender = _fallbackSender;
-                    }
+                        _maxBatchSizeInBytes = senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 ];
+                        _beaconSupported = (senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ] === false || senderConfig[_DYN_IS_BEACON_API_DISABL3 ] === false) && isBeaconsSupported();
+                        if (_self[_DYN__BUFFER ]) ;
+                        else {
+                            _self[_DYN__BUFFER ] = (senderConfig[_DYN_ENABLE_SESSION_STORA4 ] && utlCanUseSessionStorage())
+                                ? new SessionStorageSendBuffer(diagLog, senderConfig) : new ArraySendBuffer(diagLog, senderConfig);
+                        }
+                        _self._sample = new Sample(senderConfig[_DYN_SAMPLING_PERCENTAGE ], diagLog);
+                        _instrumentationKey = senderConfig[_DYN_INSTRUMENTATION_KEY ];
+                        if (!_validateInstrumentationKey(_instrumentationKey, config)) {
+                            _throwInternal(diagLog, 1 , 100 , "Invalid Instrumentation key " + _instrumentationKey);
+                        }
+                        if (_orgEndpointUrl !== senderConfig.endpointUrl) {
+                            _endpointUrl = _orgEndpointUrl = senderConfig.endpointUrl;
+                        }
+                        if (_customHeaders && _customHeaders !== senderConfig[_DYN_CUSTOM_HEADERS ]) {
+                            arrForEach(_customHeaders, function (customHeader) {
+                                delete _headers[customHeader.header];
+                            });
+                        }
+                        _customHeaders = senderConfig[_DYN_CUSTOM_HEADERS ];
+                        if (!isInternalApplicationInsightsEndpoint(_endpointUrl) && _customHeaders && _customHeaders[_DYN_LENGTH ] > 0) {
+                            arrForEach(_customHeaders, function (customHeader) {
+                                _this.addHeader(customHeader.header, customHeader.value);
+                            });
+                        }
+                        else {
+                            _customHeaders = null;
+                        }
+                        var sendPostFunc = null;
+                        if (!senderConfig[_DYN_DISABLE_XHR ] && useXDomainRequest()) {
+                            sendPostFunc = _xdrSender;
+                        }
+                        else if (!senderConfig[_DYN_DISABLE_XHR ] && isXhrSupported()) {
+                            sendPostFunc = _xhrSender;
+                        }
+                        if (!sendPostFunc && isFetchSupported()) {
+                            sendPostFunc = _fetchSender;
+                        }
+                        _fallbackSender = sendPostFunc || _xhrSender;
+                        if (!senderConfig[_DYN_IS_BEACON_API_DISABL3 ] && isBeaconsSupported()) {
+                            sendPostFunc = _beaconSender;
+                        }
+                        _self[_DYN__SENDER ] = sendPostFunc || _xhrSender;
+                        if (!senderConfig[_DYN_ONUNLOAD_DISABLE_FET5 ] && isFetchSupported(true)) {
+                            _syncUnloadSender = _fetchKeepAliveSender;
+                        }
+                        else if (isBeaconsSupported()) {
+                            _syncUnloadSender = _beaconSender;
+                        }
+                        else if (!senderConfig[_DYN_DISABLE_XHR ] && useXDomainRequest()) {
+                            _syncUnloadSender = _xdrSender;
+                        }
+                        else if (!senderConfig[_DYN_DISABLE_XHR ] && isXhrSupported()) {
+                            _syncUnloadSender = _xhrSender;
+                        }
+                        else {
+                            _syncUnloadSender = _fallbackSender;
+                        }
+                        _disableTelemetry = senderConfig.disableTelemetry;
+                        _convertUndefined = senderConfig[_DYN_CONVERT_UNDEFINED ] || UNDEFINED_VALUE;
+                        _isRetryDisabled = senderConfig.isRetryDisabled;
+                        _maxBatchInterval = senderConfig[_DYN_MAX_BATCH_INTERVAL ];
+                    }));
                 };
                 _self.processTelemetry = function (telemetryItem, itemCtx) {
                     itemCtx = _self._getTelCtx(itemCtx);
                     var diagLogger = itemCtx[_DYN_DIAG_LOG ]();
                     try {
-                        if (_self[_DYN__SENDER_CONFIG ][_DYN_DISABLE_TELEMETRY ]()) {
+                        if (_disableTelemetry) {
                             return;
                         }
                         if (!telemetryItem) {
@@ -5745,9 +6315,8 @@
                         else {
                             telemetryItem[SampleRate] = _self._sample[_DYN_SAMPLE_RATE ];
                         }
-                        var convertUndefined = _self[_DYN__SENDER_CONFIG ][_DYN_CONVERT_UNDEFINED ]() || undefined;
-                        var defaultEnvelopeIkey = telemetryItem.iKey || _self[_DYN__SENDER_CONFIG ][_DYN_INSTRUMENTATION_KEY ]();
-                        var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, diagLogger, convertUndefined);
+                        var defaultEnvelopeIkey = telemetryItem.iKey || _instrumentationKey;
+                        var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, diagLogger, _convertUndefined);
                         if (!aiEnvelope_1) {
                             _throwInternal(diagLogger, 1 , 47 , "Unable to create an AppInsights envelope");
                             return;
@@ -5773,7 +6342,7 @@
                         var payload = _serializer.serialize(aiEnvelope_1);
                         var buffer = _self[_DYN__BUFFER ];
                         var bufferSize = buffer.size();
-                        if ((bufferSize + payload[_DYN_LENGTH ]) > _self[_DYN__SENDER_CONFIG ][_DYN_MAX_BATCH_SIZE_IN_BY1 ]()) {
+                        if ((bufferSize + payload[_DYN_LENGTH ]) > _maxBatchSizeInBytes) {
                             _self[_DYN_TRIGGER_SEND ](true, null, 10 );
                         }
                         buffer[_DYN_ENQUEUE ](payload);
@@ -5794,7 +6363,7 @@
                     if (!_paused) {
                         try {
                             var buffer = _self[_DYN__BUFFER ];
-                            if (!_self[_DYN__SENDER_CONFIG ][_DYN_DISABLE_TELEMETRY ]()) {
+                            if (!_disableTelemetry) {
                                 if (buffer[_DYN_COUNT ]() > 0) {
                                     var payload = buffer.getItems();
                                     _notifySendRequest(sendReason || 0 , async);
@@ -5868,7 +6437,7 @@
                     else {
                         var results = _parseResponse(responseText);
                         if (results && results.itemsReceived && results.itemsReceived > results[_DYN_ITEMS_ACCEPTED ]
-                            && !_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
+                            && !_isRetryDisabled) {
                             _self[_DYN__ON_PARTIAL_SUCCESS ](payload, results);
                         }
                         else {
@@ -5894,7 +6463,7 @@
                                 return;
                             }
                         }
-                        if (!_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]() && _isRetriable(status)) {
+                        if (!_isRetryDisabled && _isRetriable(status)) {
                             _resendPayload(payload);
                             _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
                                 "Response code " + status + ". Will retry to send " + payload[_DYN_LENGTH ] + " items.");
@@ -5904,7 +6473,7 @@
                         }
                     }
                     else if (_offlineListener && !_offlineListener.isOnline()) {
-                        if (!_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
+                        if (!_isRetryDisabled) {
                             var offlineBackOffMultiplier = 10;
                             _resendPayload(payload, offlineBackOffMultiplier);
                             _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". Offline - Response Code: ".concat(status, ". Offline status: ").concat(!_offlineListener.isOnline(), ". Will retry to send ").concat(payload.length, " items."));
@@ -5916,7 +6485,7 @@
                             if (!response) {
                                 response = _parseResponse(res);
                             }
-                            if (response && !_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
+                            if (response && !_isRetryDisabled) {
                                 _self[_DYN__ON_PARTIAL_SUCCESS ](payload, response);
                             }
                             else {
@@ -5934,8 +6503,8 @@
                         return false;
                     }
                     if (!isNullOrUndefined(responseUrl) && responseUrl !== "") {
-                        if (responseUrl !== _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]()) {
-                            _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ] = function () { return responseUrl; };
+                        if (responseUrl !== _endpointUrl) {
+                            _endpointUrl = responseUrl;
                             ++_stamp_specific_redirects;
                             return true;
                         }
@@ -5953,7 +6522,7 @@
                 function _doBeaconSend(payload) {
                     var nav = getNavigator();
                     var buffer = _self[_DYN__BUFFER ];
-                    var url = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
+                    var url = _endpointUrl;
                     var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                     var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
                     var queued = nav.sendBeacon(url, plainTextBatch);
@@ -5982,7 +6551,7 @@
                 }
                 function _xhrSender(payload, isAsync) {
                     var xhr = new XMLHttpRequest();
-                    var endPointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
+                    var endPointUrl = _endpointUrl;
                     try {
                         xhr[DisabledPropertyName] = true;
                     }
@@ -6025,7 +6594,7 @@
                 }
                 function _doFetchSender(payload, isAsync) {
                     var _a;
-                    var endPointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
+                    var endPointUrl = _endpointUrl;
                     var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                     var plainTextBatch = new Blob([batch], { type: "application/json" });
                     var requestHeaders = new Headers();
@@ -6146,7 +6715,7 @@
                 function _setupTimer() {
                     if (!_timeoutHandle && !_paused) {
                         var retryInterval = _retryAt ? Math.max(0, _retryAt - dateNow()) : 0;
-                        var timerValue = Math.max(_self[_DYN__SENDER_CONFIG ][_DYN_MAX_BATCH_INTERVAL ](), retryInterval);
+                        var timerValue = Math.max(_maxBatchInterval, retryInterval);
                         _timeoutHandle = setTimeout(function () {
                             _timeoutHandle = null;
                             _self[_DYN_TRIGGER_SEND ](true, null, 1 );
@@ -6181,13 +6750,13 @@
                     xdr.onload = function () { return _self._xdrOnLoad(xdr, payload); };
                     xdr.onerror = function (event) { return _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr), event); };
                     var hostingProtocol = _window && _window.location && _window.location.protocol || "";
-                    if (_self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]().lastIndexOf(hostingProtocol, 0) !== 0) {
+                    if (_endpointUrl.lastIndexOf(hostingProtocol, 0) !== 0) {
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
                             "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
                         buffer[_DYN_CLEAR ]();
                         return;
                     }
-                    var endpointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]().replace(/^(https?:)/, "");
+                    var endpointUrl = _endpointUrl.replace(/^(https?:)/, "");
                     xdr.open("POST", endpointUrl);
                     var batch = buffer[_DYN_BATCH_PAYLOADS ](payload);
                     xdr.send(batch);
@@ -6217,14 +6786,15 @@
                         }
                     }
                 }
-                function _validateInstrumentationKey(config) {
-                    var disableIKeyValidationFlag = isNullOrUndefined(config[_DYN_DISABLE_INSTRUMENTAT7 ]) ? false : config[_DYN_DISABLE_INSTRUMENTAT7 ];
+                function _validateInstrumentationKey(instrumentationKey, config) {
+                    var disableValidation = config.disableInstrumentationKeyValidation;
+                    var disableIKeyValidationFlag = isNullOrUndefined(disableValidation) ? false : disableValidation;
                     if (disableIKeyValidationFlag) {
                         return true;
                     }
                     var UUID_Regex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
                     var regexp = new RegExp(UUID_Regex);
-                    return regexp.test(config[_DYN_INSTRUMENTATION_KEY ]);
+                    return regexp.test(instrumentationKey);
                 }
                 function _initDefaults() {
                     _self[_DYN__SENDER ] = null;
@@ -6244,6 +6814,22 @@
                     _fallbackSender = null;
                     _syncUnloadSender = null;
                     _evtNamespace = null;
+                    _endpointUrl = null;
+                    _orgEndpointUrl = null;
+                    _maxBatchSizeInBytes = 0;
+                    _beaconSupported = false;
+                    _customHeaders = null;
+                    _disableTelemetry = false;
+                    _instrumentationKey = null;
+                    _convertUndefined = UNDEFINED_VALUE;
+                    _isRetryDisabled = false;
+                    objDefineProp(_self, "_senderConfig", {
+                        enumerable: true,
+                        configurable: true,
+                        get: function () {
+                            return objExtend({}, defaultAppInsightsChannelConfig);
+                        }
+                    });
                 }
             });
             return _this;
@@ -6273,7 +6859,11 @@
                 throwError("Invalid input configuration");
             }
             dynamicProto(ApplicationInsights, this, function (_self) {
-                _self.config = config;
+                objDefineProp(_self, "config", {
+                    configurable: true,
+                    enumerable: true,
+                    get: function () { return config; }
+                });
                 _initialize();
                 _self[_DYN_INITIALIZE ] = _initialize;
                 _self.getSKUDefaults = function () {
@@ -6310,7 +6900,6 @@
     exports.ApplicationInsights = ApplicationInsights;
     exports.Sender = Sender;
     exports.SeverityLevel = SeverityLevel;
-    exports._InternalMessageId = _InternalMessageId;
     exports.arrForEach = arrForEach;
     exports.isNullOrUndefined = isNullOrUndefined;
     exports.proxyFunctions = proxyFunctions;
@@ -6319,4 +6908,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-//# sourceMappingURL=aib.3.0.0-beta.2210-01.js.map
+//# sourceMappingURL=aib.3.0.0-beta.2210-02.js.map