@microsoft/applicationinsights-react-native 4.0.0-nightly.2306-02 → 4.0.1-nightly.2307-21

package/browser/applicationinsights-react-native.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - React Native Plugin, 4.0.0-nightly.2306-02
+ * Application Insights JavaScript SDK - React Native Plugin, 4.0.1-nightly.2307-21
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -16,108 +16,182 @@
     var strShimObject = "object";
     var strShimUndefined = "undefined";
     var strShimPrototype = "prototype";
-    var strShimHasOwnProperty = "hasOwnProperty";
     var ObjClass$1 = Object;
-    var ObjProto$1 = ObjClass$1[strShimPrototype];
-    var ObjCreate = ObjClass$1["create"];
-    var ObjDefineProperty = ObjClass$1["defineProperty"];
-    var ObjHasOwnProperty = ObjProto$1[strShimHasOwnProperty];
 
-    var _cachedGlobal = null;
-    function getGlobal(useCached) {
-        if (useCached === void 0) { useCached = true; }
-        var result = useCached === false ? null : _cachedGlobal;
-        if (!result) {
-            if (typeof globalThis !== strShimUndefined) {
-                result = globalThis;
-            }
-            if (!result && typeof self !== strShimUndefined) {
-                result = self;
-            }
-            if (!result && typeof window !== strShimUndefined) {
-                result = window;
-            }
-            if (!result && typeof global !== strShimUndefined) {
-                result = global;
-            }
-            _cachedGlobal = result;
+    var UNDEF_VALUE = undefined;
+    var NULL_VALUE = null;
+    var EMPTY = "";
+    var FUNCTION = "function";
+    var NUMBER = "number";
+    var OBJECT = "object";
+    var PROTOTYPE = "prototype";
+    var __PROTO__ = "__proto__";
+    var STRING = "string";
+    var UNDEFINED = "undefined";
+    var CONSTRUCTOR = "constructor";
+    var SYMBOL = "Symbol";
+    var POLYFILL_TAG = "_polyfill";
+    var INDEX_OF = "indexOf";
+    var LAST_INDEX_OF = "lastIndexOf";
+    var LENGTH = "length";
+    var DONE = "done";
+    var VALUE = "value";
+    var NAME = "name";
+    var SLICE = "slice";
+    var ObjClass = Object;
+    var ObjProto = ObjClass[PROTOTYPE];
+    var StrCls = String;
+    var StrProto = StrCls[PROTOTYPE];
+    var ArrCls = Array;
+    var ArrProto = ArrCls[PROTOTYPE];
+
+    function safeGet(cb, defValue) {
+        var result = defValue;
+        try {
+            result = cb();
+        }
+        catch (e) {
         }
         return result;
     }
-    function throwTypeError$1(message) {
-        throw new TypeError(message);
+
+    function _createIs(theType) {
+        return function (value) {
+            return typeof value === theType;
+        };
     }
-    function objCreateFn(obj) {
-        var func = ObjCreate;
-        if (func) {
-            return func(obj);
-        }
-        if (obj == null) {
-            return {};
-        }
-        var type = typeof obj;
-        if (type !== strShimObject && type !== strShimFunction) {
-            throwTypeError$1("Object prototype may only be an Object:" + obj);
+    function _createObjIs(theName) {
+        var theType = "[object " + theName + "]";
+        return function (value) {
+            return !!(value && objToString(value) === theType);
+        };
+    }
+    function objToString(value) {
+        return ObjProto.toString.call(value);
+    }
+    function isUndefined(value) {
+        return typeof value === UNDEFINED || value === UNDEFINED;
+    }
+    function isNullOrUndefined(value) {
+        return value === NULL_VALUE || isUndefined(value);
+    }
+    function isStrictNullOrUndefined(value) {
+        return value === NULL_VALUE || !isDefined(value);
+    }
+    function isDefined(arg) {
+        return !!arg || arg !== UNDEF_VALUE;
+    }
+    var isString = _createIs(STRING);
+    var isFunction = _createIs(FUNCTION);
+    function isObject(value) {
+        if (!value && isNullOrUndefined(value)) {
+            return false;
         }
-        function tmpFunc() { }
-        tmpFunc[strShimPrototype] = obj;
-        return new tmpFunc();
+        return !!value && typeof value === OBJECT;
+    }
+    var isArray = ArrCls.isArray;
+    var isNumber = _createIs(NUMBER);
+    var isError = _createObjIs("Error");
+    function isPromiseLike(value) {
+        return !!value && isFunction(value.then);
     }
 
-    (getGlobal() || {})["Symbol"];
-    (getGlobal() || {})["Reflect"];
-    var extendStaticsFn = function (d, b) {
-        extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
-            ({ __proto__: [] } instanceof Array && function (d, b) {
-                d.__proto__ = b;
-            }) ||
-            function (d, b) {
-                for (var p in b) {
-                    if (b[strShimHasOwnProperty](p)) {
-                        d[p] = b[p];
+    var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
+
+    function objHasOwnProperty(obj, prop) {
+        return obj && ObjProto.hasOwnProperty.call(obj, prop);
+    }
+
+    var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
+    function polyObjHasOwn(obj, prop) {
+        return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+    }
+
+    function objForEachKey(theObject, callbackfn, thisArg) {
+        if (theObject && isObject(theObject)) {
+            for (var prop in theObject) {
+                if (objHasOwn(theObject, prop)) {
+                    if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                        break;
                     }
                 }
-            };
-        return extendStaticsFn(d, b);
-    };
-    function __extendsFn(d, b) {
-        if (typeof b !== strShimFunction && b !== null) {
-            throwTypeError$1("Class extends value " + String(b) + " is not a constructor or null");
+            }
         }
-        extendStaticsFn(d, b);
-        function __() {
-            this.constructor = d;
+    }
+
+    function _createKeyValueMap(values, keyType, valueType, completeFn) {
+        var theMap = {};
+        objForEachKey(values, function (key, value) {
+            theMap[key] = keyType ? value : key;
+            theMap[value] = valueType ? value : key;
+        });
+        return completeFn(theMap);
+    }
+
+    function throwTypeError(message) {
+        throw new TypeError(message);
+    }
+
+    function polyObjEntries(value) {
+        var result = [];
+        objForEachKey(value, function (key, value) {
+            result.push([key, value]);
+        });
+        return result;
+    }
+    function polyObjValues(value) {
+        var result = [];
+        objForEachKey(value, function (key, value) {
+            result.push(value);
+        });
+        return result;
+    }
+
+    var _objFreeze = ObjClass["freeze"];
+    var _doNothing = function (value) { return value; };
+    var _getProto = function (value) { return value[__PROTO__] || NULL_VALUE; };
+    ObjClass["assign"];
+    function objDeepFreeze(value) {
+        if (_objFreeze) {
+            objForEachKey(value, function (key, value) {
+                if (isArray(value) || isObject(value)) {
+                    _objFreeze(value);
+                }
+            });
         }
-        d[strShimPrototype] = b === null ? objCreateFn(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+        return objFreeze(value);
     }
+    var objFreeze = _objFreeze || _doNothing;
+    ObjClass["seal"] || _doNothing;
+    var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _getProto;
+    ObjClass.entries || polyObjEntries;
+    ObjClass.values || polyObjValues;
 
-    /*!
-     * Microsoft Dynamic Proto Utility, 1.1.9
-     * Copyright (c) Microsoft and contributors. All rights reserved.
-     */
-    var _a;
-    var UNDEFINED = "undefined";
-    var Constructor = 'constructor';
-    var Prototype = 'prototype';
-    var strFunction = 'function';
-    var DynInstFuncTable = '_dynInstFuncs';
-    var DynProxyTag = '_isDynProxy';
-    var DynClassName = '_dynClass';
-    var DynClassNamePrefix = '_dynCls$';
-    var DynInstChkTag = '_dynInstChk';
-    var DynAllowInstChkTag = DynInstChkTag;
-    var DynProtoDefaultOptions = '_dfOpts';
-    var UnknownValue = '_unknown_';
-    var str__Proto$1 = "__proto__";
-    var DynProtoBaseProto = "_dyn" + str__Proto$1;
-    var DynProtoGlobalSettings = "__dynProto$Gbl";
-    var DynProtoCurrent = "_dynInstProto";
-    var strUseBaseInst = 'useBaseInst';
-    var strSetInstFuncs = 'setInstFuncs';
-    var Obj = Object;
-    var _objGetPrototypeOf$1 = Obj["getPrototypeOf"];
-    var _objGetOwnProps = Obj["getOwnPropertyNames"];
-    function _getGlobal() {
+    function createEnumKeyMap(values) {
+        return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+    }
+
+    var _wellKnownSymbolMap = createEnumKeyMap({
+        asyncIterator: 0 ,
+        hasInstance: 1 ,
+        isConcatSpreadable: 2 ,
+        iterator: 3 ,
+        match: 4 ,
+        matchAll: 5 ,
+        replace: 6 ,
+        search: 7 ,
+        species: 8 ,
+        split: 9 ,
+        toPrimitive: 10 ,
+        toStringTag: 11 ,
+        unscopables: 12
+    });
+
+    var asString = StrCls;
+
+    var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+    var _globalCfg;
+    function _getGlobalValue() {
         var result;
         if (typeof globalThis !== UNDEFINED) {
             result = globalThis;
@@ -131,587 +205,1693 @@
         if (!result && typeof global !== UNDEFINED) {
             result = global;
         }
-        return result || {};
-    }
-    var _gbl = _getGlobal();
-    var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
-        o: (_a = {},
-            _a[strSetInstFuncs] = true,
-            _a[strUseBaseInst] = true,
-            _a),
-        n: 1000
-    });
-    function _hasOwnProperty(obj, prop) {
-        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
-    }
-    function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
-    }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+        return result;
     }
-    function _getObjProto$1(target) {
-        var newProto;
-        if (target) {
-            if (_objGetPrototypeOf$1) {
-                return _objGetPrototypeOf$1(target);
-            }
-            var curProto = target[str__Proto$1] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
-            newProto = target[DynProtoBaseProto] || curProto;
-            if (!_hasOwnProperty(target, DynProtoBaseProto)) {
-                delete target[DynProtoCurrent];
-                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-                target[DynProtoCurrent] = curProto;
-            }
+    function _getGlobalConfig() {
+        if (!_globalCfg) {
+            var gbl = _getGlobalValue() || {};
+            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
         }
-        return newProto;
+        return _globalCfg;
     }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
+
+    function dumpObj(object, format) {
+        var propertyValueDump = EMPTY;
+        if (isError(object)) {
+            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
         }
         else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
-                    props.push(name_1);
-                }
+            try {
+                propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
             }
-        }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
+            catch (e) {
+                propertyValueDump = " - " + dumpObj(e, format);
             }
         }
+        return objToString(object) + ": " + propertyValueDump;
     }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
-    }
-    function _throwTypeError(message) {
-        throw new TypeError("DynamicProto: " + message);
-    }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
+
+    var _arrSlice = ArrProto[SLICE];
+    var _throwMissingFunction = function (funcName, thisArg) {
+        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+    };
+    var _unwrapInstFunction = function (funcName) {
+        return function (thisArg) {
+            return thisArg[funcName].apply(thisArg, _arrSlice.call(arguments, 1));
+        };
+    };
+    var _unwrapFunction = function (funcName, clsProto) {
+        var clsFn = clsProto && clsProto[funcName];
+        return function (thisArg) {
+            var theFunc = (thisArg && thisArg[funcName]) || clsFn;
+            if (theFunc) {
+                return theFunc.apply(thisArg, _arrSlice.call(arguments, 1));
             }
-        });
-        return instFuncs;
+            _throwMissingFunction(funcName, thisArg);
+        };
+    };
+
+    var _polySymbols;
+    function _globalSymbolRegistry() {
+        if (!_polySymbols) {
+            var gblCfg = _getGlobalConfig();
+            _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
+        }
+        return _polySymbols;
+    }
+    var _wellKnownSymbolCache = {};
+    function polyNewSymbol(description) {
+        var theSymbol = {
+            description: asString(description),
+            toString: function () { return SYMBOL + "(" + description + ")"; }
+        };
+        theSymbol[POLYFILL_TAG] = true;
+        return theSymbol;
     }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
-            }
+    function polySymbolFor(key) {
+        var registry = _globalSymbolRegistry();
+        if (!objHasOwn(registry, key)) {
+            var newSymbol = polyNewSymbol(key);
+            registry.k[key] = newSymbol;
+            registry.s[newSymbol] = asString(key);
         }
-        return false;
+        return registry.k[key];
     }
-    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
-        function _instFuncProxy(target, funcHost, funcName) {
-            var theFunc = funcHost[funcName];
-            if (theFunc[DynProxyTag] && useBaseInst) {
-                var instFuncTable = target[DynInstFuncTable] || {};
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
-                }
+    function polyGetKnownSymbol(name) {
+        var result;
+        var knownName = _wellKnownSymbolMap[name];
+        if (knownName) {
+            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+        }
+        return result;
+    }
+
+    var propMap = {
+        e: "enumerable",
+        c: "configurable",
+        v: VALUE,
+        w: "writable",
+        g: "get",
+        s: "set"
+    };
+    function _createProp(value) {
+        var prop = {};
+        prop[propMap["c"]] = true;
+        prop[propMap["e"]] = true;
+        if (value.l) {
+            prop.get = function () { return value.l.v; };
+            var desc = objGetOwnPropertyDescriptor(value.l, "v");
+            if (desc && desc.set) {
+                prop.set = function (newValue) {
+                    value.l.v = newValue;
+                };
             }
-            return function () {
-                return theFunc.apply(target, arguments);
-            };
         }
-        var baseFuncs = {};
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+        objForEachKey(value, function (key, value) {
+            prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
         });
-        var baseProto = _getObjProto$1(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf$1)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
-                }
-            });
-            visited.push(baseProto);
-            baseProto = _getObjProto$1(baseProto);
-        }
-        return baseFuncs;
+        return prop;
     }
-    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-        var instFunc = null;
-        if (target && _hasOwnProperty(proto, DynClassName)) {
-            var instFuncTable = target[DynInstFuncTable] || {};
-            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
-            if (!instFunc) {
-                _throwTypeError("Missing [" + funcName + "] " + strFunction);
-            }
-            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-                var canAddInst = !_hasOwnProperty(target, funcName);
-                var objProto = _getObjProto$1(target);
-                var visited = [];
-                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                    var protoFunc = objProto[funcName];
-                    if (protoFunc) {
-                        canAddInst = (protoFunc === currentDynProtoProxy);
-                        break;
-                    }
-                    visited.push(objProto);
-                    objProto = _getObjProto$1(objProto);
-                }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
+    var objDefineProp = ObjClass["defineProperty"];
+    function objDefine(target, key, propDesc) {
+        return objDefineProp(target, key, _createProp(propDesc));
+    }
+
+    var _globalLazyTestHooks;
+    var _fetchLazyTestHooks = function () {
+        _globalLazyTestHooks = _getGlobalConfig();
+        _fetchLazyTestHooks = NULL_VALUE;
+    };
+    function getLazy(cb) {
+        var lazyValue = {};
+        _fetchLazyTestHooks && _fetchLazyTestHooks();
+        lazyValue.b = _globalLazyTestHooks.lzy;
+        objDefineProp(lazyValue, "v", {
+            configurable: true,
+            get: function () {
+                var result = cb();
+                if (!_globalLazyTestHooks.lzy) {
+                    objDefineProp(lazyValue, "v", {
+                        value: result
+                    });
+                    if (lazyValue.b) {
+                        delete lazyValue.b;
                     }
-                    instFunc[DynInstChkTag] = 1;
                 }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
+                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                    lazyValue.b = _globalLazyTestHooks.lzy;
                 }
+                return result;
             }
-        }
-        return instFunc;
+        });
+        return lazyValue;
     }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto$1(proto)[funcName];
+
+    function safeGetLazy(cb, defValue) {
+        return getLazy(function () { return safeGet(cb, defValue); });
+    }
+
+    var WINDOW = "window";
+    var _cachedGlobal;
+    var _cachedWindow;
+    var _cachedNavigator;
+    var lazySafeGetInst = function (name) { return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE); };
+    var getGlobal = function (useCached) {
+        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, NULL_VALUE));
+        return _cachedGlobal.v;
+    };
+    var getInst = function (name, useCached) {
+        var gbl = (!_cachedGlobal || useCached === false) ? getGlobal(useCached) : _cachedGlobal.v;
+        if (gbl && gbl[name]) {
+            return gbl[name];
         }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        if (name === WINDOW && _cachedWindow) {
+            return _cachedWindow.v;
         }
-        return protoFunc;
+        return NULL_VALUE;
+    };
+    var hasWindow = function () { return !!getWindow(); };
+    var getWindow = function () {
+        (!_cachedWindow || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
+        return _cachedWindow.v;
+    };
+    var getNavigator = function () {
+        (!_cachedNavigator || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
+        return _cachedNavigator.v;
+    };
+
+    var _symbol;
+    var _symbolFor;
+    var _symbolKeyFor;
+    function _getSymbolValue(name) {
+        return safeGetLazy(function () {
+            return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+        }, UNDEF_VALUE);
+    }
+    function getSymbol() {
+        var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
+        resetCache && (_symbol = lazySafeGetInst(SYMBOL));
+        (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
+        (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
+        return _symbol.v;
+    }
+    function getKnownSymbol(name, noPoly) {
+        var knownName = _wellKnownSymbolMap[name];
+        (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+    }
+    function newSymbol(description, noPoly) {
+        (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
+    }
+    function symbolFor(key) {
+        (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+        return (_symbolFor.v || polySymbolFor)(key);
     }
-    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
-        function _createDynamicPrototype(proto, funcName) {
-            var dynProtoProxy = function () {
-                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
-                return instFunc.apply(this, arguments);
+
+    function isIterator(value) {
+        return !!value && isFunction(value.next);
+    }
+    function isIterable(value) {
+        return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
+    }
+
+    var _iterSymbol;
+    function iterForOf(iter, callbackfn, thisArg) {
+        if (iter) {
+            if (!isIterator(iter)) {
+                !_iterSymbol && (_iterSymbol = getLazy(function () { return getKnownSymbol(3 ); }));
+                iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;
+            }
+            if (isIterator(iter)) {
+                var err = void 0;
+                var iterResult = void 0;
+                try {
+                    var count = 0;
+                    while (!(iterResult = iter.next())[DONE]) {
+                        if (callbackfn.call(thisArg || iter, iterResult[VALUE], count, iter) === -1) {
+                            break;
+                        }
+                        count++;
+                    }
+                }
+                catch (failed) {
+                    err = { e: failed };
+                    if (iter.throw) {
+                        iterResult = null;
+                        iter.throw(err);
+                    }
+                }
+                finally {
+                    try {
+                        if (iterResult && !iterResult[DONE]) {
+                            iter.return && iter.return(iterResult);
+                        }
+                    }
+                    finally {
+                        if (err) {
+                            throw err.e;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    var fnApply = _unwrapInstFunction("apply");
+
+    function arrAppend(target, elms) {
+        if (!isUndefined(elms) && target) {
+            if (isArray(elms)) {
+                fnApply(target.push, target, elms);
+            }
+            else if (isIterator(elms) || isIterable(elms)) {
+                iterForOf(elms, function (elm) {
+                    target.push(elm);
+                });
+            }
+            else {
+                target.push(elms);
+            }
+        }
+        return target;
+    }
+
+    function arrForEach(theArray, callbackfn, thisArg) {
+        if (theArray) {
+            var len = theArray[LENGTH] >>> 0;
+            for (var idx = 0; idx < len; idx++) {
+                if (idx in theArray) {
+                    if (callbackfn.call(thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+    _unwrapFunction(LAST_INDEX_OF, ArrProto);
+
+    var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+    var fnCall = _unwrapInstFunction("call");
+
+    var _objCreate = ObjClass["create"];
+    var objCreate = _objCreate || polyObjCreate;
+    function polyObjCreate(obj) {
+        if (!obj) {
+            return {};
+        }
+        var type = typeof obj;
+        if (type !== OBJECT && type !== FUNCTION) {
+            throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+        }
+        function tempFunc() { }
+        tempFunc[PROTOTYPE] = obj;
+        return new tempFunc();
+    }
+
+    var _isProtoArray;
+    function objSetPrototypeOf(obj, proto) {
+        var fn = ObjClass["setPrototypeOf"] ||
+            function (d, b) {
+                !_isProtoArray && (_isProtoArray = getLazy(function () {
+                    var _a;
+                    return ((_a = {}, _a[__PROTO__] = [], _a) instanceof Array);
+                }));
+                _isProtoArray.v ? d[__PROTO__] = b : objForEachKey(b, function (key, value) { return d[key] = value; });
             };
-            dynProtoProxy[DynProxyTag] = 1;
-            return dynProtoProxy;
+        return fn(obj, proto);
+    }
+
+    var _createCustomError = function (name, d, b) {
+        _safeDefineName(d, name);
+        d = objSetPrototypeOf(d, b);
+        function __() {
+            this.constructor = d;
+            _safeDefineName(this, name);
         }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+        d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
+        return d;
+    };
+    var _safeSetName = function (baseClass, name) {
+        try {
+            name && (baseClass[NAME] = name);
+        }
+        catch (e) {
+        }
+    };
+    var _safeDefineName = function (target, name) {
+        try {
+            objDefine(target, NAME, { v: name, c: true, e: false });
+        }
+        catch (e) {
+        }
+    };
+    function createCustomError(name, constructCb, errorBase) {
+        var theBaseClass = errorBase || Error;
+        var orgName = theBaseClass[PROTOTYPE][NAME];
+        var captureFn = Error.captureStackTrace;
+        return _createCustomError(name, function () {
+            var _this = this;
+            try {
+                _safeSetName(theBaseClass, name);
+                var _self = fnApply(theBaseClass, _this, arrSlice(arguments)) || _this;
+                if (_self !== _this) {
+                    var orgProto = objGetPrototypeOf(_this);
+                    if (orgProto !== objGetPrototypeOf(_self)) {
+                        objSetPrototypeOf(_self, orgProto);
+                    }
+                }
+                captureFn && captureFn(_self, _this[CONSTRUCTOR]);
+                constructCb && constructCb(_self, arguments);
+                return _self;
+            }
+            finally {
+                _safeSetName(theBaseClass, orgName);
+            }
+        }, theBaseClass);
+    }
+
+    function utcNow() {
+        return (Date.now || polyUtcNow)();
+    }
+    function polyUtcNow() {
+        return new Date().getTime();
+    }
+
+    var _fnToString;
+    var _objCtrFnString;
+    var _gblWindow;
+    function isPlainObject(value) {
+        if (!value || typeof value !== OBJECT) {
+            return false;
+        }
+        if (!_gblWindow) {
+            _gblWindow = hasWindow() ? getWindow() : true;
+        }
+        var result = false;
+        if (value !== _gblWindow) {
+            if (!_objCtrFnString) {
+                _fnToString = Function[PROTOTYPE].toString;
+                _objCtrFnString = fnCall(_fnToString, ObjClass);
+            }
+            try {
+                var proto = objGetPrototypeOf(value);
+                result = !proto;
+                if (!result) {
+                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
+                        proto = proto[CONSTRUCTOR];
+                    }
+                    result = proto && typeof proto === FUNCTION && _fnToString.call(proto) === _objCtrFnString;
+                }
+            }
+            catch (ex) {
+            }
+        }
+        return result;
+    }
+
+    var strIndexOf = _unwrapFunction(INDEX_OF, StrProto);
+    _unwrapFunction(LAST_INDEX_OF, StrProto);
+
+    var REF = "ref";
+    var UNREF = "un" + REF;
+    var HAS_REF = "hasRef";
+    var ENABLED = "enabled";
+    function _createTimerHandler(startTimer, refreshFn, cancelFn) {
+        var _a;
+        var ref = true;
+        var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
+        var theTimerHandler;
+        var _unref = function () {
+            ref = false;
+            timerId && timerId[UNREF] && timerId[UNREF]();
+            return theTimerHandler;
+        };
+        var _ref = function () {
+            ref = true;
+            timerId && timerId[REF] && timerId[REF]();
+            return theTimerHandler;
+        };
+        var _hasRef = function () {
+            if (timerId && timerId[HAS_REF]) {
+                return timerId[HAS_REF]();
+            }
+            return ref;
+        };
+        var _refresh = function () {
+            timerId = refreshFn(timerId);
+            if (!ref) {
+                _unref();
+            }
+            return theTimerHandler;
+        };
+        var _cancel = function () {
+            timerId && cancelFn(timerId);
+            timerId = NULL_VALUE;
+        };
+        var _setEnabled = function (value) {
+            !value && timerId && _cancel();
+            value && !timerId && _refresh();
+        };
+        theTimerHandler = (_a = {
+                cancel: _cancel,
+                refresh: _refresh
+            },
+            _a[HAS_REF] = _hasRef,
+            _a[REF] = _ref,
+            _a[UNREF] = _unref,
+            _a[ENABLED] = false,
+            _a);
+        objDefineProp(theTimerHandler, ENABLED, {
+            get: function () { return !!timerId; },
+            set: _setEnabled
+        });
+        return {
+            h: theTimerHandler,
+            dn: function () {
+                timerId = NULL_VALUE;
+            }
+        };
+    }
+
+    function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
+        var isArr = isArray(overrideFn);
+        var len = isArr ? overrideFn.length : 0;
+        var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
+        var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
+        var timerFn = theArgs[0];
+        theArgs[0] = function () {
+            handler.dn();
+            fnApply(timerFn, self, arrSlice(arguments));
+        };
+        var handler = _createTimerHandler(startTimer, function (timerId) {
+            if (timerId) {
+                if (timerId.refresh) {
+                    timerId.refresh();
+                    return timerId;
+                }
+                fnApply(clearFn, self, [timerId]);
+            }
+            return fnApply(setFn, self, theArgs);
+        }, function (timerId) {
+            fnApply(clearFn, self, [timerId]);
+        });
+        return handler.h;
+    }
+    function scheduleTimeout(callback, timeout) {
+        return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
+    }
+
+    (getGlobal() || {})["Symbol"];
+    (getGlobal() || {})["Reflect"];
+    var strHasOwnProperty = "hasOwnProperty";
+    var extendStaticsFn = function (d, b) {
+        extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
+            ({ __proto__: [] } instanceof Array && function (d, b) {
+                d.__proto__ = b;
+            }) ||
+            function (d, b) {
+                for (var p in b) {
+                    if (b[strHasOwnProperty](p)) {
+                        d[p] = b[p];
+                    }
+                }
+            };
+        return extendStaticsFn(d, b);
+    };
+    function __extendsFn(d, b) {
+        if (typeof b !== strShimFunction && b !== null) {
+            throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
+        }
+        extendStaticsFn(d, b);
+        function __() {
+            this.constructor = d;
+        }
+        d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+    }
+
+    function getReactNativeDeviceInfo() {
+        return DeviceInfo__default["default"];
+    }
+
+    var _a$2;
+    var Constructor = 'constructor';
+    var Prototype = 'prototype';
+    var strFunction = 'function';
+    var DynInstFuncTable = '_dynInstFuncs';
+    var DynProxyTag = '_isDynProxy';
+    var DynClassName = '_dynClass';
+    var DynClassNamePrefix = '_dynCls$';
+    var DynInstChkTag = '_dynInstChk';
+    var DynAllowInstChkTag = DynInstChkTag;
+    var DynProtoDefaultOptions = '_dfOpts';
+    var UnknownValue = '_unknown_';
+    var str__Proto = "__proto__";
+    var DynProtoBaseProto = "_dyn" + str__Proto;
+    var DynProtoGlobalSettings = "__dynProto$Gbl";
+    var DynProtoCurrent = "_dynInstProto";
+    var strUseBaseInst = 'useBaseInst';
+    var strSetInstFuncs = 'setInstFuncs';
+    var Obj = Object;
+    var _objGetPrototypeOf = Obj["getPrototypeOf"];
+    var _objGetOwnProps = Obj["getOwnPropertyNames"];
+    var _gbl = getGlobal();
+    var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
+        o: (_a$2 = {},
+            _a$2[strSetInstFuncs] = true,
+            _a$2[strUseBaseInst] = true,
+            _a$2),
+        n: 1000
+    });
+    function _isObjectOrArrayPrototype(target) {
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
+    }
+    function _isObjectArrayOrFunctionPrototype(target) {
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    }
+    function _getObjProto(target) {
+        var newProto;
+        if (target) {
+            if (_objGetPrototypeOf) {
+                return _objGetPrototypeOf(target);
+            }
+            var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+            newProto = target[DynProtoBaseProto] || curProto;
+            if (!objHasOwnProperty(target, DynProtoBaseProto)) {
+                delete target[DynProtoCurrent];
+                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+                target[DynProtoCurrent] = curProto;
+            }
+        }
+        return newProto;
+    }
+    function _forEachProp(target, func) {
+        var props = [];
+        if (_objGetOwnProps) {
+            props = _objGetOwnProps(target);
+        }
+        else {
+            for (var name_1 in target) {
+                if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                    props.push(name_1);
+                }
+            }
+        }
+        if (props && props.length > 0) {
+            for (var lp = 0; lp < props.length; lp++) {
+                func(props[lp]);
+            }
+        }
+    }
+    function _isDynamicCandidate(target, funcName, skipOwn) {
+        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
+    }
+    function _throwTypeError(message) {
+        throwTypeError("DynamicProto: " + message);
+    }
+    function _getInstanceFuncs(thisTarget) {
+        var instFuncs = {};
+        _forEachProp(thisTarget, function (name) {
+            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+                instFuncs[name] = thisTarget[name];
+            }
+        });
+        return instFuncs;
+    }
+    function _hasVisited(values, value) {
+        for (var lp = values.length - 1; lp >= 0; lp--) {
+            if (values[lp] === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+        function _instFuncProxy(target, funcHost, funcName) {
+            var theFunc = funcHost[funcName];
+            if (theFunc[DynProxyTag] && useBaseInst) {
+                var instFuncTable = target[DynInstFuncTable] || {};
+                if (instFuncTable[DynAllowInstChkTag] !== false) {
+                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
+                }
+            }
+            return function () {
+                return theFunc.apply(target, arguments);
+            };
+        }
+        var baseFuncs = {};
+        _forEachProp(instFuncs, function (name) {
+            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+        });
+        var baseProto = _getObjProto(classProto);
+        var visited = [];
+        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+            _forEachProp(baseProto, function (name) {
+                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+                }
+            });
+            visited.push(baseProto);
+            baseProto = _getObjProto(baseProto);
+        }
+        return baseFuncs;
+    }
+    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+        var instFunc = null;
+        if (target && objHasOwnProperty(proto, DynClassName)) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+            if (!instFunc) {
+                _throwTypeError("Missing [" + funcName + "] " + strFunction);
+            }
+            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+                var canAddInst = !objHasOwnProperty(target, funcName);
+                var objProto = _getObjProto(target);
+                var visited = [];
+                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                    var protoFunc = objProto[funcName];
+                    if (protoFunc) {
+                        canAddInst = (protoFunc === currentDynProtoProxy);
+                        break;
+                    }
+                    visited.push(objProto);
+                    objProto = _getObjProto(objProto);
+                }
+                try {
+                    if (canAddInst) {
+                        target[funcName] = instFunc;
+                    }
+                    instFunc[DynInstChkTag] = 1;
+                }
+                catch (e) {
+                    instFuncTable[DynAllowInstChkTag] = false;
+                }
+            }
+        }
+        return instFunc;
+    }
+    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+        var protoFunc = proto[funcName];
+        if (protoFunc === currentDynProtoProxy) {
+            protoFunc = _getObjProto(proto)[funcName];
+        }
+        if (typeof protoFunc !== strFunction) {
+            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        }
+        return protoFunc;
+    }
+    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+        function _createDynamicPrototype(proto, funcName) {
+            var dynProtoProxy = function () {
+                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+                return instFunc.apply(this, arguments);
+            };
+            dynProtoProxy[DynProxyTag] = 1;
+            return dynProtoProxy;
+        }
+        if (!_isObjectOrArrayPrototype(proto)) {
+            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            }
+            _forEachProp(target, function (name) {
+                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                    instFuncs_1[name] = target[name];
+                    delete target[name];
+                    if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                        proto[name] = _createDynamicPrototype(proto, name);
+                    }
+                }
+            });
+        }
+    }
+    function _checkPrototype(classProto, thisTarget) {
+        if (_objGetPrototypeOf) {
+            var visited = [];
+            var thisProto = _getObjProto(thisTarget);
+            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+                if (thisProto === classProto) {
+                    return true;
+                }
+                visited.push(thisProto);
+                thisProto = _getObjProto(thisProto);
+            }
+            return false;
+        }
+        return true;
+    }
+    function _getObjName(target, unknownValue) {
+        if (objHasOwnProperty(target, Prototype)) {
+            return target.name || unknownValue || UnknownValue;
+        }
+        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+    }
+    function dynamicProto(theClass, target, delegateFunc, options) {
+        if (!objHasOwnProperty(theClass, Prototype)) {
+            _throwTypeError("theClass is an invalid class definition.");
+        }
+        var classProto = theClass[Prototype];
+        if (!_checkPrototype(classProto, target)) {
+            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+        }
+        var className = null;
+        if (objHasOwnProperty(classProto, DynClassName)) {
+            className = classProto[DynClassName];
+        }
+        else {
+            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+            _gblInst.n++;
+            classProto[DynClassName] = className;
+        }
+        var perfOptions = dynamicProto[DynProtoDefaultOptions];
+        var useBaseInst = !!perfOptions[strUseBaseInst];
+        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+            useBaseInst = !!options[strUseBaseInst];
+        }
+        var instFuncs = _getInstanceFuncs(target);
+        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+        delegateFunc(target, baseFuncs);
+        var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+        if (setInstanceFunc && options) {
+            setInstanceFunc = !!options[strSetInstFuncs];
+        }
+        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+    }
+    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_BLK_VAL = "blkVal";
+    var _DYN_LENGTH = "length";
+    var _DYN_RD_ONLY = "rdOnly";
+    var _DYN_NOTIFY = "notify";
+    var _DYN_WARN_TO_CONSOLE = "warnToConsole";
+    var _DYN_THROW_INTERNAL = "throwInternal";
+    var _DYN_SET_DF = "setDf";
+    var _DYN_WATCH = "watch";
+    var _DYN_LOGGER = "logger";
+    var _DYN_APPLY = "apply";
+    var _DYN_PUSH = "push";
+    var _DYN_SPLICE = "splice";
+    var _DYN_HDLR = "hdlr";
+    var _DYN_CANCEL = "cancel";
+    var _DYN_INITIALIZE = "initialize";
+    var _DYN_IDENTIFIER = "identifier";
+    var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_GET_PLUGIN = "getPlugin";
+    var _DYN_NAME = "name";
+    var _DYN_TIME = "time";
+    var _DYN_PROCESS_NEXT = "processNext";
+    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_UNLOAD = "unload";
+    var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+    var _DYN_CREATE_NEW = "createNew";
+    var _DYN_TEARDOWN = "teardown";
+    var _DYN_MESSAGE_ID = "messageId";
+    var _DYN_MESSAGE = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+    var _DYN_USER_AGENT = "userAgent";
+    var _DYN_NODE_TYPE = "nodeType";
+    var _DYN_REPLACE = "replace";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_IS_CHILD_EVT = "isChildEvt";
+    var _DYN_GET_CTX = "getCtx";
+    var _DYN_SET_CTX = "setCtx";
+    var _DYN_COMPLETE = "complete";
+
+    var aggregationErrorType;
+    function throwAggregationError(message, sourceErrors) {
+        if (!aggregationErrorType) {
+            aggregationErrorType = createCustomError("AggregationError", function (self, args) {
+                if (args[_DYN_LENGTH ] > 1) {
+                    self.errors = args[1];
+                }
+            });
+        }
+        var theMessage = message || "One or more errors occurred.";
+        arrForEach(sourceErrors, function (srcError, idx) {
+            theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
+        });
+        throw new aggregationErrorType(theMessage, sourceErrors || []);
+    }
+
+    var UNDEFINED_VALUE = undefined;
+    var STR_EMPTY = "";
+    var STR_CORE = "core";
+    var STR_DISABLED = "disabled";
+    var STR_EXTENSION_CONFIG = "extensionConfig";
+    var STR_PROCESS_TELEMETRY = "processTelemetry";
+    var STR_PRIORITY = "priority";
+    var STR_GET_PERF_MGR = "getPerfMgr";
+    var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+
+    var rCamelCase = /-([a-z])/g;
+    var rNormalizeInvalid = /([^\w\d_$])/g;
+    var rLeadingNumeric = /^(\d+[\w\d_$])/;
+    function isNotNullOrUndefined(value) {
+        return !isNullOrUndefined(value);
+    }
+    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;
+    }
+    function strContains(value, search) {
+        if (value && search) {
+            return strIndexOf(value, search) !== -1;
+        }
+        return false;
+    }
+    function getExceptionName(object) {
+        if (isError(object)) {
+            return object[_DYN_NAME ];
+        }
+        return STR_EMPTY;
+    }
+    function _createProxyFunction(source, funcName) {
+        var srcFunc = null;
+        var src = null;
+        if (isFunction(source)) {
+            srcFunc = source;
+        }
+        else {
+            src = source;
+        }
+        return function () {
+            var originalArguments = arguments;
+            if (srcFunc) {
+                src = srcFunc();
+            }
+            if (src) {
+                return src[funcName][_DYN_APPLY ](src, originalArguments);
+            }
+        };
+    }
+    function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
+        if (target && name && source) {
+            if (overwriteTarget !== false || isUndefined(target[name])) {
+                target[name] = _createProxyFunction(source, theFunc);
+            }
+        }
+    }
+
+    var strConsole = "console";
+    var strJSON = "JSON";
+    var strCrypto = "crypto";
+    var strMsCrypto = "msCrypto";
+    var strMsie = "msie";
+    var strTrident = "trident/";
+    var _isTrident = null;
+    var _navUserAgentCheck = null;
+    function getConsole() {
+        if (typeof console !== strShimUndefined) {
+            return console;
+        }
+        return getInst(strConsole);
+    }
+    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 ]();
+            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+        }
+        return _isTrident;
+    }
+
+    var UInt32Mask = 0x100000000;
+    var MaxUInt32 = 0xffffffff;
+    var SEED1 = 123456789;
+    var SEED2 = 987654321;
+    var _mwcSeeded = false;
+    var _mwcW = SEED1;
+    var _mwcZ = SEED2;
+    function _mwcSeed(seedValue) {
+        if (seedValue < 0) {
+            seedValue >>>= 0;
+        }
+        _mwcW = (SEED1 + seedValue) & MaxUInt32;
+        _mwcZ = (SEED2 - seedValue) & MaxUInt32;
+        _mwcSeeded = true;
+    }
+    function _autoSeedMwc() {
+        try {
+            var now = utcNow() & 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 ] < 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.2';
+    var instanceName = "." + newId(6);
+    var _dataUid = 0;
+    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)) {
+                    objDefine(target, data.id, {
+                        e: false,
+                        v: theCache
+                    });
+                }
             }
-            _forEachProp(target, function (name) {
-                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                    instFuncs_1[name] = target[name];
-                    delete target[name];
-                    if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                        proto[name] = _createDynamicPrototype(proto, name);
+            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 _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf$1) {
-            var visited = [];
-            var thisProto = _getObjProto$1(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
+
+    function _isConfigDefaults(value) {
+        return (value && isObject(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
+    }
+    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 ]; lp++) {
+                var fallback = fallbacks[lp];
+                var fbValue = theConfig[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                else if (dynamicHandler) {
+                    fbValue = dynamicHandler.cfg[fallback];
+                    if (isDefaultValid(fbValue)) {
+                        defValue = fbValue;
+                    }
+                    dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+                }
+                if (isDefaultValid(defValue)) {
+                    break;
                 }
-                visited.push(thisProto);
-                thisProto = _getObjProto$1(thisProto);
             }
-            return false;
         }
-        return true;
+        if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+            defValue = cfgDefaults.v;
+        }
+        return defValue;
     }
-    function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
+    function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
+        var theValue = cfgDefaults;
+        if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
+            theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
         }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+        if (theValue) {
+            if (_isConfigDefaults(theValue)) {
+                theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
+            }
+            var newValue_1;
+            if (isArray(theValue)) {
+                newValue_1 = [];
+                newValue_1[_DYN_LENGTH ] = theValue[_DYN_LENGTH ];
+            }
+            else if (isPlainObject(theValue)) {
+                newValue_1 = {};
+            }
+            if (newValue_1) {
+                objForEachKey(theValue, function (key, value) {
+                    if (value && _isConfigDefaults(value)) {
+                        value = _resolveDefaultValue(dynamicHandler, theConfig, value);
+                    }
+                    newValue_1[key] = value;
+                });
+                theValue = newValue_1;
+            }
+        }
+        return theValue;
     }
-    function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!_hasOwnProperty(theClass, Prototype)) {
-            _throwTypeError("theClass is an invalid class definition.");
+    function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
+        var isValid;
+        var setFn;
+        var defValue;
+        var cfgDefaults = defaultValue;
+        var mergeDf;
+        var reference;
+        var readOnly;
+        var blkDynamicValue;
+        if (_isConfigDefaults(cfgDefaults)) {
+            isValid = cfgDefaults.isVal;
+            setFn = cfgDefaults.set;
+            readOnly = cfgDefaults[_DYN_RD_ONLY ];
+            blkDynamicValue = cfgDefaults[_DYN_BLK_VAL ];
+            mergeDf = cfgDefaults.mrg;
+            reference = cfgDefaults.ref;
+            if (!reference && isUndefined(reference)) {
+                reference = !!mergeDf;
+            }
+            defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
         }
-        var classProto = theClass[Prototype];
-        if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+        else {
+            defValue = defaultValue;
+        }
+        if (blkDynamicValue) {
+            dynamicHandler[_DYN_BLK_VAL ](theConfig, name);
+        }
+        var theValue;
+        var usingDefault = true;
+        var cfgValue = theConfig[name];
+        if (cfgValue || !isNullOrUndefined(cfgValue)) {
+            theValue = cfgValue;
+            usingDefault = false;
+            if (isValid && theValue !== defValue && !isValid(theValue)) {
+                theValue = defValue;
+                usingDefault = true;
+            }
+            if (setFn) {
+                theValue = setFn(theValue, defValue, theConfig);
+                usingDefault = theValue === defValue;
+            }
+        }
+        if (!usingDefault) {
+            if (isPlainObject(theValue) || isArray(defValue)) {
+                if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {
+                    objForEachKey(defValue, function (dfName, dfValue) {
+                        _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
+                    });
+                }
+            }
         }
-        var className = null;
-        if (_hasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
+        else if (defValue) {
+            theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
         }
         else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
-            _gblInst.n++;
-            classProto[DynClassName] = className;
+            theValue = defValue;
         }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
+        dynamicHandler.set(theConfig, name, theValue);
+        if (reference) {
+            dynamicHandler.ref(theConfig, name);
         }
-        var instFuncs = _getInstanceFuncs(target);
-        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
-        delegateFunc(target, baseFuncs);
-        var setInstanceFunc = !!_objGetPrototypeOf$1 && !!perfOptions[strSetInstFuncs];
-        if (setInstanceFunc && options) {
-            setInstanceFunc = !!options[strSetInstFuncs];
+        if (readOnly) {
+            dynamicHandler[_DYN_RD_ONLY ](theConfig, name);
         }
-        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
     }
-    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
-
-    var _DYN_INITIALIZE = "initialize";
-    var _DYN_NAME = "name";
-    var _DYN_IDENTIFIER = "identifier";
-    var _DYN_PUSH = "push";
-    var _DYN_IS_INITIALIZED = "isInitialized";
-    var _DYN_CONFIG = "config";
-    var _DYN_LOGGER = "logger";
-    var _DYN_LENGTH = "length";
-    var _DYN_TIME = "time";
-    var _DYN_PROCESS_NEXT = "processNext";
-    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
-    var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_TEARDOWN = "teardown";
-    var _DYN_MESSAGE_ID = "messageId";
-    var _DYN_MESSAGE = "message";
-    var _DYN_IS_ASYNC = "isAsync";
-    var _DYN__DO_TEARDOWN = "_doTeardown";
-    var _DYN_UPDATE = "update";
-    var _DYN_GET_NEXT = "getNext";
-    var _DYN_DIAG_LOG = "diagLog";
-    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-    var _DYN_CREATE_NEW = "createNew";
-    var _DYN_INDEX_OF = "indexOf";
-    var _DYN_USER_AGENT = "userAgent";
-    var _DYN_NODE_TYPE = "nodeType";
-    var _DYN_APPLY = "apply";
-    var _DYN_REPLACE = "replace";
-    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
-    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
-    var _DYN_TO_LOWER_CASE = "toLowerCase";
-    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 STR_EMPTY = "";
-    var STR_CORE = "core";
-    var STR_DISABLED = "disabled";
-    var STR_EXTENSION_CONFIG = "extensionConfig";
-    var STR_PROCESS_TELEMETRY = "processTelemetry";
-    var STR_PRIORITY = "priority";
-    var STR_ERROR_TO_CONSOLE = "errorToConsole";
-    var STR_WARN_TO_CONSOLE = "warnToConsole";
-    var STR_GET_PERF_MGR = "getPerfMgr";
 
-    var strToString = "toString";
-    var str__Proto = "__proto__";
-    var strConstructor = "constructor";
-    var _objDefineProperty$1 = ObjDefineProperty;
-    var _objFreeze = ObjClass$1.freeze;
-    var _isArray = Array.isArray;
-    var _objToString = ObjProto$1[strToString];
-    var _fnToString = ObjHasOwnProperty[strToString];
-    var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass$1);
-    var rCamelCase = /-([a-z])/g;
-    var rNormalizeInvalid = /([^\w\d_$])/g;
-    var rLeadingNumeric = /^(\d+[\w\d_$])/;
-    var _objGetPrototypeOf = Object["getPrototypeOf"];
-    function _getObjProto(target) {
-        if (target) {
-            if (_objGetPrototypeOf) {
-                return _objGetPrototypeOf(target);
+    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+    var BLOCK_DYNAMIC = symbolFor("[[ai_blkDynCfg_1]]");
+    var FORCE_DYNAMIC = symbolFor("[[ai_frcDynCfg_1]]");
+    function _cfgDeepCopy(source) {
+        if (source) {
+            var target_1;
+            if (isArray(source)) {
+                target_1 = [];
+                target_1[_DYN_LENGTH ] = source[_DYN_LENGTH ];
+            }
+            else if (isPlainObject(source)) {
+                target_1 = {};
+            }
+            if (target_1) {
+                objForEachKey(source, function (key, value) {
+                    target_1[key] = _cfgDeepCopy(value);
+                });
+                return target_1;
             }
-            var newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
-            if (newProto) {
-                return newProto;
+        }
+        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 isUndefined(value) {
-        return value === undefined || typeof value === strShimUndefined;
-    }
-    function isNullOrUndefined(value) {
-        return (value === null || isUndefined(value));
+    function blockDynamicConversion(value) {
+        if (value && (isPlainObject(value) || isArray(value))) {
+            try {
+                value[BLOCK_DYNAMIC] = true;
+            }
+            catch (e) {
+            }
+        }
+        return value;
     }
-    function isObject(value) {
-        return !!(value && typeof value === strShimObject);
+    function _canMakeDynamic(getFunc, state, value) {
+        var result = false;
+        if (value && !getFunc[state.blkVal]) {
+            result = value[FORCE_DYNAMIC];
+            if (!result && !value[BLOCK_DYNAMIC]) {
+                result = isPlainObject(value) || isArray(value);
+            }
+        }
+        return result;
     }
-    function isFunction$1(value) {
-        return !!(value && typeof value === strShimFunction);
+    function throwInvalidAccess(message) {
+        throwTypeError("InvalidAccess:" + message);
     }
-    function normalizeJsName(name) {
-        var value = name;
-        if (value && isString$1(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;
+
+    var arrayMethodsToPatch = [
+        "push",
+        "pop",
+        "shift",
+        "unshift",
+        "splice"
+    ];
+    var _throwDynamicError = function (logger, name, desc, e) {
+        logger && logger[_DYN_THROW_INTERNAL ](3 , 108 , "".concat(desc, " [").concat(name, "] failed - ") + dumpObj(e));
+    };
+    function _patchArray(state, target, name) {
+        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, name, "Patching");
+                    return result;
+                };
             });
         }
-        return value;
     }
-    function objForEachKey(target, callbackfn) {
-        if (target) {
-            for (var prop in target) {
-                if (ObjHasOwnProperty[_DYN_CALL ](target, prop)) {
-                    callbackfn[_DYN_CALL ](target, prop, target[prop]);
+    function _getOwnPropGetter(target, name) {
+        var propDesc = objGetOwnPropertyDescriptor(target, name);
+        return propDesc && propDesc.get;
+    }
+    function _createDynamicProperty(state, theConfig, name, value) {
+        var detail = {
+            n: name,
+            h: [],
+            trk: function (handler) {
+                if (handler && handler.fn) {
+                    if (arrIndexOf(detail.h, handler) === -1) {
+                        detail.h[_DYN_PUSH ](handler);
+                    }
+                    state.trk(handler, detail);
+                }
+            },
+            clr: function (handler) {
+                var idx = arrIndexOf(detail.h, handler);
+                if (idx !== -1) {
+                    detail.h[_DYN_SPLICE ](idx, 1);
+                }
+            }
+        };
+        var checkDynamic = true;
+        var isObjectOrArray = false;
+        function _getProperty() {
+            if (checkDynamic) {
+                isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
+                if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
+                    value = _makeDynamicObject(state, value, name, "Converting");
                 }
+                checkDynamic = false;
             }
+            var activeHandler = state.act;
+            if (activeHandler) {
+                detail.trk(activeHandler);
+            }
+            return value;
         }
-    }
-    function strContains(value, search) {
-        if (value && search) {
-            return value[_DYN_INDEX_OF ](search) !== -1;
+        _getProperty[state.prop] = {
+            chng: function () {
+                state.add(detail);
+            }
+        };
+        function _setProperty(newValue) {
+            if (value !== newValue) {
+                if (!!_getProperty[state.ro] && !state.upd) {
+                    throwInvalidAccess("[" + name + "] is read-only:" + dumpObj(theConfig));
+                }
+                if (checkDynamic) {
+                    isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
+                    checkDynamic = false;
+                }
+                var isReferenced = isObjectOrArray && _getProperty[state.rf];
+                if (isObjectOrArray) {
+                    if (isReferenced) {
+                        objForEachKey(value, function (key) {
+                            value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
+                        });
+                        try {
+                            objForEachKey(newValue, function (key, theValue) {
+                                _setDynamicProperty(state, value, key, theValue);
+                            });
+                            newValue = value;
+                        }
+                        catch (e) {
+                            _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Assigning", e);
+                            isObjectOrArray = false;
+                        }
+                    }
+                    else if (value && value[CFG_HANDLER_LINK]) {
+                        objForEachKey(value, function (key) {
+                            var getter = _getOwnPropGetter(value, key);
+                            if (getter) {
+                                var valueState = getter[state.prop];
+                                valueState && valueState.chng();
+                            }
+                        });
+                    }
+                }
+                if (newValue !== value) {
+                    var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
+                    if (!isReferenced && newIsObjectOrArray) {
+                        newValue = _makeDynamicObject(state, newValue, name, "Converting");
+                    }
+                    value = newValue;
+                    isObjectOrArray = newIsObjectOrArray;
+                }
+                state.add(detail);
+            }
         }
-        return false;
-    }
-    var isArray$1 = _isArray || _isArrayPoly;
-    function _isArrayPoly(obj) {
-        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Array]");
+        objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
     }
-    function isError$1(obj) {
-        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Error]");
-    }
-    function isString$1(value) {
-        return typeof value === "string";
-    }
-    function isBoolean(value) {
-        return typeof value === "boolean";
-    }
-    function isPlainObject(value) {
-        var result = false;
-        if (value && typeof value === "object") {
-            var proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
-            if (!proto) {
-                result = true;
+    function _setDynamicProperty(state, target, name, value) {
+        if (target) {
+            var getter = _getOwnPropGetter(target, name);
+            var isDynamic = getter && !!getter[state.prop];
+            if (!isDynamic) {
+                _createDynamicProperty(state, target, name, value);
             }
             else {
-                if (proto[strConstructor] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor)) {
-                    proto = proto[strConstructor];
+                target[name] = value;
+            }
+        }
+        return target;
+    }
+    function _setDynamicPropertyState(state, target, name, flags) {
+        if (target) {
+            var getter = _getOwnPropGetter(target, name);
+            var isDynamic = getter && !!getter[state.prop];
+            var inPlace = flags && flags[0 ];
+            var rdOnly = flags && flags[1 ];
+            var blkProp = flags && flags[2 ];
+            if (!isDynamic) {
+                if (blkProp) {
+                    try {
+                        blockDynamicConversion(target);
+                    }
+                    catch (e) {
+                        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Blocking", e);
+                    }
+                }
+                try {
+                    _setDynamicProperty(state, target, name, target[name]);
+                    getter = _getOwnPropGetter(target, name);
                 }
-                result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
+                catch (e) {
+                    _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "State", e);
+                }
+            }
+            if (inPlace) {
+                getter[state.rf] = inPlace;
+            }
+            if (rdOnly) {
+                getter[state.ro] = rdOnly;
+            }
+            if (blkProp) {
+                getter[state.blkVal] = true;
             }
         }
-        return result;
+        return target;
     }
-    function arrForEach(arr, callbackfn, thisArg) {
-        var len = arr[_DYN_LENGTH ];
+    function _makeDynamicObject(state, target, name, desc) {
         try {
-            for (var idx = 0; idx < len; idx++) {
-                if (idx in arr) {
-                    if (callbackfn[_DYN_CALL ](thisArg || arr, arr[idx], idx, arr) === -1) {
-                        break;
+            objForEachKey(target, function (key, value) {
+                _setDynamicProperty(state, target, key, value);
+            });
+            if (!target[CFG_HANDLER_LINK]) {
+                objDefineProp(target, CFG_HANDLER_LINK, {
+                    get: function () {
+                        return state[_DYN_HDLR ];
+                    }
+                });
+                _patchArray(state, target, name);
+            }
+        }
+        catch (e) {
+            _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, desc, e);
+        }
+        return target;
+    }
+
+    var symPrefix = "[[ai_";
+    var symPostfix = "]]";
+    function _createState(cfgHandler) {
+        var _a;
+        var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
+        var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
+        var dynamicPropertyReferenced = newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
+        var dynamicPropertyBlockValue = newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
+        var dynamicPropertyDetail = newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
+        var _waitingHandlers = null;
+        var _watcherTimer = null;
+        var theState;
+        function _useHandler(activeHandler, callback) {
+            var prevWatcher = theState.act;
+            try {
+                theState.act = activeHandler;
+                if (activeHandler && activeHandler[dynamicPropertyDetail]) {
+                    arrForEach(activeHandler[dynamicPropertyDetail], function (detail) {
+                        detail.clr(activeHandler);
+                    });
+                    activeHandler[dynamicPropertyDetail] = [];
+                }
+                callback({
+                    cfg: cfgHandler.cfg,
+                    set: cfgHandler.set.bind(cfgHandler),
+                    setDf: cfgHandler[_DYN_SET_DF ].bind(cfgHandler),
+                    ref: cfgHandler.ref.bind(cfgHandler),
+                    rdOnly: cfgHandler[_DYN_RD_ONLY ].bind(cfgHandler)
+                });
+            }
+            catch (e) {
+                var logger = cfgHandler[_DYN_LOGGER ];
+                if (logger) {
+                    logger[_DYN_THROW_INTERNAL ](1 , 107 , dumpObj(e));
+                }
+                throw e;
+            }
+            finally {
+                theState.act = prevWatcher || null;
+            }
+        }
+        function _notifyWatchers() {
+            if (_waitingHandlers) {
+                var notifyHandlers = _waitingHandlers;
+                _waitingHandlers = null;
+                _watcherTimer && _watcherTimer[_DYN_CANCEL ]();
+                _watcherTimer = null;
+                var watcherFailures_1 = [];
+                arrForEach(notifyHandlers, function (handler) {
+                    if (handler) {
+                        if (handler[dynamicPropertyDetail]) {
+                            arrForEach(handler[dynamicPropertyDetail], function (detail) {
+                                detail.clr(handler);
+                            });
+                            handler[dynamicPropertyDetail] = null;
+                        }
+                        if (handler.fn) {
+                            try {
+                                _useHandler(handler, handler.fn);
+                            }
+                            catch (e) {
+                                watcherFailures_1[_DYN_PUSH ](e);
+                            }
+                        }
+                    }
+                });
+                if (_waitingHandlers) {
+                    try {
+                        _notifyWatchers();
+                    }
+                    catch (e) {
+                        watcherFailures_1[_DYN_PUSH ](e);
                     }
                 }
+                if (watcherFailures_1[_DYN_LENGTH ] > 0) {
+                    throwAggregationError("Watcher error(s): ", watcherFailures_1);
+                }
             }
         }
-        catch (e) {
-        }
-    }
-    function objDefineAccessors(target, prop, getProp, setProp) {
-        if (_objDefineProperty$1) {
-            try {
-                var descriptor = {
-                    enumerable: true,
-                    configurable: true
-                };
-                if (getProp) {
-                    descriptor.get = getProp;
+        function _addWatcher(detail) {
+            if (detail && detail.h[_DYN_LENGTH ] > 0) {
+                if (!_waitingHandlers) {
+                    _waitingHandlers = [];
                 }
-                if (setProp) {
-                    descriptor.set = setProp;
+                if (!_watcherTimer) {
+                    _watcherTimer = scheduleTimeout(function () {
+                        _watcherTimer = null;
+                        _notifyWatchers();
+                    }, 0);
+                }
+                for (var idx = 0; idx < detail.h[_DYN_LENGTH ]; idx++) {
+                    var handler = detail.h[idx];
+                    if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
+                        _waitingHandlers[_DYN_PUSH ](handler);
+                    }
                 }
-                _objDefineProperty$1(target, prop, descriptor);
-                return true;
-            }
-            catch (e) {
             }
         }
-        return false;
-    }
-    function _doNothing(value) {
-        return value;
-    }
-    var objFreeze = _objFreeze || _doNothing;
-    function dateNow() {
-        var dt = Date;
-        return dt.now ? dt.now() : new dt().getTime();
-    }
-    function getExceptionName(object) {
-        if (isError$1(object)) {
-            return object[_DYN_NAME ];
-        }
-        return STR_EMPTY;
-    }
-    function setValue(target, field, value, valChk, srcChk) {
-        var theValue = value;
-        if (target) {
-            theValue = target[field];
-            if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
-                theValue = value;
-                target[field] = theValue;
+        function _trackHandler(handler, detail) {
+            if (handler) {
+                var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
+                if (arrIndexOf(details, detail) === -1) {
+                    details[_DYN_PUSH ](detail);
+                }
             }
         }
-        return theValue;
+        theState = (_a = {
+                prop: dynamicPropertySymbol,
+                ro: dynamicPropertyReadOnly,
+                rf: dynamicPropertyReferenced
+            },
+            _a[_DYN_BLK_VAL ] = dynamicPropertyBlockValue,
+            _a[_DYN_HDLR ] = cfgHandler,
+            _a.add = _addWatcher,
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.use = _useHandler,
+            _a.trk = _trackHandler,
+            _a);
+        return theState;
     }
-    function getCfgValue(theValue, defaultValue) {
-        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+
+    function _createAndUseHandler(state, configHandler) {
+        var handler = {
+            fn: configHandler,
+            rm: function () {
+                handler.fn = null;
+                state = null;
+                configHandler = null;
+            }
+        };
+        state.use(handler, configHandler);
+        return handler;
     }
-    function _createProxyFunction(source, funcName) {
-        var srcFunc = null;
-        var src = null;
-        if (isFunction$1(source)) {
-            srcFunc = source;
+    function _createDynamicHandler(logger, target, inPlace) {
+        var _a;
+        var dynamicHandler = getDynamicConfigHandler(target);
+        if (dynamicHandler) {
+            return dynamicHandler;
         }
-        else {
-            src = source;
+        var uid = createUniqueNamespace("dyncfg", true);
+        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+        var theState;
+        function _notifyWatchers() {
+            theState[_DYN_NOTIFY ]();
         }
-        return function () {
-            var originalArguments = arguments;
-            if (srcFunc) {
-                src = srcFunc();
-            }
-            if (src) {
-                return src[funcName][_DYN_APPLY ](src, originalArguments);
+        function _setValue(target, name, value) {
+            try {
+                target = _setDynamicProperty(theState, target, name, value);
             }
-        };
-    }
-    function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
-        if (target && name && source) {
-            if (overwriteTarget !== false || isUndefined(target[name])) {
-                target[name] = _createProxyFunction(source, theFunc);
+            catch (e) {
+                _throwDynamicError(logger, name, "Setting value", e);
             }
+            return target[name];
         }
-    }
-    function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
-        var theArgs = arguments;
-        var extended = theArgs[0] || {};
-        var argLen = theArgs[_DYN_LENGTH ];
-        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$1(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$1(newValue)) || isPlainObject(newValue))) {
-                    var clone = extended[prop];
-                    if (isNewArray) {
-                        if (!isArray$1(clone)) {
-                            clone = [];
-                        }
-                    }
-                    else if (!isPlainObject(clone)) {
-                        clone = {};
+        function _watch(configHandler) {
+            return _createAndUseHandler(theState, configHandler);
+        }
+        function _block(configHandler, allowUpdate) {
+            theState.use(null, function (details) {
+                var prevUpd = theState.upd;
+                try {
+                    if (!isUndefined(allowUpdate)) {
+                        theState.upd = allowUpdate;
                     }
-                    newValue = objExtend(deep, clone, newValue);
+                    configHandler(details);
                 }
-                if (newValue !== undefined) {
-                    extended[prop] = newValue;
+                finally {
+                    theState.upd = prevUpd;
                 }
-            }
+            });
         }
-        return extended;
-    }
-
-    var strWindow = "window";
-    var strNavigator = "navigator";
-    var strConsole = "console";
-    var strJSON = "JSON";
-    var strCrypto = "crypto";
-    var strMsCrypto = "msCrypto";
-    var strMsie = "msie";
-    var strTrident = "trident/";
-    var _isTrident = null;
-    var _navUserAgentCheck = null;
-    function getGlobalInst(name) {
-        var gbl = getGlobal();
-        if (gbl && gbl[name]) {
-            return gbl[name];
+        function _ref(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 ] = true, _a))[name];
         }
-        if (name === strWindow && hasWindow()) {
-            return window;
+        function _rdOnly(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 ] = true, _a))[name];
         }
-        return null;
-    }
-    function hasWindow() {
-        return Boolean(typeof window === strShimObject && window);
-    }
-    function hasNavigator() {
-        return Boolean(typeof navigator === strShimObject && navigator);
-    }
-    function getNavigator() {
-        if (hasNavigator()) {
-            return navigator;
+        function _blkPropValue(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 ] = true, _a))[name];
         }
-        return getGlobalInst(strNavigator);
-    }
-    function getConsole() {
-        if (typeof console !== strShimUndefined) {
-            return console;
+        function _applyDefaults(theConfig, defaultValues) {
+            if (defaultValues) {
+                objForEachKey(defaultValues, function (name, value) {
+                    _applyDefaultValue(cfgHandler, theConfig, name, value);
+                });
+            }
+            return theConfig;
         }
-        return getGlobalInst(strConsole);
-    }
-    function hasJSON() {
-        return Boolean((typeof JSON === strShimObject && JSON) || getGlobalInst(strJSON) !== null);
+        var cfgHandler = (_a = {
+                uid: null,
+                cfg: newTarget
+            },
+            _a[_DYN_LOGGER ] = logger,
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.set = _setValue,
+            _a[_DYN_SET_DF ] = _applyDefaults,
+            _a[_DYN_WATCH ] = _watch,
+            _a.ref = _ref,
+            _a[_DYN_RD_ONLY ] = _rdOnly,
+            _a[_DYN_BLK_VAL ] = _blkPropValue,
+            _a._block = _block,
+            _a);
+        objDefine(cfgHandler, "uid", {
+            c: false,
+            e: false,
+            w: false,
+            v: uid
+        });
+        theState = _createState(cfgHandler);
+        _makeDynamicObject(theState, newTarget, "config", "Creating");
+        return cfgHandler;
     }
-    function getJSON() {
-        if (hasJSON()) {
-            return JSON || getGlobalInst(strJSON);
+    function _logInvalidAccess(logger, message) {
+        if (logger) {
+            logger[_DYN_WARN_TO_CONSOLE ](message);
+            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
         }
-        return null;
-    }
-    function getCrypto() {
-        return getGlobalInst(strCrypto);
-    }
-    function getMsCrypto() {
-        return getGlobalInst(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 ]();
-            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+        else {
+            throwInvalidAccess(message);
         }
-        return _isTrident;
     }
-    function dumpObj$1(object) {
-        var objectTypeDump = Object[strShimPrototype].toString[_DYN_CALL ](object);
-        var propertyValueDump = STR_EMPTY;
-        if (objectTypeDump === "[object Error]") {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object[_DYN_NAME ] + "'";
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
         }
-        else if (hasJSON()) {
-            propertyValueDump = getJSON().stringify(object);
+        return dynamicHandler;
+    }
+    function onConfigChange(config, configHandler, logger) {
+        var handler = config[CFG_HANDLER_LINK] || config;
+        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler[_DYN_WATCH ](configHandler);
         }
-        return objectTypeDump + propertyValueDump;
+        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
     var _aiNamespace = null;
     function _getExtensionNamespace() {
-        var target = getGlobalInst("Microsoft");
+        var target = getInst("Microsoft");
         if (target) {
             _aiNamespace = target["ApplicationInsights"];
         }
@@ -725,9 +1905,23 @@
         return ns ? ns["ChromeDbgExt"] : null;
     }
 
+    var _a$1;
+    var STR_WARN_TO_CONSOLE = "warnToConsole";
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
+    var defaultValues$1 = {
+        loggingLevelConsole: 0,
+        loggingLevelTelemetry: 1,
+        maxMessageLimit: 25,
+        enableDebug: false
+    };
+    var _logFuncs = (_a$1 = {},
+        _a$1[0 ] = null,
+        _a$1[1 ] = "errorToConsole",
+        _a$1[2 ] = STR_WARN_TO_CONSOLE,
+        _a$1[3 ] = "debugToConsole",
+        _a$1);
     function _sanitizeDiagnosticText(text) {
         if (text) {
             return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
@@ -741,7 +1935,7 @@
             if (theConsole[func]) {
                 logFunc = func;
             }
-            if (isFunction$1(theConsole[logFunc])) {
+            if (isFunction(theConsole[logFunc])) {
                 theConsole[logFunc](message);
             }
         }
@@ -778,20 +1972,18 @@
             var _loggingLevelTelemetry;
             var _maxInternalMessageLimit;
             var _enableDebug;
+            var _unloadHandler;
             dynamicProto(DiagnosticLogger, this, function (_self) {
-                _setDefaultsFromConfig(config || {});
+                _unloadHandler = _setDefaultsFromConfig(config || {});
                 _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
-                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
-                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
-                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebug; };
-                _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
+                _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 (_enableDebug) {
-                        throw dumpObj$1(message);
+                        throw dumpObj(message);
                     }
                     else {
-                        var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
+                        var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
                         if (!isUndefined(message[_DYN_MESSAGE ])) {
                             if (isUserAct) {
                                 var messageKey = +message[_DYN_MESSAGE_ID ];
@@ -812,11 +2004,15 @@
                         }
                     }
                 };
-                _self[STR_WARN_TO_CONSOLE ] = function (message) {
+                _self.debugToConsole = function (message) {
+                    _logToConsole("debug", message);
+                    _debugExtMsg("warning", message);
+                };
+                _self[_DYN_WARN_TO_CONSOLE ] = function (message) {
                     _logToConsole("warn", message);
                     _debugExtMsg("warning", message);
                 };
-                _self[STR_ERROR_TO_CONSOLE ] = function (message) {
+                _self.errorToConsole = function (message) {
                     _logToConsole("error", message);
                     _debugExtMsg("error", message);
                 };
@@ -825,6 +2021,10 @@
                     _messageLogged = {};
                 };
                 _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+                _self[_DYN_UNLOAD ] = function (isAsync) {
+                    _unloadHandler && _unloadHandler.rm();
+                    _unloadHandler = null;
+                };
                 function _logInternalMessage(severity, message) {
                     if (_areInternalMessagesThrottled()) {
                         return;
@@ -848,19 +2048,22 @@
                             var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
                             _self.queue[_DYN_PUSH ](throttleMessage);
                             if (severity === 1 ) {
-                                _self[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
+                                _self.errorToConsole(throttleLimitMessage);
                             }
                             else {
-                                _self[STR_WARN_TO_CONSOLE ](throttleLimitMessage);
+                                _self[_DYN_WARN_TO_CONSOLE ](throttleLimitMessage);
                             }
                         }
                     }
                 }
                 function _setDefaultsFromConfig(config) {
-                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
-                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
-                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
-                    _enableDebug = getCfgValue(config.enableDebug, getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false));
+                    return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
+                        var config = details.cfg;
+                        _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                        _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                        _maxInternalMessageLimit = config.maxMessageLimit;
+                        _enableDebug = config.enableDebug;
+                    });
                 }
                 function _areInternalMessagesThrottled() {
                     return _messageCount >= _maxInternalMessageLimit;
@@ -881,10 +2084,10 @@
     }
     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);
+        _getLogger(logger)[_DYN_WARN_TO_CONSOLE ](message);
     }
 
     var strExecutionContextKey = "ctx";
@@ -893,19 +2096,20 @@
     var PerfEvent = /** @class */ (function () {
         function PerfEvent(name, payloadDetails, isAsync) {
             var _self = this;
-            var accessorDefined = false;
-            _self.start = dateNow();
+            _self.start = utcNow();
             _self[_DYN_NAME ] = name;
             _self[_DYN_IS_ASYNC ] = isAsync;
             _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
-            if (isFunction$1(payloadDetails)) {
+            if (isFunction(payloadDetails)) {
                 var theDetails_1;
-                accessorDefined = objDefineAccessors(_self, "payload", function () {
-                    if (!theDetails_1 && isFunction$1(payloadDetails)) {
-                        theDetails_1 = payloadDetails();
-                        payloadDetails = null;
+                objDefine(_self, "payload", {
+                    g: function () {
+                        if (!theDetails_1 && isFunction(payloadDetails)) {
+                            theDetails_1 = payloadDetails();
+                            payloadDetails = null;
+                        }
+                        return theDetails_1;
                     }
-                    return theDetails_1;
                 });
             }
             _self[_DYN_GET_CTX ] = function (key) {
@@ -937,7 +2141,7 @@
             _self[_DYN_COMPLETE ] = function () {
                 var childTime = 0;
                 var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                if (isArray$1(childEvts)) {
+                if (isArray(childEvts)) {
                     for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
                         var childEvt = childEvts[lp];
                         if (childEvt) {
@@ -945,12 +2149,9 @@
                         }
                     }
                 }
-                _self[_DYN_TIME ] = dateNow() - _self.start;
+                _self[_DYN_TIME ] = utcNow() - _self.start;
                 _self.exTime = _self[_DYN_TIME ] - childTime;
                 _self[_DYN_COMPLETE ] = function () { };
-                if (!accessorDefined && isFunction$1(payloadDetails)) {
-                    _self.payload = payloadDetails();
-                }
             };
         }
         PerfEvent.ParentContextKey = "parent";
@@ -967,178 +2168,38 @@
             if (perfMgr) {
                 var perfEvt = void 0;
                 var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
-                try {
-                    perfEvt = perfMgr.create(getSource(), details, isAsync);
-                    if (perfEvt) {
-                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
-                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
-                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
-                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                                if (!children) {
-                                    children = [];
-                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
-                                }
-                                children[_DYN_PUSH ](perfEvt);
-                            }
-                        }
-                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
-                        return func(perfEvt);
-                    }
-                }
-                catch (ex) {
-                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
-                        perfEvt[_DYN_SET_CTX ]("exception", ex);
-                    }
-                }
-                finally {
-                    if (perfEvt) {
-                        perfMgr.fire(perfEvt);
-                    }
-                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
-                }
-            }
-        }
-        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 ] < 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 = '2.8.12';
-    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;
+                try {
+                    perfEvt = perfMgr.create(getSource(), details, isAsync);
+                    if (perfEvt) {
+                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                                if (!children) {
+                                    children = [];
+                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
+                                }
+                                children[_DYN_PUSH ](perfEvt);
+                            }
+                        }
+                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
+                        return func(perfEvt);
                     }
-                    return defValue;
                 }
-                return theCache[normalizeJsName(name)];
-            },
-            kill: function (target, name) {
-                if (target && target[name]) {
-                    try {
-                        delete target[name];
+                catch (ex) {
+                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ]("exception", ex);
                     }
-                    catch (e) {
+                }
+                finally {
+                    if (perfEvt) {
+                        perfMgr.fire(perfEvt);
                     }
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
                 }
             }
-        };
-        return data;
+        }
+        return func();
     }
 
     var pluginStateData = createElmNodeData("plugin");
@@ -1157,11 +2218,14 @@
             }
             proxy = proxy[_DYN_GET_NEXT ]();
         }
-        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
+        return createTelemetryProxyChain([startAt], core.config || {}, core);
     }
-    function _createInternalContext(telemetryChain, config, core, startAt) {
+    function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
         var _nextProxy = null;
         var _onComplete = [];
+        if (!dynamicHandler) {
+            dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
+        }
         if (startAt !== null) {
             _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
         }
@@ -1172,12 +2236,12 @@
                     return core;
                 },
                 diagLog: function () {
-                    return safeGetLogger(core, config);
+                    return safeGetLogger(core, dynamicHandler.cfg);
                 },
                 getCfg: function () {
-                    return config;
+                    return dynamicHandler.cfg;
                 },
-                getExtCfg: _getExtCfg,
+                getExtCfg: _resolveExtCfg,
                 getConfig: _getConfig,
                 hasNext: function () {
                     return !!_nextProxy;
@@ -1213,10 +2277,10 @@
                 if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
                     arrForEach(onComplete, function (completeDetails) {
                         try {
-                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
+                            completeDetails.func.call(completeDetails.self, completeDetails.args);
                         }
                         catch (e) {
-                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj$1(e));
+                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
                         }
                     });
                     _onComplete = [];
@@ -1224,48 +2288,54 @@
             }
             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;
+            var cfg = dynamicHandler.cfg;
+            if (cfg && identifier) {
+                var extCfg = cfg[STR_EXTENSION_CONFIG ];
+                if (!extCfg && createIfMissing) {
+                    extCfg = {};
+                }
+                cfg[STR_EXTENSION_CONFIG] = extCfg;
+                extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
+                if (extCfg) {
+                    idCfg = extCfg[identifier];
+                    if (!idCfg && createIfMissing) {
+                        idCfg = {};
                     }
-                    theConfig = newConfig_1;
+                    extCfg[identifier] = idCfg;
+                    idCfg = dynamicHandler.ref(extCfg, identifier);
                 }
             }
-            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 = dynamicHandler.cfg[field];
+                        if (cfgValue || !isNullOrUndefined(cfgValue)) {
+                            newConfig[field] = cfgValue;
+                        }
+                    }
+                    _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
+                });
+            }
+            return dynamicHandler[_DYN_SET_DF ](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 = dynamicHandler.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;
@@ -1278,38 +2348,41 @@
         }
         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$1(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            if (isArray(plugins)) {
+                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.config);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(unloadState) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.unload(context, unloadState);
+            nextPlugin && nextPlugin[_DYN_UNLOAD ](context, unloadState);
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
             if (plugins === void 0) { plugins = null; }
-            if (isArray$1(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
             return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
@@ -1318,20 +2391,20 @@
         return context;
     }
     function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = core[_DYN_CONFIG ] || {};
+        var config = createDynamicConfig(core.config);
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(updateState) {
             return context.iterate(function (plugin) {
-                if (isFunction$1(plugin[_DYN_UPDATE ])) {
+                if (isFunction(plugin[_DYN_UPDATE ])) {
                     plugin[_DYN_UPDATE ](context, updateState);
                 }
             });
         }
         function _createNew(plugins, startAt) {
             if (plugins === void 0) { plugins = null; }
-            if (isArray$1(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
             }
             return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
@@ -1342,13 +2415,13 @@
     function createTelemetryProxyChain(plugins, config, core, startAt) {
         var firstProxy = null;
         var add = startAt ? false : true;
-        if (isArray$1(plugins) && plugins[_DYN_LENGTH ] > 0) {
+        if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
             var lastProxy_1 = null;
             arrForEach(plugins, function (thePlugin) {
                 if (!add && startAt === thePlugin) {
                     add = true;
                 }
-                if (add && thePlugin && isFunction$1(thePlugin[STR_PROCESS_TELEMETRY ])) {
+                if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
                     var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
                     if (!firstProxy) {
                         firstProxy = newProxy;
@@ -1367,8 +2440,8 @@
     }
     function createTelemetryPluginProxy(plugin, config, core) {
         var nextProxy = null;
-        var hasProcessTelemetry = isFunction$1(plugin[STR_PROCESS_TELEMETRY ]);
-        var hasSetNext = isFunction$1(plugin[_DYN_SET_NEXT_PLUGIN ]);
+        var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
+        var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
         var chainId;
         if (plugin) {
             chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
@@ -1393,7 +2466,7 @@
         };
         function _getTelCtx() {
             var itemCtx;
-            if (plugin && isFunction$1(plugin[strGetTelCtx])) {
+            if (plugin && isFunction(plugin[strGetTelCtx])) {
                 itemCtx = plugin[strGetTelCtx]();
             }
             if (!itemCtx) {
@@ -1425,7 +2498,7 @@
                             hasRun = true;
                         }
                         if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj$1(error) + ", run flags: " + dumpObj$1(hasRunContext));
+                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
                         }
                     }
                 }, details, isAsync);
@@ -1507,7 +2580,7 @@
                     handler(unloadCtx, unloadState);
                 }
                 catch (e) {
-                    _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj$1(e));
+                    _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
                 }
             });
             handlers = [];
@@ -1518,7 +2591,36 @@
         };
     }
 
+    function createUnloadHookContainer() {
+        var _hooks = [];
+        function _doUnload(logger) {
+            var oldHooks = _hooks;
+            _hooks = [];
+            arrForEach(oldHooks, function (fn) {
+                try {
+                    (fn.rm || fn.remove).call(fn);
+                }
+                catch (e) {
+                    _throwInternal(logger, 2 , 73 , "Unloading:" + dumpObj(e));
+                }
+            });
+        }
+        function _addHook(hooks) {
+            if (hooks) {
+                arrAppend(_hooks, hooks);
+            }
+        }
+        return {
+            run: _doUnload,
+            add: _addHook
+        };
+    }
+
+    var _a;
     var strGetPlugin = "getPlugin";
+    var defaultValues = (_a = {},
+        _a[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} },
+        _a);
     var BaseTelemetryPlugin = /** @class */ (function () {
         function BaseTelemetryPlugin() {
             var _self = this;
@@ -1526,7 +2628,7 @@
             var _rootCtx;
             var _nextPlugin;
             var _unloadHandlerContainer;
-            var _hooks;
+            var _hookContainer;
             _initDefaults();
             dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
                 _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
@@ -1551,11 +2653,7 @@
                         if (!unloadDone) {
                             unloadDone = true;
                             _unloadHandlerContainer.run(theUnloadCtx, unloadState);
-                            var oldHooks = _hooks;
-                            _hooks = [];
-                            arrForEach(oldHooks, function (fn) {
-                                fn.rm();
-                            });
+                            _hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG ]());
                             if (result === true) {
                                 theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
                             }
@@ -1595,17 +2693,9 @@
                     }
                     return result;
                 };
-                _self._addHook = function (hooks) {
-                    if (hooks) {
-                        if (isArray$1(hooks)) {
-                            _hooks = _hooks.concat(hooks);
-                        }
-                        else {
-                            _hooks[_DYN_PUSH ](hooks);
-                        }
-                    }
-                };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
+                proxyFunctionAs(_self, "_addHook", function () { return _hookContainer; }, "add");
+                objDefine(_self, "_unloadHooks", { g: function () { return _hookContainer; } });
             });
             _self[_DYN_DIAG_LOG ] = function (itemCtx) {
                 return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
@@ -1623,7 +2713,7 @@
                 if (itemCtx) {
                     itemCtx[_DYN_PROCESS_NEXT ](env);
                 }
-                else if (_nextPlugin && isFunction$1(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
+                else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
                     _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
                 }
             };
@@ -1643,9 +2733,7 @@
                 return itemCtx;
             }
             function _setDefaults(config, core, pluginChain) {
-                if (config) {
-                    setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
-                }
+                createDynamicConfig(config, defaultValues, safeGetLogger(core));
                 if (!pluginChain && core) {
                     pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
                 }
@@ -1661,7 +2749,7 @@
                 _self[STR_CORE ] = null;
                 _rootCtx = null;
                 _nextPlugin = null;
-                _hooks = [];
+                _hookContainer = createUnloadHookContainer();
                 _unloadHandlerContainer = createUnloadHandlerContainer();
             }
         }
@@ -1669,196 +2757,16 @@
         return BaseTelemetryPlugin;
     }());
 
-    var _DYN_EXTENSION_CONFIG = "extensionConfig";
-
-    var ConfigurationManager = /** @class */ (function () {
-        function ConfigurationManager() {
-        }
-        ConfigurationManager.getConfig = function (config, field, identifier, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = false; }
-            var configValue;
-            if (identifier && config[_DYN_EXTENSION_CONFIG ] && config[_DYN_EXTENSION_CONFIG ][identifier] && !isNullOrUndefined(config[_DYN_EXTENSION_CONFIG ][identifier][field])) {
-                configValue = config[_DYN_EXTENSION_CONFIG ][identifier][field];
-            }
-            else {
-                configValue = config[field];
-            }
-            return !isNullOrUndefined(configValue) ? configValue : defaultValue;
-        };
-        return ConfigurationManager;
-    }());
-
     var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
 
-    var UNDEF_VALUE = undefined;
-    var EMPTY = "";
-    var FUNCTION = "function";
-    var NUMBER = "number";
-    var PROTOTYPE = "prototype";
-    var STRING = "string";
-    var SLICE = "slice";
-    var ObjClass = Object;
-    var ObjProto = ObjClass[PROTOTYPE];
-    var StrCls = String;
-    var ArrCls = Array;
-    var ArrProto = ArrCls[PROTOTYPE];
-
-    function _createIs(theType) {
-        return function (value) {
-            return typeof value === theType;
-        };
-    }
-    function _createObjIs(theName) {
-        var theType = "[object " + theName + "]";
-        return function (value) {
-            return !!(value && objToString(value) === theType);
-        };
-    }
-    function objToString(value) {
-        return ObjProto.toString.call(value);
-    }
-    var isString = _createIs(STRING);
-    var isFunction = _createIs(FUNCTION);
-    var isArray = ArrCls.isArray;
-    var isNumber = _createIs(NUMBER);
-    var isError = _createObjIs("Error");
-    function isPromiseLike(value) {
-        return !!value && isFunction(value.then);
-    }
-
-    function throwTypeError(message) {
-        throw new TypeError(message);
-    }
-
-    var asString = StrCls;
-
-    function dumpObj(object, format) {
-        var propertyValueDump = EMPTY;
-        if (isError(object)) {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
-        }
-        else {
-            try {
-                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
-            }
-            catch (e) {
-                propertyValueDump = " - " + dumpObj(e, format);
-            }
-        }
-        return objToString(object) + ": " + propertyValueDump;
-    }
-
-    function _unwrapFunction(funcName, target, polyFunc) {
-        return function (thisArg) {
-            var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
-            if (theFunc || polyFunc) {
-                var theArgs = arguments;
-                return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
-            }
-            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
-        };
-    }
-
-    var objDefineProp = ObjClass["defineProperty"];
-
-    var arrSlice = _unwrapFunction(SLICE, ArrProto);
-
-    var REF = "ref";
-    var UNREF = "un" + REF;
-    var HAS_REF = "hasRef";
-    var ENABLED = "enabled";
-    function _createTimerHandler(startTimer, refreshFn, cancelFn) {
-        var _a;
-        var ref = true;
-        var timerId = startTimer ? refreshFn(null) : null;
-        var theTimerHandler;
-        var _unref = function () {
-            ref = false;
-            timerId && timerId[UNREF] && timerId[UNREF]();
-            return theTimerHandler;
-        };
-        var _ref = function () {
-            ref = true;
-            timerId && timerId[REF] && timerId[REF]();
-            return theTimerHandler;
-        };
-        var _hasRef = function () {
-            if (timerId && timerId[HAS_REF]) {
-                return timerId[HAS_REF]();
-            }
-            return ref;
-        };
-        var _refresh = function () {
-            timerId = refreshFn(timerId);
-            if (!ref) {
-                _unref();
-            }
-            return theTimerHandler;
-        };
-        var _cancel = function () {
-            timerId && cancelFn(timerId);
-            timerId = null;
-        };
-        var _setEnabled = function (value) {
-            !value && timerId && _cancel();
-            value && !timerId && _refresh();
-        };
-        theTimerHandler = (_a = {
-                cancel: _cancel,
-                refresh: _refresh
-            },
-            _a[HAS_REF] = _hasRef,
-            _a[REF] = _ref,
-            _a[UNREF] = _unref,
-            _a[ENABLED] = false,
-            _a);
-        objDefineProp(theTimerHandler, ENABLED, {
-            get: function () { return !!timerId; },
-            set: _setEnabled
-        });
-        return {
-            h: theTimerHandler,
-            dn: function () {
-                timerId = null;
-            }
-        };
-    }
-
-    function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
-        var isArr = isArray(overrideFn);
-        var len = isArr ? overrideFn.length : 0;
-        var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
-        var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
-        var timerFn = theArgs[0];
-        theArgs[0] = function () {
-            handler.dn();
-            timerFn.apply(self, arguments);
-        };
-        var handler = _createTimerHandler(startTimer, function (timerId) {
-            if (timerId) {
-                if (timerId.refresh) {
-                    timerId.refresh();
-                    return timerId;
-                }
-                clearFn.call(self, timerId);
-            }
-            return setFn.apply(self, theArgs);
-        }, function (timerId) {
-            clearFn.call(self, timerId);
-        });
-        return handler.h;
-    }
-    function scheduleTimeout(callback, timeout) {
-        return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
-    }
-
-    function getReactNativeDeviceInfo() {
-        return DeviceInfo__default["default"];
-    }
-
-    var ReactNativePlugin = /** @class */ (function (_super) {
-        __extendsFn(ReactNativePlugin, _super);
-        function ReactNativePlugin(config) {
+    var defaultReactNativePluginConfig = objDeepFreeze({
+        disableDeviceCollection: false,
+        disableExceptionCollection: false,
+        uniqueIdPromiseTimeout: 5000
+    });
+    var ReactNativeManualDevicePlugin = /** @class */ (function (_super) {
+        __extendsFn(ReactNativeManualDevicePlugin, _super);
+        function ReactNativeManualDevicePlugin(config) {
             var _this = _super.call(this) || this;
             _this.identifier = "AppInsightsReactNativePlugin";
             _this.priority = 140;
@@ -1870,27 +2778,36 @@
             var _waitingTimer;
             var _waitingItems = null;
             var _deviceInfoModule;
-            dynamicProto(ReactNativePlugin, _this, function (_self, _base) {
+            var _deviceInfoNeedsUpdate;
+            var exceptionHandlerSet;
+            dynamicProto(ReactNativeManualDevicePlugin, _this, function (_self, _base) {
                 _initDefaults();
                 _self.initialize = function (config,
                 core, extensions) {
-                    var _a;
+                    var identifier = _this.identifier;
                     if (!_self.isInitialized()) {
                         _base.initialize(config, core, extensions);
-                        var inConfig_1 = config || {};
-                        var defaultConfig = _getDefaultConfig();
-                        objForEachKey(defaultConfig, function (option, value) {
-                            _config[option] = ConfigurationManager.getConfig(inConfig_1, option, _self.identifier, !isUndefined(_config[option]) ? _config[option] : value);
-                        });
-                        if (!_config.disableDeviceCollection) {
-                            _self._collectDeviceInfo();
-                        }
-                        if (core && core.getPlugin) {
-                            _analyticsPlugin = (_a = core.getPlugin(AnalyticsPluginIdentifier)) === null || _a === void 0 ? void 0 : _a.plugin;
-                        }
-                        if (!_config.disableExceptionCollection) {
-                            _self._setExceptionHandler();
-                        }
+                        _self._addHook(onConfigChange(config, function (details) {
+                            var _a;
+                            var ctx = _self._getTelCtx();
+                            _config = ctx.getExtCfg(identifier, defaultReactNativePluginConfig);
+                            if (!_config.disableDeviceCollection && _deviceInfoNeedsUpdate) {
+                                _deviceInfoNeedsUpdate = !_self._collectDeviceInfo();
+                            }
+                            if (core && core.getPlugin) {
+                                _analyticsPlugin = (_a = core.getPlugin(AnalyticsPluginIdentifier)) === null || _a === void 0 ? void 0 : _a.plugin;
+                            }
+                            else {
+                                _analyticsPlugin = null;
+                            }
+                            if (exceptionHandlerSet) {
+                                _resetGlobalErrorHandler();
+                            }
+                            if (!_config.disableExceptionCollection) {
+                                _self._setExceptionHandler();
+                                exceptionHandlerSet = true;
+                            }
+                        }));
                     }
                 };
                 _self.processTelemetry = function (item, itemCtx) {
@@ -1908,6 +2825,7 @@
                 };
                 _self.setDeviceInfoModule = function (deviceInfoModule) {
                     _deviceInfoModule = deviceInfoModule;
+                    _deviceInfoNeedsUpdate = true;
                 };
                 _self.setDeviceId = _setDeviceId;
                 _self.setDeviceModel = function (newModel) {
@@ -1918,10 +2836,13 @@
                 };
                 _self._collectDeviceInfo = function () {
                     try {
-                        var deviceInfoModule = _deviceInfoModule || getReactNativeDeviceInfo();
-                        _device.deviceClass = deviceInfoModule.getDeviceType();
-                        _device.model = deviceInfoModule.getModel();
-                        var uniqueId = deviceInfoModule.getUniqueId();
+                        _deviceInfoModule = _this.getDeviceInfoModule(_deviceInfoModule);
+                        if (!_deviceInfoModule) {
+                            return false;
+                        }
+                        _device.deviceClass = _deviceInfoModule.getDeviceType();
+                        _device.model = _deviceInfoModule.getModel();
+                        var uniqueId = _deviceInfoModule.getUniqueId();
                         if (isPromiseLike(uniqueId)) {
                             _waitingForId = true;
                             if (_waitingTimer) {
@@ -1935,16 +2856,17 @@
                             uniqueId.then(function (value) {
                                 _setDeviceId(value);
                             }, function (reason) {
-                                _warnToConsole(_self.diagLog(), "Failed to get device id: " + dumpObj$1(reason));
+                                _warnToConsole(_self.diagLog(), "Failed to get device id: " + dumpObj(reason));
                                 _setDeviceId(_device.id);
                             });
                         }
                         else if (isString(uniqueId)) {
                             _device.id = uniqueId;
                         }
+                        return true;
                     }
                     catch (e) {
-                        _warnToConsole(_self.diagLog(), "Failed to get DeviceInfo: " + getExceptionName(e) + " - " + dumpObj$1(e));
+                        _warnToConsole(_self.diagLog(), "Failed to get DeviceInfo: " + getExceptionName(e) + " - " + dumpObj(e));
                     }
                 };
                 _self._doTeardown = function (unloadCtx, unloadState, asyncCallback) {
@@ -1953,11 +2875,13 @@
                 };
                 function _initDefaults() {
                     _device = {};
-                    _config = config || _getDefaultConfig();
+                    _config = {};
                     _analyticsPlugin = null;
                     _defaultHandler = null;
                     _waitingForId = false;
                     _deviceInfoModule = null;
+                    _deviceInfoNeedsUpdate = true;
+                    exceptionHandlerSet = false;
                 }
                 function _setDeviceId(newId) {
                     _device.id = newId;
@@ -2025,22 +2949,33 @@
                 }
                 _self._config = _config;
                 _self._getDbgPlgTargets = function () {
-                    return [_device, _deviceInfoModule];
+                    return [_device, _deviceInfoModule, _config];
                 };
             });
-            function _getDefaultConfig() {
-                return {
-                    disableDeviceCollection: false,
-                    disableExceptionCollection: false,
-                    uniqueIdPromiseTimeout: 5000
-                };
-            }
             return _this;
         }
-        ReactNativePlugin.__ieDyn=1;
-        return ReactNativePlugin;
+        ReactNativeManualDevicePlugin.prototype.getDeviceInfoModule = function (_deviceInfoModule) {
+            if (!_deviceInfoModule) {
+                _warnToConsole(this.diagLog(), "Failed to get DeviceInfo. Provide DeviceInfo while init or turn it off by setting disableDeviceCollection flag to true");
+                return null;
+            }
+            return _deviceInfoModule;
+        };
+        return ReactNativeManualDevicePlugin;
     }(BaseTelemetryPlugin));
 
+    var ReactNativePlugin = /** @class */ (function (_super) {
+        __extendsFn(ReactNativePlugin, _super);
+        function ReactNativePlugin() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ReactNativePlugin.prototype.getDeviceInfoModule = function (_deviceInfoModule) {
+            return _deviceInfoModule || getReactNativeDeviceInfo();
+        };
+        return ReactNativePlugin;
+    }(ReactNativeManualDevicePlugin));
+
+    exports.ReactNativeManualDevicePlugin = ReactNativeManualDevicePlugin;
     exports.ReactNativePlugin = ReactNativePlugin;
     exports.getReactNativeDeviceInfo = getReactNativeDeviceInfo;