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

package/dist/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.0.0-beta.2210-01
+ * Application Insights JavaScript SDK - Common, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -17,12 +17,15 @@
     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 ObjClass$1 = Object;
     var ObjProto$1 = ObjClass$1[PROTOTYPE];
     var StrCls = String;
     var StrProto = StrCls[PROTOTYPE];
+    var MathCls = Math;
     var ArrCls = Array;
 
     function _safeCheck(cb, defValue) {
@@ -129,7 +132,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)) {
@@ -173,7 +176,7 @@
     }
     function objDeepFreeze(value) {
         if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
+            objForEachKey$1(value, function (key, value) {
                 if (isArray(value) || isObject(value)) {
                     _objFreeze(value);
                 }
@@ -185,7 +188,7 @@
 
     function createEnum(values) {
         var theEnum = {};
-        objForEachKey(values, function (field, value) {
+        objForEachKey$1(values, function (field, value) {
             theEnum[field] = value;
             theEnum[value] = field;
         });
@@ -193,7 +196,7 @@
     }
     function createSimpleMap(values) {
         var mapClass = {};
-        objForEachKey(values, function (field, value) {
+        objForEachKey$1(values, function (field, value) {
             mapClass[field] = value[1];
             mapClass[value[0]] = value[1];
         });
@@ -203,6 +206,42 @@
         return createSimpleMap(values);
     }
 
+    var POLY_GLOBAL_REGISTORT = "__polySymbols$ts_utils";
+    var _polySymbols;
+    function _globalSymbolRegistry() {
+        if (!_polySymbols) {
+            var gbl = getGlobal$1();
+            _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 dumpObj(object, format) {
         var objectTypeDump = objToString(object);
         var propertyValueDump = "";
@@ -250,7 +289,7 @@
                 d.__proto__ = b;
             }) ||
             function (d, b) {
-                objForEachKey(b, function (key, value) {
+                objForEachKey$1(b, function (key, value) {
                     d[key] = value;
                 });
             };
@@ -285,8 +324,62 @@
         throw new _unsupportedError(message);
     }
 
+    var _objDefineProperty = ObjClass$1["defineProperty"];
+    function objDefineProp(target, key, descriptor) {
+        if (_objDefineProperty) {
+            _objDefineProperty(target, key, descriptor);
+            return target;
+        }
+        throwUnsupported("Unable to define property [" + objToString(key) + "] on " + dumpObj(target));
+    }
+    function objDefineAccessors(target, prop, getProp, setProp, configurable) {
+        if (_objDefineProperty) {
+            try {
+                var descriptor = {
+                    enumerable: true,
+                    configurable: isUndefined(configurable) ? true : configurable
+                };
+                if (getProp) {
+                    descriptor.get = getProp;
+                }
+                if (setProp) {
+                    descriptor.set = setProp;
+                }
+                return objDefineProp(target, prop, descriptor);
+            }
+            catch (e) {
+                throwUnsupported("Unable to define accessors for [" + objToString(prop) + "] on " + dumpObj(target));
+            }
+        }
+    }
+
+    var mathMax = MathCls.max;
+
+    var strSlice = _unwrapFunction("slice");
+
+    var SUB_STR = "substr";
+    var strSubstr = StrProto[SUB_STR] ? _unwrapFunction(SUB_STR) : polyStrSubstr;
+    function polyStrSubstr(value, start, length) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError$1("'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 strIndexOf = _unwrapFunction(INDEX_OF);
 
+    var asString = StrCls;
+
     function _createTrimFn(exp) {
         return function _doTrim(value) {
             if (isNullOrUndefined(value)) {
@@ -315,7 +408,6 @@
     var ObjProto = ObjClass[strShimPrototype];
     var ObjAssign = ObjClass["assign"];
     var ObjCreate = ObjClass["create"];
-    var ObjHasOwnProperty = ObjProto[strShimHasOwnProperty];
 
     var _cachedGlobal = null;
     function getGlobal(useCached) {
@@ -428,7 +520,7 @@
     function _isObjectArrayOrFunctionPrototype(target) {
         return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
     }
-    function _getObjProto(target) {
+    function _getObjProto$1(target) {
         var newProto;
         if (target) {
             if (_objGetPrototypeOf) {
@@ -502,7 +594,7 @@
         _forEachProp(instFuncs, function (name) {
             baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
         });
-        var baseProto = _getObjProto(classProto);
+        var baseProto = _getObjProto$1(classProto);
         var visited = [];
         while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
             _forEachProp(baseProto, function (name) {
@@ -511,7 +603,7 @@
                 }
             });
             visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
+            baseProto = _getObjProto$1(baseProto);
         }
         return baseFuncs;
     }
@@ -525,7 +617,7 @@
             }
             if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
                 var canAddInst = !_hasOwnProperty(target, funcName);
-                var objProto = _getObjProto(target);
+                var objProto = _getObjProto$1(target);
                 var visited = [];
                 while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
                     var protoFunc = objProto[funcName];
@@ -534,7 +626,7 @@
                         break;
                     }
                     visited.push(objProto);
-                    objProto = _getObjProto(objProto);
+                    objProto = _getObjProto$1(objProto);
                 }
                 try {
                     if (canAddInst) {
@@ -552,7 +644,7 @@
     function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
         var protoFunc = proto[funcName];
         if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
+            protoFunc = _getObjProto$1(proto)[funcName];
         }
         if (typeof protoFunc !== strFunction) {
             _throwTypeError("[" + funcName + "] is not a " + strFunction);
@@ -588,13 +680,13 @@
     function _checkPrototype(classProto, thisTarget) {
         if (_objGetPrototypeOf) {
             var visited = [];
-            var thisProto = _getObjProto(thisTarget);
+            var thisProto = _getObjProto$1(thisTarget);
             while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
                 if (thisProto === classProto) {
                     return true;
                 }
                 visited.push(thisProto);
-                thisProto = _getObjProto(thisProto);
+                thisProto = _getObjProto$1(thisProto);
             }
             return false;
         }
@@ -643,64 +735,85 @@
     };
     dynamicProto[DynProtoDefaultOptions] = perfDefaults;
 
-    var _DYN_NAME$1 = "name";
-    var _DYN_PUSH = "push";
     var _DYN_LENGTH$1 = "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_NAME$1 = "name";
+    var _DYN_CALL = "call";
+    var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
     var _DYN_MESSAGE_ID = "messageId";
     var _DYN_MESSAGE$1 = "message";
     var _DYN_DIAG_LOG = "diagLog";
     var _DYN_USER_AGENT = "userAgent";
-    var _DYN_SUBSTR = "substr";
     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_CALL = "call";
     var _DYN_TRACE_ID = "traceId";
     var _DYN_SPAN_ID = "spanId";
     var _DYN_TRACE_FLAGS = "traceFlags";
     var _DYN_VERSION = "version";
 
+    var UNDEFINED_VALUE = undefined;
     var STR_EMPTY = "";
     var STR_ERROR_TO_CONSOLE = "errorToConsole";
     var STR_WARN_TO_CONSOLE = "warnToConsole";
+    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 strToISOString = "toISOString";
     var strToString = "toString";
-    var DateProto = Date[strShimPrototype];
-    var _dateToISOString = DateProto[strToISOString] || _polyfillRequired("Date", strToISOString);
-    var _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
-    _fnToString[_DYN_CALL ](ObjClass);
-    function _polyfillRequired(object, name) {
-        return function () {
-            throwUnsupported("Polyfill required for [" + name + "]");
-        };
+    var strGetPrototypeOf = "getPrototypeOf";
+    var strConstructor = "constructor";
+    var _fnToString = ObjClass[strToString];
+    var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass);
+    var rCamelCase = /-([a-z])/g;
+    var rNormalizeInvalid = /([^\w\d_$])/g;
+    var rLeadingNumeric = /^(\d+[\w\d_$])/;
+    var _getObjProto = Object[strGetPrototypeOf];
+    function normalizeJsName(name) {
+        var value = name;
+        if (value && isString(value)) {
+            value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
+                return letter.toUpperCase();
+            });
+            value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
+            value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
+                return "_" + match;
+            });
+        }
+        return value;
     }
+    var objForEachKey = objForEachKey$1;
     function strContains(value, search) {
         if (value && search) {
             return strIndexOf(value, search) !== -1;
         }
         return false;
     }
+    function isPlainObject(value) {
+        var result = false;
+        if (value && typeof value === "object") {
+            var proto = _getObjProto(value);
+            if (!proto) {
+                result = true;
+            }
+            else {
+                if (proto[strConstructor] && objHasOwnProperty(proto, strConstructor)) {
+                    proto = proto[strConstructor];
+                }
+                result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
+            }
+        }
+        return result;
+    }
     function toISOString(date) {
-        return _dateToISOString[_DYN_CALL ](date);
+        return date && date.toISOString() || "";
     }
     function dateNow() {
         var dt = Date;
@@ -712,9 +825,6 @@
         }
         return STR_EMPTY;
     }
-    function getCfgValue(theValue, defaultValue) {
-        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-    }
     function createClassFromInterface(defaults) {
         return /** @class */ (function () {
             function class_1() {
@@ -729,6 +839,122 @@
         }());
     }
 
+    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+    function _cfgDeepCopy(source) {
+        if (source) {
+            if (isArray(source)) {
+                var result_1 = [];
+                result_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
+                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$1("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$1 ]; 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 strConsole = "console";
     var strPerformance = "performance";
     var strJSON = "JSON";
@@ -808,9 +1034,364 @@
         return value;
     }
 
+    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$1 ] < maxLength) {
+            chars++;
+            result += base64chars.charAt(number & 0x3F);
+            number >>>= 6;
+            if (chars === 5) {
+                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+                chars = 0;
+            }
+        }
+        return result;
+    }
+
+    var version = "3.0.0-beta.2210-02";
+    var instanceName = "." + newId(6);
+    var _dataUid = 0;
+    function createUniqueNamespace(name, includeVersion) {
+        if (includeVersion === void 0) { includeVersion = false; }
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+    }
+
+    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$1 ] > 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$1 ] > 0) {
+                if (!_waitingHandlers) {
+                    _waitingHandlers = [];
+                }
+                if (!_watcherTimer) {
+                    _watcherTimer = setTimeout(function () {
+                        _watcherTimer = null;
+                        _notifyWatchers();
+                    }, 0);
+                }
+                _insertWatcher(_waitingHandlers, detail);
+            }
+        }
+        theState = (_a = {
+                prop: dynamicPropertySymbol,
+                ro: dynamicPropertyReadOnly,
+                hdlr: cfgHandler,
+                add: _addWatcher
+            },
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.use = _useHandler,
+            _a);
+        return theState;
+    }
+
+    function _createAndUseHandler(state, configHandler) {
+        var handler = {
+            fn: configHandler,
+            rm: function () {
+                handler.fn = null;
+                state = null;
+                configHandler = null;
+            }
+        };
+        state.use(handler, configHandler);
+        return handler;
+    }
+    function _createDynamicHandler(logger, target, inPlace) {
+        var _a, _b;
+        var dynamicConfig = getDynamicConfigHandler(target);
+        if (dynamicConfig) {
+            return dynamicConfig;
+        }
+        var uid = createUniqueNamespace("dyncfg", true);
+        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+        var theState;
+        function _notifyWatchers() {
+            theState[_DYN_NOTIFY ]();
+        }
+        function _setValue(target, name, value) {
+            return _setDynamicProperty(theState, target, name, value);
+        }
+        function _watch(configHandler) {
+            return _createAndUseHandler(theState, configHandler);
+        }
+        function _block(configHandler) {
+            theState.use(null, configHandler);
+        }
+        var cfgHandler = (_a = {
+                uid: null,
+                cfg: newTarget
+            },
+            _a[_DYN_LOGGER ] = logger,
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.set = _setValue,
+            _a[_DYN_WATCH ] = _watch,
+            _a._block = _block,
+            _a);
+        objDefineProp(cfgHandler, "uid", (_b = {},
+            _b[_DYN_CONFIGURABLE ] = false,
+            _b[_DYN_ENUMERABLE ] = false,
+            _b.writable = false,
+            _b.value = uid,
+            _b));
+        theState = _createState(cfgHandler);
+        _makeDynamicObject(theState, newTarget);
+        return cfgHandler;
+    }
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamic = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            applyDefaults(dynamic.cfg, defaultConfig);
+        }
+        return 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 _a;
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
+    var defaultValues = (_a = {
+            loggingLevelConsole: 0,
+            loggingLevelTelemetry: 1,
+            maxMessageLimit: 25
+        },
+        _a[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = false,
+        _a);
     function _sanitizeDiagnosticText(text) {
         if (text) {
             return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
@@ -863,8 +1444,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) {
@@ -937,10 +1518,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, _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;
@@ -961,58 +1546,7 @@
     }
     function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
         if (isUserAct === void 0) { isUserAct = false; }
-        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
-    }
-
-    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;
+        _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
     }
 
     function generateW3CId() {
@@ -1031,10 +1565,10 @@
                     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 TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]*)?$/;
+    var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
     var DEFAULT_VERSION = "00";
     var INVALID_VERSION = "ff";
     var INVALID_TRACE_ID = "00000000000000000000000000000000";
@@ -1042,7 +1576,7 @@
     var SAMPLED_FLAG = 0x01;
     function _isValid(value, len, invalidValue) {
         if (value && value[_DYN_LENGTH$1 ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/);
+            return !!value.match(/^[\da-f]*$/i);
         }
         return false;
     }
@@ -1067,7 +1601,7 @@
         return _a = {},
             _a[_DYN_VERSION ] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
             _a[_DYN_TRACE_ID ] = isValidTraceId(traceId) ? traceId : generateW3CId(),
-            _a.spanId = isValidSpanId(spanId) ? spanId : generateW3CId()[_DYN_SUBSTR ](0, 16),
+            _a[_DYN_SPAN_ID ] = isValidSpanId(spanId) ? spanId : generateW3CId().substr(0, 16),
             _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,
             _a;
     }
@@ -1089,10 +1623,11 @@
             match[3] === INVALID_SPAN_ID) {
             return null;
         }
-        return _a = {},
-            _a[_DYN_VERSION ] = match[1],
-            _a[_DYN_TRACE_ID ] = match[2],
-            _a[_DYN_SPAN_ID ] = match[3],
+        return _a = {
+                version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+                traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+                spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]()
+            },
             _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
             _a;
     }
@@ -1128,7 +1663,7 @@
             if (version !== "00" && version !== "ff") {
                 version = DEFAULT_VERSION;
             }
-            return "".concat(version, "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID), "-").concat(flags);
+            return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
         }
         return "";
     }
@@ -1260,7 +1795,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);
@@ -1280,7 +1815,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;
             });
@@ -1353,7 +1888,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 ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH ] > 0) {
                 return match[2] + (match[3] || "");
             }
@@ -1363,7 +1898,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 ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH ] > 0) {
                 result = match[2] || "";
                 if (inclPort && match[_DYN_LENGTH ] > 2) {
@@ -2431,7 +2966,7 @@
         ,
             _a);
         if (!isNullOrUndefined(customProperties)) {
-            objForEachKey(customProperties, function (prop, value) {
+            objForEachKey$1(customProperties, function (prop, value) {
                 telemetryItem.data[prop] = value;
             });
         }
@@ -2577,7 +3112,7 @@
     function utlGetSessionStorageKeys() {
         var keys = [];
         if (utlCanUseSessionStorage()) {
-            objForEachKey(getInst("sessionStorage"), function (key) {
+            objForEachKey$1(getInst("sessionStorage"), function (key) {
                 keys.push(key);
             });
         }