@microsoft/applicationinsights-analytics-js 3.0.0-beta.2210-01 → 3.0.0-beta.2210-03

package/dist/applicationinsights-analytics-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Web Analytics, 3.0.0-beta.2210-01
+ * Application Insights JavaScript SDK - Web Analytics, 3.0.0-beta.2210-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -18,7 +18,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) {
@@ -348,7 +347,6 @@
 
     var UNDEF_VALUE = undefined;
     var EMPTY = "";
-    var BOOLEAN = "boolean";
     var FUNCTION = "function";
     var NUMBER = "number";
     var OBJECT = "object";
@@ -356,13 +354,19 @@
     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 MathCls = Math;
     var ArrCls = Array;
+    var ArrProto = ArrCls[PROTOTYPE];
 
     function _safeCheck(cb, defValue) {
         var result = defValue;
@@ -406,7 +410,6 @@
     }
     var isArray = ArrCls.isArray;
     var isNumber = _createIs(NUMBER);
-    var isBoolean = _createIs(BOOLEAN);
     var isError = _createObjIs("[object Error]");
     function isTruthy(value) {
         return !(!value || _safeCheck(function () { return !(value && (0 + value)); }, !value));
@@ -482,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)) {
@@ -514,6 +517,7 @@
         throw new TypeError(message);
     }
 
+    ObjClass["assign"];
     var _objFreeze = ObjClass["freeze"];
     function _doNothing(value) {
         return value;
@@ -526,7 +530,7 @@
     }
     function objDeepFreeze(value) {
         if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
+            objForEachKey$1(value, function (key, value) {
                 if (isArray(value) || isObject(value)) {
                     _objFreeze(value);
                 }
@@ -535,16 +539,76 @@
         return objFreeze(value);
     }
     var objFreeze = _objFreeze || _doNothing;
+    ObjClass["seal"] || _doNothing;
 
     function createEnum(values) {
         var theEnum = {};
-        objForEachKey(values, function (field, value) {
+        objForEachKey$1(values, function (field, value) {
             theEnum[field] = value;
             theEnum[value] = field;
         });
         return objDeepFreeze(theEnum);
     }
 
+    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 = "";
@@ -588,7 +652,7 @@
                 d.__proto__ = b;
             }) ||
             function (d, b) {
-                objForEachKey(b, function (key, value) {
+                objForEachKey$1(b, function (key, value) {
                     d[key] = value;
                 });
             };
@@ -652,7 +716,29 @@
         }
     }
 
+    var mathMax = MathCls.max;
+
+    var strSlice = _unwrapFunction("slice");
+
+    var SUB_STR = "substr";
     var strSubstring = _unwrapFunction("substring");
+    var strSubstr = StrProto[SUB_STR] ? _unwrapFunction(SUB_STR) : polyStrSubstr;
+    function polyStrSubstr(value, start, length) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError("'polyStrSubstr called with invalid " + dumpObj(value));
+        }
+        if (length < 0) {
+            return EMPTY;
+        }
+        start = start || 0;
+        if (start < 0) {
+            start = mathMax(start + value[LENGTH], 0);
+        }
+        if (isUndefined(length)) {
+            return strSlice(value, start);
+        }
+        return strSlice(value, start, start + length);
+    }
 
     var ENDS_WITH = "endsWith";
     var strEndsWith = StrProto[ENDS_WITH] ? _unwrapFunction(ENDS_WITH) : polyStrEndsWith;
@@ -669,6 +755,8 @@
 
     var strIndexOf = _unwrapFunction(INDEX_OF);
 
+    var asString = StrCls;
+
     function _createTrimFn(exp) {
         return function _doTrim(value) {
             if (isNullOrUndefined(value)) {
@@ -687,49 +775,54 @@
 
     var createEnumStyle = createEnum;
 
+    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 = "push";
     var _DYN_INITIALIZE = "initialize";
-    var _DYN_NAME$1 = "name";
     var _DYN_IDENTIFIER = "identifier";
-    var _DYN_PUSH = "push";
+    var _DYN_SPLICE = "splice";
     var _DYN_IS_INITIALIZED = "isInitialized";
-    var _DYN_CONFIG = "config";
-    var _DYN_LOGGER = "logger";
-    var _DYN_LENGTH$2 = "length";
+    var _DYN_NAME$1 = "name";
     var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_CALL = "call";
     var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_SPLICE = "splice";
+    var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
     var _DYN_TEARDOWN = "teardown";
     var _DYN_MESSAGE_ID = "messageId";
     var _DYN_MESSAGE$2 = "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_SUBSTR = "substr";
     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_IS_CHILD_EVT = "isChildEvt";
     var _DYN_GET_CTX = "getCtx";
     var _DYN_SET_CTX = "setCtx";
     var _DYN_COMPLETE = "complete";
 
+    var UNDEFINED_VALUE = undefined;
     var STR_EMPTY = "";
     var STR_CORE = "core";
     var STR_DISABLED = "disabled";
@@ -739,42 +832,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 _aiNamespace = null;
-    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;
-    }
-
-    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);
-    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);
     }
@@ -791,6 +861,7 @@
         }
         return value;
     }
+    var objForEachKey = objForEachKey$1;
     function strContains(value, search) {
         if (value && search) {
             return strIndexOf(value, search) !== -1;
@@ -805,7 +876,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;
@@ -814,7 +885,7 @@
         return result;
     }
     function toISOString(date) {
-        return _dateToISOString[_DYN_CALL ](date);
+        return date && date.toISOString() || "";
     }
     function dateNow() {
         var dt = Date;
@@ -837,9 +908,6 @@
         }
         return theValue;
     }
-    function getCfgValue(theValue, defaultValue) {
-        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-    }
     function _createProxyFunction(source, funcName) {
         var srcFunc = null;
         var src = null;
@@ -866,111 +934,621 @@
             }
         }
     }
-    function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
-        var theArgs = arguments;
-        var extended = theArgs[0] || {};
-        var argLen = theArgs[_DYN_LENGTH$2 ];
-        var deep = false;
-        var idx = 1;
-        if (argLen > 0 && isBoolean(extended)) {
-            deep = extended;
-            extended = theArgs[idx] || {};
-            idx++;
-        }
-        if (!isObject(extended)) {
-            extended = {};
-        }
-        for (; idx < argLen; idx++) {
-            var arg = theArgs[idx];
-            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)));
-                if (!propOk) {
-                    continue;
-                }
-                var newValue = arg[prop];
-                var isNewArray = void 0;
-                if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
-                    var clone = extended[prop];
-                    if (isNewArray) {
-                        if (!isArray(clone)) {
-                            clone = [];
-                        }
+
+    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 strLocation = "location";
+    var strConsole = "console";
+    var strPerformance = "performance";
+    var strJSON = "JSON";
+    var strCrypto = "crypto";
+    var strMsCrypto = "msCrypto";
+    var strMsie = "msie";
+    var strTrident = "trident/";
+    var _isTrident = null;
+    var _navUserAgentCheck = null;
+    var _enableMocks = false;
+    function getLocation(checkForMock) {
+        if (checkForMock && _enableMocks) {
+            var mockLocation = getInst("__mockLocation");
+            if (mockLocation) {
+                return mockLocation;
+            }
+        }
+        if (typeof location === strShimObject && location) {
+            return location;
+        }
+        return getInst(strLocation);
+    }
+    function getConsole() {
+        if (typeof console !== strShimUndefined) {
+            return console;
+        }
+        return getInst(strConsole);
+    }
+    function getPerformance() {
+        return getInst(strPerformance);
+    }
+    function hasJSON() {
+        return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
+    }
+    function getJSON() {
+        if (hasJSON()) {
+            return JSON || getInst(strJSON);
+        }
+        return null;
+    }
+    function getCrypto() {
+        return getInst(strCrypto);
+    }
+    function getMsCrypto() {
+        return getInst(strMsCrypto);
+    }
+    function isIE() {
+        var nav = getNavigator();
+        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+        }
+        return _isTrident;
+    }
+
+    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-03";
+    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;
                     }
-                    else if (!isPlainObject(clone)) {
-                        clone = {};
+                }
+            }
+            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) {
                     }
-                    newValue = objExtend(deep, clone, newValue);
                 }
-                if (newValue !== undefined) {
-                    extended[prop] = newValue;
+            }
+        };
+        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 ](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;
+                        });
+                    }
+                    else if (isArray(value)) {
+                        arrForEach(value, function (propValue, idx) {
+                            value[idx] = UNDEFINED_VALUE;
+                        });
+                    }
+                }
+                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 ](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);
             }
         }
-        return extended;
+        theState = (_a = {
+                prop: dynamicPropertySymbol,
+                ro: dynamicPropertyReadOnly,
+                hdlr: cfgHandler,
+                add: _addWatcher
+            },
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.use = _useHandler,
+            _a);
+        return theState;
     }
 
-    var strLocation = "location";
-    var strConsole = "console";
-    var strPerformance = "performance";
-    var strJSON = "JSON";
-    var strCrypto = "crypto";
-    var strMsCrypto = "msCrypto";
-    var strMsie = "msie";
-    var strTrident = "trident/";
-    var _isTrident = null;
-    var _navUserAgentCheck = null;
-    var _enableMocks = false;
-    function getLocation(checkForMock) {
-        if (checkForMock && _enableMocks) {
-            var mockLocation = getInst("__mockLocation");
-            if (mockLocation) {
-                return mockLocation;
+    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;
         }
-        if (typeof location === strShimObject && location) {
-            return location;
+        var uid = createUniqueNamespace("dyncfg", true);
+        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+        var theState;
+        function _notifyWatchers() {
+            theState[_DYN_NOTIFY ]();
         }
-        return getInst(strLocation);
-    }
-    function getConsole() {
-        if (typeof console !== strShimUndefined) {
-            return console;
+        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 getInst(strConsole);
-    }
-    function getPerformance() {
-        return getInst(strPerformance);
-    }
-    function hasJSON() {
-        return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
     }
-    function getJSON() {
-        if (hasJSON()) {
-            return JSON || getInst(strJSON);
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamic = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            applyDefaults(dynamic.cfg, defaultConfig);
         }
-        return null;
+        return dynamic;
     }
-    function getCrypto() {
-        return getInst(strCrypto);
+    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);
     }
-    function getMsCrypto() {
-        return getInst(strMsCrypto);
+
+    var _aiNamespace = null;
+    function _getExtensionNamespace() {
+        var target = getInst("Microsoft");
+        if (target) {
+            _aiNamespace = target["ApplicationInsights"];
+        }
+        return _aiNamespace;
     }
-    function isIE() {
-        var nav = getNavigator();
-        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
-            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    function getDebugExt(config) {
+        var ns = _aiNamespace;
+        if (!ns && config.disableDbgExt !== true) {
+            ns = _aiNamespace || _getExtensionNamespace();
         }
-        return _isTrident;
+        return ns ? ns["ChromeDbgExt"] : null;
     }
 
+    var _a$3;
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
+    var defaultValues$2 = (_a$3 = {
+            loggingLevelConsole: 0,
+            loggingLevelTelemetry: 1,
+            maxMessageLimit: 25
+        },
+        _a$3[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = false,
+        _a$3);
     function _sanitizeDiagnosticText(text) {
         if (text) {
             return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
@@ -1026,8 +1604,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) {
@@ -1100,10 +1678,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;
@@ -1124,7 +1706,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);
@@ -1240,146 +1822,6 @@
         return func();
     }
 
-    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;
-    }
-
     function generateW3CId() {
         var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
         var oct = STR_EMPTY, tmp;
@@ -1396,14 +1838,14 @@
                     hexValues[tmp >> 28 & 0xF];
         }
         var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
-        return oct[_DYN_SUBSTR ](0, 8) + oct[_DYN_SUBSTR ](9, 4) + "4" + oct[_DYN_SUBSTR ](13, 3) + clockSequenceHi + oct[_DYN_SUBSTR ](16, 3) + oct[_DYN_SUBSTR ](19, 12);
+        return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
     }
 
     var INVALID_TRACE_ID = "00000000000000000000000000000000";
     var INVALID_SPAN_ID = "0000000000000000";
     function _isValid(value, len, invalidValue) {
         if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/);
+            return !!value.match(/^[\da-f]*$/i);
         }
         return false;
     }
@@ -1432,9 +1874,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;
         }
@@ -1445,12 +1890,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;
@@ -1497,48 +1942,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;
@@ -1551,27 +1999,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) {
@@ -1582,7 +2033,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);
         }
@@ -1591,7 +2042,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) {
@@ -1604,7 +2055,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);
         }
@@ -1767,11 +2218,11 @@
         return objFreeze(proxyChain);
     }
 
+    var _a$2, _b;
     var strToGMTString = "toGMTString";
     var strToUTCString = "toUTCString";
     var strCookie = "cookie";
     var strExpires = "expires";
-    var strEnabled = "enabled";
     var strIsCookieUseDisabled = "isCookieUseDisabled";
     var strDisableCookiesUsage = "disableCookiesUsage";
     var strConfigCookieMgr = "_ckMgr";
@@ -1781,6 +2232,18 @@
     var _doc = getDocument();
     var _cookieCache = {};
     var _globalCookieConfig = {};
+    var defaultConfig = objDeepFreeze((_a$2 = {},
+        _a$2[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+        _a$2.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+        _a$2.enabled = UNDEFINED_VALUE,
+        _a$2));
+    var rootDefaultConfig = (_b = {
+            cookieCfg: {},
+            cookieDomain: UNDEFINED_VALUE,
+            cookiePath: UNDEFINED_VALUE
+        },
+        _b[strDisableCookiesUsage] = UNDEFINED_VALUE,
+        _b);
     function _gblCookieMgr(config, logger) {
         var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
         if (!inst) {
@@ -1795,22 +2258,6 @@
         }
         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;
@@ -1831,8 +2278,8 @@
             cookieMgr = core.getCookieMgr();
         }
         else if (config) {
-            var cookieCfg = config[_DYN_COOKIE_CFG ];
-            if (cookieCfg[strConfigCookieMgr]) {
+            var cookieCfg = config.cookieCfg;
+            if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
                 cookieMgr = cookieCfg[strConfigCookieMgr];
             }
             else {
@@ -1845,10 +2292,35 @@
         return cookieMgr;
     }
     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);
+            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);
@@ -1871,7 +2343,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])) {
@@ -1897,9 +2369,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;
@@ -1907,7 +2378,7 @@
             get: function (name) {
                 var value = STR_EMPTY;
                 if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                    value = (cookieMgrConfig.getCookie || _getCookieValue)(name);
+                    value = _getCookieFn(name);
                 }
                 return value;
             },
@@ -1923,14 +2394,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;
@@ -1979,7 +2449,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;
@@ -2050,7 +2520,11 @@
         };
     }
 
+    var _a$1;
     var strGetPlugin = "getPlugin";
+    var defaultValues$1 = (_a$1 = {},
+        _a$1[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: [] },
+        _a$1);
     var BaseTelemetryPlugin = /** @class */ (function () {
         function BaseTelemetryPlugin() {
             var _self = this;
@@ -2086,7 +2560,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);
@@ -2129,12 +2608,7 @@
                 };
                 _self._addHook = function (hooks) {
                     if (hooks) {
-                        if (isArray(hooks)) {
-                            _hooks = _hooks.concat(hooks);
-                        }
-                        else {
-                            _hooks[_DYN_PUSH ](hooks);
-                        }
+                        arrAppend(_hooks, hooks);
                     }
                 };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
@@ -2175,9 +2649,7 @@
                 return itemCtx;
             }
             function _setDefaults(config, core, pluginChain) {
-                if (config) {
-                    setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
-                }
+                createDynamicConfig(config, defaultValues$1, core[_DYN_LOGGER ]);
                 if (!pluginChain && core) {
                     pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
                 }
@@ -2216,7 +2688,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;
     }
@@ -2612,7 +3084,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 ](value);
@@ -2632,7 +3104,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;
             });
@@ -2683,7 +3155,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] || "");
             }
@@ -2693,7 +3165,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) {
@@ -3496,7 +3968,7 @@
         ,
             _a);
         if (!isNullOrUndefined(customProperties)) {
-            objForEachKey(customProperties, function (prop, value) {
+            objForEachKey$1(customProperties, function (prop, value) {
                 telemetryItem.data[prop] = value;
             });
         }
@@ -3620,28 +4092,20 @@
     var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
 
     var _DYN_TO_STRING = "toString";
-    var _DYN_DISABLE_EXCEPTION_TR0 = "disableExceptionTracking";
-    var _DYN_AUTO_TRACK_PAGE_VISI1 = "autoTrackPageVisitTime";
-    var _DYN_OVERRIDE_PAGE_VIEW_D2 = "overridePageViewDuration";
-    var _DYN_ENABLE_UNHANDLED_PRO3 = "enableUnhandledPromiseRejectionTracking";
-    var _DYN_SAMPLING_PERCENTAGE = "samplingPercentage";
-    var _DYN_IS_STORAGE_USE_DISAB4 = "isStorageUseDisabled";
-    var _DYN_IS_BROWSER_LINK_TRAC5 = "isBrowserLinkTrackingEnabled";
-    var _DYN_ENABLE_AUTO_ROUTE_TR6 = "enableAutoRouteTracking";
-    var _DYN_NAME_PREFIX = "namePrefix";
-    var _DYN_DISABLE_FLUSH_ON_BEF7 = "disableFlushOnBeforeUnload";
+    var _DYN_IS_STORAGE_USE_DISAB0 = "isStorageUseDisabled";
+    var _DYN__ADD_HOOK = "_addHook";
     var _DYN_CORE = "core";
     var _DYN_DATA_TYPE = "dataType";
     var _DYN_ENVELOPE_TYPE = "envelopeType";
     var _DYN_DIAG_LOG = "diagLog";
     var _DYN_TRACK = "track";
     var _DYN_TRACK_PAGE_VIEW = "trackPageView";
-    var _DYN_TRACK_PREVIOUS_PAGE_9 = "trackPreviousPageVisit";
-    var _DYN_SEND_PAGE_VIEW_INTER10 = "sendPageViewInternal";
-    var _DYN_SEND_PAGE_VIEW_PERFO11 = "sendPageViewPerformanceInternal";
-    var _DYN_POPULATE_PAGE_VIEW_P12 = "populatePageViewPerformanceEvent";
+    var _DYN_TRACK_PREVIOUS_PAGE_1 = "trackPreviousPageVisit";
+    var _DYN_SEND_PAGE_VIEW_INTER2 = "sendPageViewInternal";
+    var _DYN_SEND_PAGE_VIEW_PERFO3 = "sendPageViewPerformanceInternal";
+    var _DYN_POPULATE_PAGE_VIEW_P4 = "populatePageViewPerformanceEvent";
     var _DYN_HREF = "href";
-    var _DYN_SEND_EXCEPTION_INTER13 = "sendExceptionInternal";
+    var _DYN_SEND_EXCEPTION_INTER5 = "sendExceptionInternal";
     var _DYN_EXCEPTION = "exception";
     var _DYN_ERROR = "error";
     var _DYN__ONERROR = "_onerror";
@@ -3649,22 +4113,23 @@
     var _DYN_LINE_NUMBER = "lineNumber";
     var _DYN_COLUMN_NUMBER = "columnNumber";
     var _DYN_MESSAGE = "message";
-    var _DYN__CREATE_AUTO_EXCEPTI14 = "CreateAutoException";
-    var _DYN_ADD_TELEMETRY_INITIA15 = "addTelemetryInitializer";
+    var _DYN__CREATE_AUTO_EXCEPTI6 = "CreateAutoException";
+    var _DYN_ADD_TELEMETRY_INITIA7 = "addTelemetryInitializer";
     var _DYN_DURATION = "duration";
     var _DYN_LENGTH = "length";
-    var _DYN_IS_PERFORMANCE_TIMIN16 = "isPerformanceTimingSupported";
-    var _DYN_GET_PERFORMANCE_TIMI17 = "getPerformanceTiming";
+    var _DYN_AUTO_UNHANDLED_PROMI8 = "autoUnhandledPromiseInstrumented";
+    var _DYN_IS_PERFORMANCE_TIMIN9 = "isPerformanceTimingSupported";
+    var _DYN_GET_PERFORMANCE_TIMI10 = "getPerformanceTiming";
     var _DYN_NAVIGATION_START = "navigationStart";
-    var _DYN_SHOULD_COLLECT_DURAT18 = "shouldCollectDuration";
-    var _DYN_IS_PERFORMANCE_TIMIN19 = "isPerformanceTimingDataReady";
+    var _DYN_SHOULD_COLLECT_DURAT11 = "shouldCollectDuration";
+    var _DYN_IS_PERFORMANCE_TIMIN12 = "isPerformanceTimingDataReady";
     var _DYN_GET_ENTRIES_BY_TYPE = "getEntriesByType";
     var _DYN_RESPONSE_START = "responseStart";
     var _DYN_REQUEST_START = "requestStart";
     var _DYN_LOAD_EVENT_END = "loadEventEnd";
     var _DYN_RESPONSE_END = "responseEnd";
     var _DYN_CONNECT_END = "connectEnd";
-    var _DYN_PAGE_VISIT_START_TIM20 = "pageVisitStartTime";
+    var _DYN_PAGE_VISIT_START_TIM13 = "pageVisitStartTime";
 
     var PageViewManager = /** @class */ (function () {
         function PageViewManager(appInsights, overridePageViewDuration, core, pageViewPerformanceManager) {
@@ -3717,18 +4182,18 @@
                         var location_1 = getLocation();
                         uri = pageView.uri = location_1 && location_1[_DYN_HREF ] || "";
                     }
-                    if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN16 ]()) {
-                        appInsights[_DYN_SEND_PAGE_VIEW_INTER10 ](pageView, customProperties);
+                    if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN9 ]()) {
+                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                         _flushChannels(true);
                         _throwInternal(_logger, 2 , 25 , "trackPageView: navigation timing API used for calculation of page duration is not supported in this browser. This page view will be collected without duration and timing info.");
                         return;
                     }
                     var pageViewSent = false;
                     var customDuration;
-                    var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI17 ]()[_DYN_NAVIGATION_START ];
+                    var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI10 ]()[_DYN_NAVIGATION_START ];
                     if (start > 0) {
                         customDuration = dateTimeUtilsDuration(start, +new Date);
-                        if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT18 ](customDuration)) {
+                        if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT11 ](customDuration)) {
                             customDuration = undefined;
                         }
                     }
@@ -3744,7 +4209,7 @@
                             }
                             customProperties[_DYN_DURATION ] = customDuration;
                         }
-                        appInsights[_DYN_SEND_PAGE_VIEW_INTER10 ](pageView, customProperties);
+                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                         _flushChannels(true);
                         pageViewSent = true;
                     }
@@ -3755,24 +4220,24 @@
                     _addQueue(function () {
                         var processed = false;
                         try {
-                            if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN19 ]()) {
+                            if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN12 ]()) {
                                 processed = true;
                                 var pageViewPerformance = {
                                     name: name,
                                     uri: uri
                                 };
-                                pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P12 ](pageViewPerformance);
+                                pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P4 ](pageViewPerformance);
                                 if (!pageViewPerformance.isValid && !pageViewSent) {
                                     customProperties[_DYN_DURATION ] = customDuration;
-                                    appInsights[_DYN_SEND_PAGE_VIEW_INTER10 ](pageView, customProperties);
+                                    appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                                 }
                                 else {
                                     if (!pageViewSent) {
                                         customProperties[_DYN_DURATION ] = pageViewPerformance.durationMs;
-                                        appInsights[_DYN_SEND_PAGE_VIEW_INTER10 ](pageView, customProperties);
+                                        appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                                     }
                                     if (!pageViewPerformanceSent) {
-                                        appInsights[_DYN_SEND_PAGE_VIEW_PERFO11 ](pageViewPerformance, customProperties);
+                                        appInsights[_DYN_SEND_PAGE_VIEW_PERFO3 ](pageViewPerformance, customProperties);
                                         pageViewPerformanceSent = true;
                                     }
                                 }
@@ -3781,7 +4246,7 @@
                                 processed = true;
                                 if (!pageViewSent) {
                                     customProperties[_DYN_DURATION ] = maxDurationLimit;
-                                    appInsights[_DYN_SEND_PAGE_VIEW_INTER10 ](pageView, customProperties);
+                                    appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                                 }
                             }
                         }
@@ -3873,7 +4338,7 @@
             var _this = this;
             var _logger = safeGetLogger(core);
             dynamicProto(PageViewPerformanceManager, this, function (_self) {
-                _self[_DYN_POPULATE_PAGE_VIEW_P12 ] = function (pageViewPerformance) {
+                _self[_DYN_POPULATE_PAGE_VIEW_P4 ] = function (pageViewPerformance) {
                     pageViewPerformance.isValid = false;
                     var navigationTiming = _getPerformanceNavigationTiming();
                     var timing = _getPerformanceTiming();
@@ -3900,7 +4365,7 @@
                         if (total === 0) {
                             _throwInternal(_logger, 2 , 10 , "error calculating page view performance.", { total: total, network: network, request: request, response: response, dom: dom });
                         }
-                        else if (!_this[_DYN_SHOULD_COLLECT_DURAT18 ](total, network, request, response, dom)) {
+                        else if (!_this[_DYN_SHOULD_COLLECT_DURAT11 ](total, network, request, response, dom)) {
                             _throwInternal(_logger, 2 , 45 , "Invalid page load duration value. Browser perf data won't be sent.", { total: total, network: network, request: request, response: response, dom: dom });
                         }
                         else if (total < Math.floor(network) + Math.floor(request) + Math.floor(response) + Math.floor(dom)) {
@@ -3917,10 +4382,10 @@
                         }
                     }
                 };
-                _self[_DYN_GET_PERFORMANCE_TIMI17 ] = _getPerformanceTiming;
-                _self[_DYN_IS_PERFORMANCE_TIMIN16 ] = _isPerformanceTimingSupported;
-                _self[_DYN_IS_PERFORMANCE_TIMIN19 ] = _isPerformanceTimingDataReady;
-                _self[_DYN_SHOULD_COLLECT_DURAT18 ] = _shouldCollectDuration;
+                _self[_DYN_GET_PERFORMANCE_TIMI10 ] = _getPerformanceTiming;
+                _self[_DYN_IS_PERFORMANCE_TIMIN9 ] = _isPerformanceTimingSupported;
+                _self[_DYN_IS_PERFORMANCE_TIMIN12 ] = _isPerformanceTimingDataReady;
+                _self[_DYN_SHOULD_COLLECT_DURAT11 ] = _shouldCollectDuration;
             });
         }
         PageViewPerformanceManager.__ieDyn=1;
@@ -3931,7 +4396,7 @@
         function PageVisitTimeManager(logger, pageVisitTimeTrackingHandler) {
             var prevPageVisitDataKeyName = "prevPageVisitData";
             dynamicProto(PageVisitTimeManager, this, function (_self) {
-                _self[_DYN_TRACK_PREVIOUS_PAGE_9 ] = function (currentPageName, currentPageUrl) {
+                _self[_DYN_TRACK_PREVIOUS_PAGE_1 ] = function (currentPageName, currentPageUrl) {
                     try {
                         var prevPageVisitTimeData = restartPageVisitTimer(currentPageName, currentPageUrl);
                         if (prevPageVisitTimeData) {
@@ -3977,7 +4442,7 @@
                             var pageVisitDataJsonStr = utlGetSessionStorage(logger, prevPageVisitDataKeyName);
                             if (pageVisitDataJsonStr && hasJSON()) {
                                 prevPageVisitData = getJSON().parse(pageVisitDataJsonStr);
-                                prevPageVisitData.pageVisitTime = pageVisitEndTime - prevPageVisitData[_DYN_PAGE_VISIT_START_TIM20 ];
+                                prevPageVisitData.pageVisitTime = pageVisitEndTime - prevPageVisitData[_DYN_PAGE_VISIT_START_TIM13 ];
                                 utlRemoveSessionStorage(logger, prevPageVisitDataKeyName);
                             }
                         }
@@ -3997,7 +4462,7 @@
     }());
     var PageVisitData = /** @class */ (function () {
         function PageVisitData(pageName, pageUrl) {
-            this[_DYN_PAGE_VISIT_START_TIM20 ] = dateNow();
+            this[_DYN_PAGE_VISIT_START_TIM13 ] = dateNow();
             this.pageName = pageName;
             this.pageUrl = pageUrl;
         }
@@ -4031,6 +4496,7 @@
         return Timing;
     }());
 
+    var _a;
     var strEvent = "event";
     function _dispatchEvent(target, evnt) {
         if (target && target.dispatchEvent && evnt) {
@@ -4048,38 +4514,37 @@
         return error || "";
     }
     var MinMilliSeconds = 60000;
-    function _configMilliseconds(value, defValue) {
+    var defaultValues = objDeepFreeze((_a = {
+            sessionRenewalMs: { set: _chkConfigMilliseconds, v: 30 * 60 * 1000 },
+            sessionExpirationMs: { set: _chkConfigMilliseconds, v: 24 * 60 * 60 * 1000 },
+            disableExceptionTracking: { set: stringToBoolOrDefault },
+            autoTrackPageVisitTime: { set: stringToBoolOrDefault },
+            overridePageViewDuration: { set: stringToBoolOrDefault },
+            enableUnhandledPromiseRejectionTracking: { set: stringToBoolOrDefault }
+        },
+        _a[_DYN_AUTO_UNHANDLED_PROMI8 ] = false,
+        _a.samplingPercentage = { isVal: _chkSampling, v: 100 },
+        _a.isStorageUseDisabled = { set: stringToBoolOrDefault },
+        _a.isBrowserLinkTrackingEnabled = { set: stringToBoolOrDefault },
+        _a.enableAutoRouteTracking = { set: stringToBoolOrDefault },
+        _a.namePrefix = "",
+        _a.enableDebug = { set: stringToBoolOrDefault },
+        _a.disableFlushOnBeforeUnload = { set: stringToBoolOrDefault },
+        _a.disableFlushOnUnload = { set: stringToBoolOrDefault, fb: "disableFlushOnBeforeUnload" },
+        _a));
+    function _chkConfigMilliseconds(value, defValue) {
         value = value || defValue;
         if (value < MinMilliSeconds) {
             value = MinMilliSeconds;
         }
-        return value;
+        return +value;
     }
-    function _getDefaultConfig(config) {
-        if (!config) {
-            config = {};
-        }
-        config.sessionRenewalMs = _configMilliseconds(config.sessionRenewalMs, 30 * 60 * 1000);
-        config.sessionExpirationMs = _configMilliseconds(config.sessionExpirationMs, 24 * 60 * 60 * 1000);
-        config[_DYN_DISABLE_EXCEPTION_TR0 ] = stringToBoolOrDefault(config[_DYN_DISABLE_EXCEPTION_TR0 ]);
-        config[_DYN_AUTO_TRACK_PAGE_VISI1 ] = stringToBoolOrDefault(config[_DYN_AUTO_TRACK_PAGE_VISI1 ]);
-        config[_DYN_OVERRIDE_PAGE_VIEW_D2 ] = stringToBoolOrDefault(config[_DYN_OVERRIDE_PAGE_VIEW_D2 ]);
-        config[_DYN_ENABLE_UNHANDLED_PRO3 ] = stringToBoolOrDefault(config[_DYN_ENABLE_UNHANDLED_PRO3 ]);
-        if (isNaN(config[_DYN_SAMPLING_PERCENTAGE ]) || config[_DYN_SAMPLING_PERCENTAGE ] <= 0 || config[_DYN_SAMPLING_PERCENTAGE ] >= 100) {
-            config[_DYN_SAMPLING_PERCENTAGE ] = 100;
-        }
-        config[_DYN_IS_STORAGE_USE_DISAB4 ] = stringToBoolOrDefault(config[_DYN_IS_STORAGE_USE_DISAB4 ]);
-        config[_DYN_IS_BROWSER_LINK_TRAC5 ] = stringToBoolOrDefault(config[_DYN_IS_BROWSER_LINK_TRAC5 ]);
-        config[_DYN_ENABLE_AUTO_ROUTE_TR6 ] = stringToBoolOrDefault(config[_DYN_ENABLE_AUTO_ROUTE_TR6 ]);
-        config[_DYN_NAME_PREFIX ] = config[_DYN_NAME_PREFIX ] || "";
-        config.enableDebug = stringToBoolOrDefault(config.enableDebug);
-        config[_DYN_DISABLE_FLUSH_ON_BEF7 ] = stringToBoolOrDefault(config[_DYN_DISABLE_FLUSH_ON_BEF7 ]);
-        config.disableFlushOnUnload = stringToBoolOrDefault(config.disableFlushOnUnload, config[_DYN_DISABLE_FLUSH_ON_BEF7 ]);
-        return config;
+    function _chkSampling(value) {
+        return !isNaN(value) && value > 0 && value <= 100;
     }
     function _updateStorageUsage(extConfig) {
-        if (!isUndefined(extConfig[_DYN_IS_STORAGE_USE_DISAB4 ])) {
-            if (extConfig[_DYN_IS_STORAGE_USE_DISAB4 ]) {
+        if (!isUndefined(extConfig[_DYN_IS_STORAGE_USE_DISAB0 ])) {
+            if (extConfig[_DYN_IS_STORAGE_USE_DISAB0 ]) {
                 utlDisableStorage();
             }
             else {
@@ -4108,11 +4573,13 @@
             var _autoExceptionInstrumented;
             var _enableUnhandledPromiseRejectionTracking;
             var _autoUnhandledPromiseInstrumented;
+            var _extConfig;
+            var _autoTrackPageVisitTime;
             var _prevUri;
             var _currUri;
             var _evtNamespace;
             dynamicProto(AnalyticsPlugin, _this, function (_self, _base) {
-                var _addHook = _base._addHook;
+                var _addHook = _base[_DYN__ADD_HOOK ];
                 _initDefaults();
                 _self.getCookieMgr = function () {
                     return safeGetCookieMgr(_self[_DYN_CORE ]);
@@ -4167,15 +4634,15 @@
                     try {
                         var inPv = pageView || {};
                         _pageViewManager[_DYN_TRACK_PAGE_VIEW ](inPv, __assignFn(__assignFn(__assignFn({}, inPv.properties), inPv.measurements), customProperties));
-                        if (_self.config[_DYN_AUTO_TRACK_PAGE_VISI1 ]) {
-                            _pageVisitTimeManager[_DYN_TRACK_PREVIOUS_PAGE_9 ](inPv.name, inPv.uri);
+                        if (_autoTrackPageVisitTime) {
+                            _pageVisitTimeManager[_DYN_TRACK_PREVIOUS_PAGE_1 ](inPv.name, inPv.uri);
                         }
                     }
                     catch (e) {
                         _throwInternal(1 , 37 , "trackPageView failed, page view will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
                     }
                 };
-                _self[_DYN_SEND_PAGE_VIEW_INTER10 ] = function (pageView, properties, systemProperties) {
+                _self[_DYN_SEND_PAGE_VIEW_INTER2 ] = function (pageView, properties, systemProperties) {
                     var doc = getDocument();
                     if (doc) {
                         pageView.refUri = pageView.refUri === undefined ? doc.referrer : pageView.refUri;
@@ -4183,15 +4650,15 @@
                     var telemetryItem = createTelemetryItem(pageView, PageView[_DYN_DATA_TYPE ], PageView[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties, systemProperties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 };
-                _self[_DYN_SEND_PAGE_VIEW_PERFO11 ] = function (pageViewPerformance, properties, systemProperties) {
+                _self[_DYN_SEND_PAGE_VIEW_PERFO3 ] = function (pageViewPerformance, properties, systemProperties) {
                     var telemetryItem = createTelemetryItem(pageViewPerformance, PageViewPerformance[_DYN_DATA_TYPE ], PageViewPerformance[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties, systemProperties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 };
                 _self.trackPageViewPerformance = function (pageViewPerformance, customProperties) {
                     var inPvp = pageViewPerformance || {};
                     try {
-                        _pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P12 ](inPvp);
-                        _self[_DYN_SEND_PAGE_VIEW_PERFO11 ](inPvp, customProperties);
+                        _pageViewPerformanceManager[_DYN_POPULATE_PAGE_VIEW_P4 ](inPvp);
+                        _self[_DYN_SEND_PAGE_VIEW_PERFO3 ](inPvp, customProperties);
                     }
                     catch (e) {
                         _throwInternal(1 , 37 , "trackPageViewPerformance failed, page view will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -4220,15 +4687,15 @@
                             url = loc && loc[_DYN_HREF ] || "";
                         }
                         _pageTracking.stop(name, url, properties, measurement);
-                        if (_self.config[_DYN_AUTO_TRACK_PAGE_VISI1 ]) {
-                            _pageVisitTimeManager[_DYN_TRACK_PREVIOUS_PAGE_9 ](name, url);
+                        if (_autoTrackPageVisitTime) {
+                            _pageVisitTimeManager[_DYN_TRACK_PREVIOUS_PAGE_1 ](name, url);
                         }
                     }
                     catch (e) {
                         _throwInternal(1 , 32 , "stopTrackPage failed, page view will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
                     }
                 };
-                _self[_DYN_SEND_EXCEPTION_INTER13 ] = function (exception, customProperties, systemProperties) {
+                _self[_DYN_SEND_EXCEPTION_INTER5 ] = function (exception, customProperties, systemProperties) {
                     var theError = exception[_DYN_EXCEPTION ] || exception[_DYN_ERROR ] || new Error(strNotSpecified);
                     var exceptionPartB = new Exception(_self[_DYN_DIAG_LOG ](), theError, exception.properties || customProperties, exception.measurements, exception.severityLevel, exception.id).toInterface();
                     var telemetryItem = createTelemetryItem(exceptionPartB, Exception[_DYN_DATA_TYPE ], Exception[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), customProperties, systemProperties);
@@ -4239,7 +4706,7 @@
                         exception[_DYN_EXCEPTION ] = exception[_DYN_ERROR ];
                     }
                     try {
-                        _self[_DYN_SEND_EXCEPTION_INTER13 ](exception, customProperties);
+                        _self[_DYN_SEND_EXCEPTION_INTER5 ](exception, customProperties);
                     }
                     catch (e) {
                         _throwInternal(1 , 35 , "trackException failed, exception will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -4265,7 +4732,7 @@
                             message: exception[_DYN_MESSAGE ]
                         };
                         if (isCrossOriginError(exception.message, exception.url, exception.lineNumber, exception.columnNumber, exception[_DYN_ERROR ])) {
-                            _sendCORSException(Exception[_DYN__CREATE_AUTO_EXCEPTI14 ]("Script error: The browser's same-origin policy prevents us from getting the details of this exception. Consider using the 'crossorigin' attribute.", url, exception[_DYN_LINE_NUMBER ] || 0, exception[_DYN_COLUMN_NUMBER ] || 0, error, evt, null, errorSrc), properties);
+                            _sendCORSException(Exception[_DYN__CREATE_AUTO_EXCEPTI6 ]("Script error: The browser's same-origin policy prevents us from getting the details of this exception. Consider using the 'crossorigin' attribute.", url, exception[_DYN_LINE_NUMBER ] || 0, exception[_DYN_COLUMN_NUMBER ] || 0, error, evt, null, errorSrc), properties);
                         }
                         else {
                             if (!exception[_DYN_ERROR_SRC ]) {
@@ -4280,9 +4747,9 @@
                             + getExceptionName(e), { exception: dumpObj(e), errorString: errorString });
                     }
                 };
-                _self[_DYN_ADD_TELEMETRY_INITIA15 ] = function (telemetryInitializer) {
+                _self[_DYN_ADD_TELEMETRY_INITIA7 ] = function (telemetryInitializer) {
                     if (_self[_DYN_CORE ]) {
-                        return _self[_DYN_CORE ][_DYN_ADD_TELEMETRY_INITIA15 ](telemetryInitializer);
+                        return _self[_DYN_CORE ][_DYN_ADD_TELEMETRY_INITIA7 ](telemetryInitializer);
                     }
                     if (!_preInitTelemetryInitializers) {
                         _preInitTelemetryInitializers = [];
@@ -4301,16 +4768,14 @@
                         _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
                         if (_preInitTelemetryInitializers) {
                             arrForEach(_preInitTelemetryInitializers, function (initializer) {
-                                core[_DYN_ADD_TELEMETRY_INITIA15 ](initializer);
+                                core[_DYN_ADD_TELEMETRY_INITIA7 ](initializer);
                             });
                             _preInitTelemetryInitializers = null;
                         }
-                        var extConfig = _populateDefaults(config);
-                        _updateStorageUsage(extConfig);
+                        _populateDefaults(config);
                         _pageViewPerformanceManager = new PageViewPerformanceManager(_self[_DYN_CORE ]);
-                        _pageViewManager = new PageViewManager(_this, extConfig[_DYN_OVERRIDE_PAGE_VIEW_D2 ], _self[_DYN_CORE ], _pageViewPerformanceManager);
+                        _pageViewManager = new PageViewManager(_this, _extConfig.overridePageViewDuration, _self[_DYN_CORE ], _pageViewPerformanceManager);
                         _pageVisitTimeManager = new PageVisitTimeManager(_self[_DYN_DIAG_LOG ](), function (pageName, pageUrl, pageVisitTime) { return trackPageVisitTime(pageName, pageUrl, pageVisitTime); });
-                        _updateBrowserLinkTracking(extConfig, config);
                         _eventTracking = new Timing(_self[_DYN_DIAG_LOG ](), "trackEvent");
                         _eventTracking.action =
                             function (name, url, duration, properties, measurements) {
@@ -4335,11 +4800,11 @@
                                 properties: properties,
                                 measurements: measurements
                             };
-                            _self[_DYN_SEND_PAGE_VIEW_INTER10 ](pageViewItem, properties);
+                            _self[_DYN_SEND_PAGE_VIEW_INTER2 ](pageViewItem, properties);
                         };
                         if (hasWindow()) {
-                            _updateExceptionTracking(extConfig);
-                            _updateLocationChange(extConfig);
+                            _updateExceptionTracking();
+                            _updateLocationChange();
                         }
                     }
                     catch (e) {
@@ -4353,23 +4818,16 @@
                     _initDefaults();
                 };
                 function _populateDefaults(config) {
-                    var ctx = createProcessTelemetryContext(null, config, _self[_DYN_CORE ]);
                     var identifier = _self.identifier;
-                    var defaults = _getDefaultConfig(config);
-                    var extConfig = _self.config = ctx.getExtCfg(identifier);
-                    if (defaults !== undefined) {
-                        objForEachKey(defaults, function (field, value) {
-                            extConfig[field] = ctx.getConfig(identifier, field, value);
-                            if (extConfig[field] === undefined) {
-                                extConfig = value;
-                            }
-                        });
-                    }
-                    return extConfig;
-                }
-                function _updateBrowserLinkTracking(extConfig, config) {
-                    _isBrowserLinkTrackingEnabled = extConfig[_DYN_IS_BROWSER_LINK_TRAC5 ] || config[_DYN_IS_BROWSER_LINK_TRAC5 ];
-                    _addDefaultTelemetryInitializers();
+                    var core = _self[_DYN_CORE ];
+                    _self[_DYN__ADD_HOOK ](onConfigChange(config, function () {
+                        var ctx = createProcessTelemetryContext(null, config, core);
+                        _extConfig = ctx.getExtCfg(identifier, defaultValues);
+                        _autoTrackPageVisitTime = _extConfig.autoTrackPageVisitTime;
+                        _updateStorageUsage(_extConfig);
+                        _isBrowserLinkTrackingEnabled = _extConfig.isBrowserLinkTrackingEnabled;
+                        _addDefaultTelemetryInitializers();
+                    }));
                 }
                 function trackPageVisitTime(pageName, pageUrl, pageVisitTime) {
                     var properties = { PageName: pageName, PageUrl: pageUrl };
@@ -4397,7 +4855,7 @@
                             }
                             return true;
                         };
-                        _self[_DYN_ADD_TELEMETRY_INITIA15 ](dropBrowserLinkRequests);
+                        _self[_DYN__ADD_HOOK ](_self[_DYN_ADD_TELEMETRY_INITIA7 ](dropBrowserLinkRequests));
                         _browserLinkInitializerAdded = true;
                     }
                 }
@@ -4405,33 +4863,37 @@
                     var telemetryItem = createTelemetryItem(exception, Exception[_DYN_DATA_TYPE ], Exception[_DYN_ENVELOPE_TYPE ], _self[_DYN_DIAG_LOG ](), properties);
                     _self[_DYN_CORE ][_DYN_TRACK ](telemetryItem);
                 }
-                function _updateExceptionTracking(extConfig) {
+                function _updateExceptionTracking() {
                     var _window = getWindow();
                     var locn = getLocation(true);
-                    _disableExceptionTracking = extConfig[_DYN_DISABLE_EXCEPTION_TR0 ];
-                    if (!_disableExceptionTracking && !_autoExceptionInstrumented && !extConfig.autoExceptionInstrumented) {
-                        _addHook(InstrumentEvent(_window, "onerror", {
-                            ns: _evtNamespace,
-                            rsp: function (callDetails, message, url, lineNumber, columnNumber, error) {
-                                if (!_disableExceptionTracking && callDetails.rslt !== true) {
-                                    _self[_DYN__ONERROR ](Exception[_DYN__CREATE_AUTO_EXCEPTI14 ](message, url, lineNumber, columnNumber, error, callDetails.evt));
+                    _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
+                        _disableExceptionTracking = _extConfig.disableExceptionTracking;
+                        if (!_disableExceptionTracking && !_autoExceptionInstrumented && !_extConfig.autoExceptionInstrumented) {
+                            _addHook(InstrumentEvent(_window, "onerror", {
+                                ns: _evtNamespace,
+                                rsp: function (callDetails, message, url, lineNumber, columnNumber, error) {
+                                    if (!_disableExceptionTracking && callDetails.rslt !== true) {
+                                        _self[_DYN__ONERROR ](Exception[_DYN__CREATE_AUTO_EXCEPTI6 ](message, url, lineNumber, columnNumber, error, callDetails.evt));
+                                    }
                                 }
-                            }
-                        }, false));
-                        _autoExceptionInstrumented = true;
-                    }
-                    _addUnhandledPromiseRejectionTracking(extConfig, _window, locn);
+                            }, false));
+                            _autoExceptionInstrumented = true;
+                        }
+                    }));
+                    _addUnhandledPromiseRejectionTracking(_window, locn);
                 }
-                function _updateLocationChange(extConfig) {
+                function _updateLocationChange() {
                     var win = getWindow();
                     var locn = getLocation(true);
-                    _enableAutoRouteTracking = extConfig[_DYN_ENABLE_AUTO_ROUTE_TR6 ] === true;
-                    if (win && _enableAutoRouteTracking && hasHistory()) {
-                        var _history = getHistory();
-                        if (isFunction(_history.pushState) && isFunction(_history.replaceState) && typeof Event !== strShimUndefined) {
-                            _addHistoryListener(extConfig, win, _history, locn);
+                    _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
+                        _enableAutoRouteTracking = _extConfig.enableAutoRouteTracking === true;
+                        if (win && _enableAutoRouteTracking && !_historyListenerAdded && hasHistory()) {
+                            var _history = getHistory();
+                            if (isFunction(_history.pushState) && isFunction(_history.replaceState) && typeof Event !== strShimUndefined) {
+                                _addHistoryListener(win, _history, locn);
+                            }
                         }
-                    }
+                    }));
                 }
                 function _getDistributedTraceCtx() {
                     var distributedTraceCtx = null;
@@ -4449,8 +4911,11 @@
                     }
                     return distributedTraceCtx;
                 }
-                function _addHistoryListener(extConfig, win, history, locn) {
-                    var namePrefix = extConfig[_DYN_NAME_PREFIX ] || "";
+                function _addHistoryListener(win, history, locn) {
+                    if (_historyListenerAdded) {
+                        return;
+                    }
+                    var namePrefix = _extConfig.namePrefix || "";
                     function _popstateHandler() {
                         if (_enableAutoRouteTracking) {
                             _dispatchEvent(win, createDomEvent(namePrefix + "locationchange"));
@@ -4479,44 +4944,44 @@
                             }).bind(this, _prevUri), _self.autoRoutePVDelay);
                         }
                     }
-                    if (!_historyListenerAdded) {
-                        _addHook(InstrumentEvent(history, "pushState", {
-                            ns: _evtNamespace,
-                            rsp: function () {
-                                if (_enableAutoRouteTracking) {
-                                    _dispatchEvent(win, createDomEvent(namePrefix + "pushState"));
-                                    _dispatchEvent(win, createDomEvent(namePrefix + "locationchange"));
-                                }
+                    _addHook(InstrumentEvent(history, "pushState", {
+                        ns: _evtNamespace,
+                        rsp: function () {
+                            if (_enableAutoRouteTracking) {
+                                _dispatchEvent(win, createDomEvent(namePrefix + "pushState"));
+                                _dispatchEvent(win, createDomEvent(namePrefix + "locationchange"));
                             }
-                        }, true));
-                        _addHook(InstrumentEvent(history, "replaceState", {
-                            ns: _evtNamespace,
-                            rsp: function () {
-                                if (_enableAutoRouteTracking) {
-                                    _dispatchEvent(win, createDomEvent(namePrefix + "replaceState"));
-                                    _dispatchEvent(win, createDomEvent(namePrefix + "locationchange"));
-                                }
+                        }
+                    }, true));
+                    _addHook(InstrumentEvent(history, "replaceState", {
+                        ns: _evtNamespace,
+                        rsp: function () {
+                            if (_enableAutoRouteTracking) {
+                                _dispatchEvent(win, createDomEvent(namePrefix + "replaceState"));
+                                _dispatchEvent(win, createDomEvent(namePrefix + "locationchange"));
                             }
-                        }, true));
-                        eventOn(win, namePrefix + "popstate", _popstateHandler, _evtNamespace);
-                        eventOn(win, namePrefix + "locationchange", _locationChangeHandler, _evtNamespace);
-                        _historyListenerAdded = true;
-                    }
-                }
-                function _addUnhandledPromiseRejectionTracking(extConfig, _window, _location) {
-                    _enableUnhandledPromiseRejectionTracking = extConfig[_DYN_ENABLE_UNHANDLED_PRO3 ] === true;
-                    if (_enableUnhandledPromiseRejectionTracking && !_autoUnhandledPromiseInstrumented) {
-                        _addHook(InstrumentEvent(_window, "onunhandledrejection", {
-                            ns: _evtNamespace,
-                            rsp: function (callDetails, error) {
-                                if (_enableUnhandledPromiseRejectionTracking && callDetails.rslt !== true) {
-                                    _self[_DYN__ONERROR ](Exception[_DYN__CREATE_AUTO_EXCEPTI14 ](_getReason(error), _location ? _location[_DYN_HREF ] : "", 0, 0, error, callDetails.evt));
+                        }
+                    }, true));
+                    eventOn(win, namePrefix + "popstate", _popstateHandler, _evtNamespace);
+                    eventOn(win, namePrefix + "locationchange", _locationChangeHandler, _evtNamespace);
+                    _historyListenerAdded = true;
+                }
+                function _addUnhandledPromiseRejectionTracking(_window, _location) {
+                    _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
+                        _enableUnhandledPromiseRejectionTracking = _extConfig.enableUnhandledPromiseRejectionTracking === true;
+                        _autoExceptionInstrumented = _autoExceptionInstrumented || _extConfig[_DYN_AUTO_UNHANDLED_PROMI8 ];
+                        if (_enableUnhandledPromiseRejectionTracking && !_autoUnhandledPromiseInstrumented) {
+                            _addHook(InstrumentEvent(_window, "onunhandledrejection", {
+                                ns: _evtNamespace,
+                                rsp: function (callDetails, error) {
+                                    if (_enableUnhandledPromiseRejectionTracking && callDetails.rslt !== true) {
+                                        _self[_DYN__ONERROR ](Exception[_DYN__CREATE_AUTO_EXCEPTI6 ](_getReason(error), _location ? _location[_DYN_HREF ] : "", 0, 0, error, callDetails.evt));
+                                    }
                                 }
-                            }
-                        }, false));
-                        _autoUnhandledPromiseInstrumented = true;
-                        extConfig.autoUnhandledPromiseInstrumented = _autoUnhandledPromiseInstrumented;
-                    }
+                            }, false));
+                            _extConfig[_DYN_AUTO_UNHANDLED_PROMI8 ] = _autoUnhandledPromiseInstrumented = true;
+                        }
+                    }));
                 }
                 function _throwInternal(severity, msgId, msg, properties, isUserAct) {
                     _self[_DYN_DIAG_LOG ]().throwInternal(severity, msgId, msg, properties, isUserAct);
@@ -4536,10 +5001,17 @@
                     _autoExceptionInstrumented = false;
                     _enableUnhandledPromiseRejectionTracking = false;
                     _autoUnhandledPromiseInstrumented = false;
+                    _autoTrackPageVisitTime = false;
                     var location = getLocation(true);
                     _prevUri = location && location[_DYN_HREF ] || "";
                     _currUri = null;
                     _evtNamespace = null;
+                    _extConfig = null;
+                    objDefineProp(_self, "config", {
+                        configurable: true,
+                        enumerable: true,
+                        get: function () { return _extConfig; }
+                    });
                 }
                 objDefineAccessors(_self, "_pageViewManager", function () { return _pageViewManager; });
                 objDefineAccessors(_self, "_pageViewPerformanceManager", function () { return _pageViewPerformanceManager; });
@@ -4548,8 +5020,7 @@
             });
             return _this;
         }
-        AnalyticsPlugin.Version = "3.0.0-beta.2210-01";
-        AnalyticsPlugin.getDefaultConfig = _getDefaultConfig;
+        AnalyticsPlugin.Version = "3.0.0-beta.2210-03";
         return AnalyticsPlugin;
     }(BaseTelemetryPlugin));