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

package/browser/{ai.dbg.3.0.0-beta.2210-01.cjs.js → ai.dbg.3.0.0-beta.2210-02.cjs.js}

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Debug Plugin, 3.0.0-beta.2210-01
+ * Application Insights JavaScript SDK - Debug Plugin, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -12,10 +12,8 @@ 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$1 = null;
 function getGlobal$1(useCached) {
@@ -342,11 +340,16 @@ var STRING = "string";
 var UNDEFINED = "undefined";
 var HAS_OWN_PROPERTY = "hasOwnProperty";
 var SYMBOL = "Symbol";
+var POLYFILL_TAG = "_polyfill";
 var INDEX_OF = "indexOf";
 var LENGTH = "length";
+var DONE = "done";
+var VALUE = "value";
 var ObjClass = Object;
 var ObjProto = ObjClass[PROTOTYPE];
+var StrCls = String;
 var ArrCls = Array;
+var ArrProto = ArrCls[PROTOTYPE];
 
 function _safeCheck(cb, defValue) {
     var result = defValue;
@@ -450,7 +453,7 @@ function polyObjHasOwn(obj, prop) {
     return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
 }
 
-function objForEachKey(theObject, callbackfn, thisArg) {
+function objForEachKey$1(theObject, callbackfn, thisArg) {
     if (theObject && isObject(theObject)) {
         for (var prop in theObject) {
             if (objHasOwn(theObject, prop)) {
@@ -491,11 +494,65 @@ function objKeys(value) {
 }
 var objFreeze = _objFreeze || _doNothing;
 
-_safeCheck(function () { return isDefined(Symbol); }, false);
+var POLY_GLOBAL_REGISTORT = "__polySymbols$ts_utils";
+var _polySymbols;
+function _globalSymbolRegistry() {
+    if (!_polySymbols) {
+        var gbl = getGlobal();
+        _polySymbols = gbl[POLY_GLOBAL_REGISTORT] = gbl[POLY_GLOBAL_REGISTORT] || { k: {}, s: {} };
+    }
+    return _polySymbols;
+}
+function polyNewSymbol(description) {
+    var theSymbol = {
+        description: "" + description,
+        toString: function () { return SYMBOL + "(" + description + ")"; }
+    };
+    theSymbol[POLYFILL_TAG] = true;
+    return theSymbol;
+}
+function polySymbolFor(key) {
+    var registry = _globalSymbolRegistry();
+    if (!objHasOwn(registry, key)) {
+        var newSymbol = polyNewSymbol(key);
+        registry.k[key] = newSymbol;
+        registry.s[newSymbol] = "" + key;
+    }
+    return registry.k[key];
+}
+
+var _hasSymbol = _safeCheck(function () { return isDefined(Symbol); }, false);
 var _symbol = getInst(SYMBOL);
-_symbol && _safeCheck(function () { return _symbol["for"]; }, null);
+var _symbolFor = _symbol && _safeCheck(function () { return _symbol["for"]; }, null);
 _symbol && _safeCheck(function () { return _symbol["keyFor"]; }, null);
 var isSymbol = _createIs("symbol");
+function newSymbol(description, noPoly) {
+    return _hasSymbol ? Symbol(description) : (!noPoly ? polyNewSymbol(description) : null);
+}
+var symbolFor = _symbolFor || polySymbolFor;
+
+function isIterator(value) {
+    return !!value && isFunction(value.next);
+}
+
+function arrAppend(target, elms) {
+    if (!isUndefined(elms) && target) {
+        if (isArray(elms)) {
+            ArrProto.push.apply(target, elms);
+        }
+        else if (isIterator(elms)) {
+            var value = elms.next();
+            while (!value[DONE]) {
+                target.push(value[VALUE]);
+                value = elms.next();
+            }
+        }
+        else {
+            target.push(elms);
+        }
+    }
+    return target;
+}
 
 function dumpObj(object, format) {
     var objectTypeDump = objToString(object);
@@ -540,7 +597,7 @@ function objSetPrototypeOf(obj, proto) {
             d.__proto__ = b;
         }) ||
         function (d, b) {
-            objForEachKey(b, function (key, value) {
+            objForEachKey$1(b, function (key, value) {
                 d[key] = value;
             });
         };
@@ -606,43 +663,53 @@ function objDefineAccessors(target, prop, getProp, setProp, configurable) {
 
 var strIndexOf = _unwrapFunction(INDEX_OF);
 
+var asString = StrCls;
+
+var _DYN_LENGTH$1 = "length";
+var _DYN_NOTIFY = "notify";
+var _DYN_THROW_INTERNAL = "throwInternal";
+var _DYN_WATCH = "watch";
+var _DYN_LOGGER = "logger";
+var _DYN_CONFIGURABLE = "configurable";
+var _DYN_ENUMERABLE = "enumerable";
+var _DYN_APPLY = "apply";
+var _DYN_INDEX_OF = "indexOf";
+var _DYN_PUSH$1 = "push";
 var _DYN_INITIALIZE = "initialize";
-var _DYN_NAME$1 = "name";
 var _DYN_IDENTIFIER$1 = "identifier";
-var _DYN_PUSH$1 = "push";
+var _DYN_SPLICE = "splice";
 var _DYN_IS_INITIALIZED = "isInitialized";
-var _DYN_CONFIG = "config";
-var _DYN_LOGGER = "logger";
-var _DYN_LENGTH$1 = "length";
+var _DYN_NAME$1 = "name";
 var _DYN_TIME = "time";
 var _DYN_PROCESS_NEXT = "processNext";
 var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+var _DYN_CALL = "call";
 var _DYN_GET_PLUGIN = "getPlugin";
-var _DYN_SPLICE = "splice";
+var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
 var _DYN_TEARDOWN = "teardown";
 var _DYN_MESSAGE_ID = "messageId";
 var _DYN_MESSAGE = "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_DIAG_LOG = "diagLog";
 var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
 var _DYN_CREATE_NEW = "createNew";
+var _DYN_CONFIG = "config";
 var _DYN_USER_AGENT = "userAgent";
 var _DYN_SPLIT = "split";
 var _DYN_NODE_TYPE = "nodeType";
-var _DYN_APPLY = "apply";
 var _DYN_REPLACE$1 = "replace";
-var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+var _DYN_ENABLE_DEBUG_EXCEPTI5 = "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 UNDEFINED_VALUE = undefined;
 var STR_EMPTY = "";
 var STR_CORE = "core";
 var STR_DISABLED = "disabled";
@@ -652,39 +719,20 @@ var STR_PRIORITY = "priority";
 var STR_ERROR_TO_CONSOLE = "errorToConsole";
 var STR_WARN_TO_CONSOLE = "warnToConsole";
 var STR_GET_PERF_MGR = "getPerfMgr";
+var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
 
-var _aiNamespace = null;
-function _getExtensionNamespace() {
-    var target = getInst("Microsoft");
-    if (target) {
-        _aiNamespace = target["ApplicationInsights"];
-    }
-    return _aiNamespace;
-}
-function getDebugExt(config) {
-    var ns = _aiNamespace;
-    if (!ns && config.disableDbgExt !== true) {
-        ns = _aiNamespace || _getExtensionNamespace();
-    }
-    return ns ? ns["ChromeDbgExt"] : null;
-}
-
-var cString = "String";
-var cObject = "Object";
 var strToString = "toString";
 var strGetPrototypeOf = "getPrototypeOf";
 var strConstructor$1 = "constructor";
-var _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
+var _fnToString = ObjClass$1[strToString];
 var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass$1);
 var rCamelCase = /-([a-z])/g;
 var rNormalizeInvalid = /([^\w\d_$])/g;
 var rLeadingNumeric = /^(\d+[\w\d_$])/;
-function _polyfillRequired(object, name) {
-    return function () {
-        throwUnsupported("Polyfill required for [" + name + "]");
-    };
+var _getObjProto = Object[strGetPrototypeOf];
+function isNotNullOrUndefined(value) {
+    return !isNullOrUndefined(value);
 }
-var _getObjProto = Object[strGetPrototypeOf] || _polyfillRequired(cObject, strGetPrototypeOf);
 function normalizeJsName(name) {
     var value = name;
     if (value && isString(value)) {
@@ -698,6 +746,7 @@ function normalizeJsName(name) {
     }
     return value;
 }
+var objForEachKey = objForEachKey$1;
 function strContains(value, search) {
     if (value && search) {
         return strIndexOf(value, search) !== -1;
@@ -712,7 +761,7 @@ function isPlainObject(value) {
             result = true;
         }
         else {
-            if (proto[strConstructor$1] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor$1)) {
+            if (proto[strConstructor$1] && objHasOwnProperty(proto, strConstructor$1)) {
                 proto = proto[strConstructor$1];
             }
             result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
@@ -724,20 +773,6 @@ function dateNow() {
     var dt = Date;
     return dt.now ? dt.now() : new dt().getTime();
 }
-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;
-        }
-    }
-    return theValue;
-}
-function getCfgValue(theValue, defaultValue) {
-    return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-}
 function _createProxyFunction(source, funcName) {
     var srcFunc = null;
     var src = null;
@@ -764,49 +799,121 @@ function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
         }
     }
 }
-function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
-    var theArgs = arguments;
-    var extended = theArgs[0] || {};
-    var argLen = theArgs[_DYN_LENGTH$1 ];
-    var deep = false;
-    var idx = 1;
-    if (argLen > 0 && isBoolean(extended)) {
-        deep = extended;
-        extended = theArgs[idx] || {};
-        idx++;
-    }
-    if (!isObject(extended)) {
-        extended = {};
-    }
-    for (; idx < argLen; idx++) {
-        var arg = theArgs[idx];
-        var isArgArray = isArray(arg);
-        var isArgObj = isObject(arg);
-        for (var prop in arg) {
-            var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty[_DYN_CALL ](arg, prop)));
-            if (!propOk) {
-                continue;
-            }
-            var newValue = arg[prop];
-            var isNewArray = void 0;
-            if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
-                var clone = extended[prop];
-                if (isNewArray) {
-                    if (!isArray(clone)) {
-                        clone = [];
-                    }
-                }
-                else if (!isPlainObject(clone)) {
-                    clone = {};
+
+var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+function _cfgDeepCopy(source) {
+    if (source) {
+        if (isArray(source)) {
+            var result_1 = [];
+            result_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
+            arrForEach(source, function (value, idx) {
+                result_1[idx] = _cfgDeepCopy(value);
+            });
+            return result_1;
+        }
+        if (isPlainObject(source)) {
+            var target_1 = {};
+            objForEachKey$1(source, function (key, value) {
+                target_1[key] = _cfgDeepCopy(value);
+            });
+            return target_1;
+        }
+    }
+    return source;
+}
+function getDynamicConfigHandler(value) {
+    if (value) {
+        var handler = value[CFG_HANDLER_LINK] || value;
+        if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler;
+        }
+    }
+    return null;
+}
+function throwInvalidAccess(message) {
+    throwTypeError("InvalidAccess:" + message);
+}
+
+function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+    var defValue;
+    var isDefaultValid = cfgDefaults.dfVal || isDefined;
+    if (theConfig && cfgDefaults.fb) {
+        var fallbacks = cfgDefaults.fb;
+        if (!isArray(fallbacks)) {
+            fallbacks = [fallbacks];
+        }
+        for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1 ]; lp++) {
+            var fallback = fallbacks[lp];
+            var fbValue = theConfig[fallback];
+            if (isDefaultValid(fbValue)) {
+                defValue = fbValue;
+            }
+            else {
+                fbValue = dynamicHandler.cfg[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
                 }
-                newValue = objExtend(deep, clone, newValue);
+                dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
             }
-            if (newValue !== undefined) {
-                extended[prop] = newValue;
+            if (isDefaultValid(defValue)) {
+                break;
             }
         }
     }
-    return extended;
+    if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+        defValue = cfgDefaults.v;
+    }
+    return defValue;
+}
+function _applyDefaultValue(theConfig, name, defaultValue) {
+    var dynamicHandler = theConfig[CFG_HANDLER_LINK];
+    if (!dynamicHandler) {
+        throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
+    }
+    var isValid;
+    var setFn;
+    var defValue;
+    var cfgDefaults = defaultValue;
+    if (cfgDefaults && isObject(cfgDefaults) && (cfgDefaults.isVal || cfgDefaults.set || cfgDefaults.fb || objHasOwn(cfgDefaults, "v"))) {
+        isValid = cfgDefaults.isVal;
+        setFn = cfgDefaults.set;
+        defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    else {
+        defValue = defaultValue;
+    }
+    var theValue = defValue;
+    var usingDefault = true;
+    var cfgValue = theConfig[name];
+    if (cfgValue || !isNullOrUndefined(cfgValue)) {
+        theValue = cfgValue;
+        usingDefault = false;
+    }
+    if (!usingDefault) {
+        if (isValid && theValue !== defValue && !isValid(theValue)) {
+            theValue = defValue;
+            usingDefault = true;
+        }
+        if (setFn) {
+            theValue = setFn(theValue, defValue, theConfig);
+            usingDefault = theValue === defValue;
+        }
+    }
+    if (theValue && usingDefault && (isPlainObject(theValue) || isArray(theValue))) {
+        theValue = _cfgDeepCopy(theValue);
+    }
+    dynamicHandler.set(theConfig, name, theValue);
+}
+function applyDefaults(theConfig, defaultValues) {
+    if (defaultValues) {
+        if (theConfig && !theConfig[CFG_HANDLER_LINK] && (isPlainObject(theConfig) || isArray(theConfig))) {
+            throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
+        }
+        objForEachKey(defaultValues, function (name, value) {
+            _applyDefaultValue(theConfig, name, value);
+        });
+    }
+    return theConfig;
 }
 
 var strDocumentMode = "documentMode";
@@ -868,9 +975,430 @@ function getIEVersion(userAgentStr) {
     return null;
 }
 
+var UInt32Mask = 0x100000000;
+var MaxUInt32 = 0xffffffff;
+var _mwcSeeded = false;
+var _mwcW = 123456789;
+var _mwcZ = 987654321;
+function _mwcSeed(seedValue) {
+    if (seedValue < 0) {
+        seedValue >>>= 0;
+    }
+    _mwcW = (123456789 + seedValue) & MaxUInt32;
+    _mwcZ = (987654321 - seedValue) & MaxUInt32;
+    _mwcSeeded = true;
+}
+function _autoSeedMwc() {
+    try {
+        var now = dateNow() & 0x7fffffff;
+        _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+    }
+    catch (e) {
+    }
+}
+function random32(signed) {
+    var value = 0;
+    var c = getCrypto() || getMsCrypto();
+    if (c && c.getRandomValues) {
+        value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
+    }
+    if (value === 0 && isIE()) {
+        if (!_mwcSeeded) {
+            _autoSeedMwc();
+        }
+        value = mwcRandom32() & MaxUInt32;
+    }
+    if (value === 0) {
+        value = Math.floor((UInt32Mask * Math.random()) | 0);
+    }
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function mwcRandom32(signed) {
+    _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
+    _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
+    var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function newId(maxLength) {
+    if (maxLength === void 0) { maxLength = 22; }
+    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var number = random32() >>> 0;
+    var chars = 0;
+    var result = STR_EMPTY;
+    while (result[_DYN_LENGTH$1 ] < maxLength) {
+        chars++;
+        result += base64chars.charAt(number & 0x3F);
+        number >>>= 6;
+        if (chars === 5) {
+            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+            chars = 0;
+        }
+    }
+    return result;
+}
+
+var _objDefineProperty = ObjDefineProperty;
+var version = "3.0.0-beta.2210-02";
+var instanceName = "." + newId(6);
+var _dataUid = 0;
+function _createAccessor(target, prop, value) {
+    var _a;
+    if (_objDefineProperty) {
+        try {
+            _objDefineProperty(target, prop, (_a = {
+                    value: value
+                },
+                _a[_DYN_ENUMERABLE ] = false,
+                _a[_DYN_CONFIGURABLE ] = true,
+                _a));
+            return true;
+        }
+        catch (e) {
+        }
+    }
+    return false;
+}
+function _canAcceptData(target) {
+    return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
+}
+function _getCache(data, target) {
+    var theCache = target[data.id];
+    if (!theCache) {
+        theCache = {};
+        try {
+            if (_canAcceptData(target)) {
+                if (!_createAccessor(target, data.id, theCache)) {
+                    target[data.id] = theCache;
+                }
+            }
+        }
+        catch (e) {
+        }
+    }
+    return theCache;
+}
+function createUniqueNamespace(name, includeVersion) {
+    if (includeVersion === void 0) { includeVersion = false; }
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+}
+function createElmNodeData(name) {
+    var data = {
+        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+        accept: function (target) {
+            return _canAcceptData(target);
+        },
+        get: function (target, name, defValue, addDefault) {
+            var theCache = target[data.id];
+            if (!theCache) {
+                if (addDefault) {
+                    theCache = _getCache(data, target);
+                    theCache[normalizeJsName(name)] = defValue;
+                }
+                return defValue;
+            }
+            return theCache[normalizeJsName(name)];
+        },
+        kill: function (target, name) {
+            if (target && target[name]) {
+                try {
+                    delete target[name];
+                }
+                catch (e) {
+                }
+            }
+        }
+    };
+    return data;
+}
+
+var arrayMethodsToPatch = [
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice"
+];
+function _patchArray(state, target) {
+    if (isArray(target)) {
+        arrForEach(arrayMethodsToPatch, function (method) {
+            var orgMethod = target[method];
+            target[method] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var result = orgMethod[_DYN_APPLY ](this, args);
+                _makeDynamicObject(state, target);
+                return result;
+            };
+        });
+    }
+}
+function _makeDynamicProperty(state, theConfig, name, value) {
+    var detail = {
+        n: name,
+        h: [],
+        add: function (handler) {
+            if (handler && handler.fn && detail.h[_DYN_INDEX_OF ](handler) === -1) {
+                detail.h[_DYN_PUSH$1 ](handler);
+            }
+        }
+    };
+    var checkDynamic = true;
+    function _getProperty() {
+        if (checkDynamic) {
+            if (value && !value[CFG_HANDLER_LINK] && (isPlainObject(value) || isArray(value))) {
+                value = _makeDynamicObject(state, value);
+            }
+            checkDynamic = false;
+        }
+        var activeHandler = state.act;
+        if (activeHandler) {
+            detail.add(activeHandler);
+        }
+        return value;
+    }
+    _getProperty[state.prop] = true;
+    function _setProperty(newValue) {
+        if (value !== newValue) {
+            if (!!_setProperty[state.ro] && state.upd) {
+                throwInvalidAccess("[" + name + "] is sealed from " + dumpObj(theConfig));
+            }
+            if (value && value[CFG_HANDLER_LINK]) {
+                if (isPlainObject(value)) {
+                    objForEachKey$1(value, function (key) {
+                        value[key] = UNDEFINED_VALUE;
+                    });
+                }
+                else if (isArray(value)) {
+                    arrForEach(value, function (propValue, idx) {
+                        value[idx] = UNDEFINED_VALUE;
+                    });
+                }
+            }
+            checkDynamic = false;
+            if (isPlainObject(newValue) || isArray(newValue)) {
+                _makeDynamicObject(state, newValue);
+            }
+            value = newValue;
+            state.add(detail);
+        }
+    }
+    objDefineAccessors(theConfig, detail.n, _getProperty, _setProperty, true);
+}
+function _setDynamicProperty(state, target, name, value) {
+    if (target) {
+        var isDynamic = false;
+        var propDesc = objGetOwnPropertyDescriptor(target, name);
+        if (propDesc && propDesc.get) {
+            isDynamic = !!propDesc.get[state.prop];
+        }
+        if (!isDynamic) {
+            _makeDynamicProperty(state, target, name, value);
+        }
+        else {
+            target[name] = value;
+        }
+    }
+    return value;
+}
+function _makeDynamicObject(state, target ) {
+    var _a;
+    objForEachKey$1( target, function (key, value) {
+        _setDynamicProperty(state, target, key, value);
+    });
+    if (!target[CFG_HANDLER_LINK]) {
+        objDefineProp(target, CFG_HANDLER_LINK, (_a = {},
+            _a[_DYN_CONFIGURABLE ] = false,
+            _a[_DYN_ENUMERABLE ] = false,
+            _a.get = function () {
+                return state.hdlr;
+            },
+            _a));
+        _patchArray(state, target);
+    }
+    return target;
+}
+
+var symPrefix = "[[ai_";
+var symPostfix = "]]";
+function _insertWatcher(watchers, theDetail) {
+    if (theDetail && theDetail.h && theDetail.h[_DYN_LENGTH$1 ] > 0) {
+        arrForEach(theDetail.h, function (handler) {
+            if (handler && handler.fn && watchers[_DYN_INDEX_OF ](handler) === -1) {
+                watchers[_DYN_PUSH$1 ](handler);
+            }
+        });
+    }
+}
+function _createState(cfgHandler) {
+    var _a;
+    var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
+    var _waitingHandlers = null;
+    var _watcherTimer = null;
+    var theState;
+    function _useHandler(activeHandler, callback) {
+        var prevWatcher = theState.act;
+        try {
+            theState.act = activeHandler;
+            callback({
+                cfg: cfgHandler.cfg,
+                hdlr: cfgHandler
+            });
+        }
+        catch (e) {
+            var message = "Watcher [" + dumpObj(callback) + "] failed [" + dumpObj(e) + "]";
+            var logger = cfgHandler[_DYN_LOGGER ];
+            if (logger) {
+                cfgHandler.logger[_DYN_THROW_INTERNAL ](1 , 107 , message);
+            }
+            else {
+                throwInvalidAccess(message);
+            }
+        }
+        finally {
+            theState.act = prevWatcher || null;
+        }
+    }
+    function _notifyWatchers() {
+        if (_waitingHandlers) {
+            var notifyHandlers = _waitingHandlers;
+            _waitingHandlers = null;
+            if (_watcherTimer) {
+                clearTimeout(_watcherTimer);
+                _watcherTimer = null;
+            }
+            arrForEach(notifyHandlers, function (handler) {
+                if (handler.fn) {
+                    _useHandler(handler, handler.fn);
+                }
+            });
+            if (_waitingHandlers) {
+                _notifyWatchers();
+            }
+        }
+    }
+    function _addWatcher(detail) {
+        if (detail && detail.h[_DYN_LENGTH$1 ] > 0) {
+            if (!_waitingHandlers) {
+                _waitingHandlers = [];
+            }
+            if (!_watcherTimer) {
+                _watcherTimer = setTimeout(function () {
+                    _watcherTimer = null;
+                    _notifyWatchers();
+                }, 0);
+            }
+            _insertWatcher(_waitingHandlers, detail);
+        }
+    }
+    theState = (_a = {
+            prop: dynamicPropertySymbol,
+            ro: dynamicPropertyReadOnly,
+            hdlr: cfgHandler,
+            add: _addWatcher
+        },
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.use = _useHandler,
+        _a);
+    return theState;
+}
+
+function _createAndUseHandler(state, configHandler) {
+    var handler = {
+        fn: configHandler,
+        rm: function () {
+            handler.fn = null;
+            state = null;
+            configHandler = null;
+        }
+    };
+    state.use(handler, configHandler);
+    return handler;
+}
+function _createDynamicHandler(logger, target, inPlace) {
+    var _a, _b;
+    var dynamicConfig = getDynamicConfigHandler(target);
+    if (dynamicConfig) {
+        return dynamicConfig;
+    }
+    var uid = createUniqueNamespace("dyncfg", true);
+    var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+    var theState;
+    function _notifyWatchers() {
+        theState[_DYN_NOTIFY ]();
+    }
+    function _setValue(target, name, value) {
+        return _setDynamicProperty(theState, target, name, value);
+    }
+    function _watch(configHandler) {
+        return _createAndUseHandler(theState, configHandler);
+    }
+    function _block(configHandler) {
+        theState.use(null, configHandler);
+    }
+    var cfgHandler = (_a = {
+            uid: null,
+            cfg: newTarget
+        },
+        _a[_DYN_LOGGER ] = logger,
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.set = _setValue,
+        _a[_DYN_WATCH ] = _watch,
+        _a._block = _block,
+        _a);
+    objDefineProp(cfgHandler, "uid", (_b = {},
+        _b[_DYN_CONFIGURABLE ] = false,
+        _b[_DYN_ENUMERABLE ] = false,
+        _b.writable = false,
+        _b.value = uid,
+        _b));
+    theState = _createState(cfgHandler);
+    _makeDynamicObject(theState, newTarget);
+    return cfgHandler;
+}
+function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+    var dynamic = _createDynamicHandler(logger, config || {}, inPlace);
+    if (defaultConfig) {
+        applyDefaults(dynamic.cfg, defaultConfig);
+    }
+    return dynamic;
+}
+
+var _aiNamespace = null;
+function _getExtensionNamespace() {
+    var target = getInst("Microsoft");
+    if (target) {
+        _aiNamespace = target["ApplicationInsights"];
+    }
+    return _aiNamespace;
+}
+function getDebugExt(config) {
+    var ns = _aiNamespace;
+    if (!ns && config.disableDbgExt !== true) {
+        ns = _aiNamespace || _getExtensionNamespace();
+    }
+    return ns ? ns["ChromeDbgExt"] : null;
+}
+
+var _a$1;
 var AiNonUserActionablePrefix = "AI (Internal): ";
 var AiUserActionablePrefix = "AI: ";
 var AIInternalMessagePrefix = "AITR_";
+var defaultValues$1 = (_a$1 = {
+        loggingLevelConsole: 0,
+        loggingLevelTelemetry: 1,
+        maxMessageLimit: 25
+    },
+    _a$1[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = false,
+    _a$1);
 function _sanitizeDiagnosticText(text) {
     if (text) {
         return "\"" + text[_DYN_REPLACE$1 ](/\"/g, STR_EMPTY) + "\"";
@@ -926,8 +1454,8 @@ var DiagnosticLogger = /** @class */ (function () {
             _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
             _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
             _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
-            _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
-            _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
+            _self[_DYN_ENABLE_DEBUG_EXCEPTI5 ] = function () { return _enableDebugExceptions; };
+            _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
                 if (isUserAct === void 0) { isUserAct = false; }
                 var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
                 if (_enableDebugExceptions) {
@@ -1000,10 +1528,14 @@ var DiagnosticLogger = /** @class */ (function () {
                 }
             }
             function _setDefaultsFromConfig(config) {
-                _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
-                _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
-                _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
-                _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
+                var handler = createDynamicConfig(config, defaultValues$1, _self);
+                handler[_DYN_WATCH ](function (details) {
+                    var config = details.cfg;
+                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                    _maxInternalMessageLimit = config.maxMessageLimit;
+                    _enableDebugExceptions = config[_DYN_ENABLE_DEBUG_EXCEPTI5 ];
+                });
             }
             function _areInternalMessagesThrottled() {
                 return _messageCount >= _maxInternalMessageLimit;
@@ -1024,7 +1556,7 @@ function _getLogger(logger) {
 }
 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);
 }
 
 var strExecutionContextKey = "ctx";
@@ -1137,146 +1669,6 @@ function doPerf(mgrSource, getSource, func, details, isAsync) {
     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$1 ] < maxLength) {
-        chars++;
-        result += base64chars.charAt(number & 0x3F);
-        number >>>= 6;
-        if (chars === 5) {
-            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-            chars = 0;
-        }
-    }
-    return result;
-}
-
-var _objDefineProperty = ObjDefineProperty;
-var version = "3.0.0-beta.2210-01";
-var instanceName = "." + newId(6);
-var _dataUid = 0;
-function _createAccessor(target, prop, value) {
-    if (_objDefineProperty) {
-        try {
-            _objDefineProperty(target, prop, {
-                value: value,
-                enumerable: false,
-                configurable: true
-            });
-            return true;
-        }
-        catch (e) {
-        }
-    }
-    return false;
-}
-function _canAcceptData(target) {
-    return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
-}
-function _getCache(data, target) {
-    var theCache = target[data.id];
-    if (!theCache) {
-        theCache = {};
-        try {
-            if (_canAcceptData(target)) {
-                if (!_createAccessor(target, data.id, theCache)) {
-                    target[data.id] = theCache;
-                }
-            }
-        }
-        catch (e) {
-        }
-    }
-    return theCache;
-}
-function createUniqueNamespace(name, includeVersion) {
-    if (includeVersion === void 0) { includeVersion = false; }
-    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
-}
-function createElmNodeData(name) {
-    var data = {
-        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
-        accept: function (target) {
-            return _canAcceptData(target);
-        },
-        get: function (target, name, defValue, addDefault) {
-            var theCache = target[data.id];
-            if (!theCache) {
-                if (addDefault) {
-                    theCache = _getCache(data, target);
-                    theCache[normalizeJsName(name)] = defValue;
-                }
-                return defValue;
-            }
-            return theCache[normalizeJsName(name)];
-        },
-        kill: function (target, name) {
-            if (target && target[name]) {
-                try {
-                    delete target[name];
-                }
-                catch (e) {
-                }
-            }
-        }
-    };
-    return data;
-}
-
 var pluginStateData = createElmNodeData("plugin");
 function _getPluginState(plugin) {
     return pluginStateData.get(plugin, "state", {}, true);
@@ -1295,9 +1687,12 @@ function _getNextProxyStart(proxy, core, startAt) {
     }
     return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
 }
-function _createInternalContext(telemetryChain, config, core, startAt) {
+function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
     var _nextProxy = null;
     var _onComplete = [];
+    if (!dynamicConfig) {
+        dynamicConfig = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
+    }
     if (startAt !== null) {
         _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
     }
@@ -1308,12 +1703,12 @@ function _createInternalContext(telemetryChain, config, core, startAt) {
                 return core;
             },
             diagLog: function () {
-                return safeGetLogger(core, config);
+                return safeGetLogger(core, dynamicConfig.cfg);
             },
             getCfg: function () {
-                return config;
+                return dynamicConfig.cfg;
             },
-            getExtCfg: _getExtCfg,
+            getExtCfg: _resolveExtCfg,
             getConfig: _getConfig,
             hasNext: function () {
                 return !!_nextProxy;
@@ -1360,48 +1755,51 @@ function _createInternalContext(telemetryChain, config, core, startAt) {
         }
         return nextProxy;
     }
-    function _getExtCfg(identifier, defaultValue, mergeDefault) {
-        if (defaultValue === void 0) { defaultValue = {}; }
-        if (mergeDefault === void 0) { mergeDefault = 0 ; }
-        var theConfig;
-        if (config) {
-            var extConfig = config[STR_EXTENSION_CONFIG ];
-            if (extConfig && identifier) {
-                theConfig = extConfig[identifier];
-            }
-        }
-        if (!theConfig) {
-            theConfig = defaultValue;
-        }
-        else if (isObject(defaultValue)) {
-            if (mergeDefault !== 0 ) {
-                var newConfig_1 = objExtend(true, defaultValue, theConfig);
-                if (config && mergeDefault === 2 ) {
-                    objForEachKey(defaultValue, function (field) {
-                        if (isNullOrUndefined(newConfig_1[field])) {
-                            var cfgValue = config[field];
-                            if (!isNullOrUndefined(cfgValue)) {
-                                newConfig_1[field] = cfgValue;
-                            }
-                        }
-                    });
+    function _getExtCfg(identifier, createIfMissing) {
+        var idCfg = null;
+        if (dynamicConfig.cfg && identifier) {
+            var extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+            if (!extCfg && createIfMissing) {
+                dynamicConfig.set(dynamicConfig.cfg, "extensionConfig", {});
+                extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+            }
+            if (extCfg) {
+                idCfg = extCfg[identifier];
+                if (!idCfg && createIfMissing) {
+                    dynamicConfig.set(extCfg, identifier, {});
+                    idCfg = extCfg[identifier];
                 }
-                theConfig = newConfig_1;
             }
         }
-        return theConfig;
+        return idCfg;
+    }
+    function _resolveExtCfg(identifier, defaultValues) {
+        var newConfig = _getExtCfg(identifier, true);
+        if (defaultValues) {
+            objForEachKey(defaultValues, function (field, defaultValue) {
+                if (isNullOrUndefined(newConfig[field])) {
+                    var cfgValue = dynamicConfig.cfg[field];
+                    if (cfgValue || !isNullOrUndefined(cfgValue)) {
+                        newConfig[field] = cfgValue;
+                    }
+                }
+                _applyDefaultValue(newConfig, field, defaultValue);
+            });
+        }
+        return applyDefaults(newConfig, defaultValues);
     }
     function _getConfig(identifier, field, defaultValue) {
         if (defaultValue === void 0) { defaultValue = false; }
         var theValue;
-        var extConfig = _getExtCfg(identifier, null);
-        if (extConfig && !isNullOrUndefined(extConfig[field])) {
+        var extConfig = _getExtCfg(identifier, false);
+        var rootConfig = dynamicConfig.cfg;
+        if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
             theValue = extConfig[field];
         }
-        else if (config && !isNullOrUndefined(config[field])) {
-            theValue = config[field];
+        else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
+            theValue = rootConfig[field];
         }
-        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+        return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
     }
     function _iterateChain(cb) {
         var nextPlugin;
@@ -1414,27 +1812,30 @@ function _createInternalContext(telemetryChain, config, core, startAt) {
     }
     return context;
 }
-function createProcessTelemetryContext(telemetryChain, config, core, startAt) {
+function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
+    var config = createDynamicConfig(cfg);
     var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
     var context = internalContext.ctx;
     function _processNext(env) {
         var nextPlugin = internalContext._next();
-        nextPlugin && nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+        if (nextPlugin) {
+            nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+        }
         return !nextPlugin;
     }
     function _createNew(plugins, startAt) {
         if (plugins === void 0) { plugins = null; }
         if (isArray(plugins)) {
-            plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
         }
-        return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config, core, startAt);
+        return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
     }
     context[_DYN_PROCESS_NEXT ] = _processNext;
     context[_DYN_CREATE_NEW ] = _createNew;
     return context;
 }
 function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-    var config = core[_DYN_CONFIG ] || {};
+    var config = createDynamicConfig(core[_DYN_CONFIG ]);
     var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
     var context = internalContext.ctx;
     function _processNext(unloadState) {
@@ -1445,7 +1846,7 @@ function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
     function _createNew(plugins, startAt) {
         if (plugins === void 0) { plugins = null; }
         if (isArray(plugins)) {
-            plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
         }
         return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
     }
@@ -1454,7 +1855,7 @@ function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
     return context;
 }
 function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-    var config = core[_DYN_CONFIG ] || {};
+    var config = createDynamicConfig(core[_DYN_CONFIG ]);
     var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
     var context = internalContext.ctx;
     function _processNext(updateState) {
@@ -1467,7 +1868,7 @@ function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
     function _createNew(plugins, startAt) {
         if (plugins === void 0) { plugins = null; }
         if (isArray(plugins)) {
-            plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
         }
         return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
     }
@@ -1654,7 +2055,11 @@ function createUnloadHandlerContainer() {
     };
 }
 
+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;
@@ -1690,7 +2095,12 @@ var BaseTelemetryPlugin = /** @class */ (function () {
                         var oldHooks = _hooks;
                         _hooks = [];
                         arrForEach(oldHooks, function (fn) {
-                            fn.rm();
+                            try {
+                                (fn.rm || fn.remove)[_DYN_CALL ](fn);
+                            }
+                            catch (e) {
+                                _throwInternal(theUnloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unloading:" + dumpObj(e));
+                            }
                         });
                         if (result === true) {
                             theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
@@ -1733,12 +2143,7 @@ var BaseTelemetryPlugin = /** @class */ (function () {
             };
             _self._addHook = function (hooks) {
                 if (hooks) {
-                    if (isArray(hooks)) {
-                        _hooks = _hooks.concat(hooks);
-                    }
-                    else {
-                        _hooks[_DYN_PUSH$1 ](hooks);
-                    }
+                    arrAppend(_hooks, hooks);
                 }
             };
             proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
@@ -1779,9 +2184,7 @@ var BaseTelemetryPlugin = /** @class */ (function () {
             return itemCtx;
         }
         function _setDefaults(config, core, pluginChain) {
-            if (config) {
-                setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
-            }
+            createDynamicConfig(config, defaultValues, core[_DYN_LOGGER ]);
             if (!pluginChain && core) {
                 pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
             }
@@ -2955,7 +3358,7 @@ var DebugPlugin = /** @class */ (function (_super) {
                     var defaultConfig = getDefaultConfig();
                     var ctx_1 = _self._getTelCtx();
                     var identifier_1 = _self[_DYN_IDENTIFIER ];
-                    objForEachKey(defaultConfig, function (field, value) {
+                    objForEachKey$1(defaultConfig, function (field, value) {
                         _theConfig[field] = function () { return ctx_1.getConfig(identifier_1, field, value()); };
                     });
                     var foundTrackers_1 = [];
@@ -3170,4 +3573,4 @@ var DebugPlugin = /** @class */ (function (_super) {
 var DebugPlugin$1 = DebugPlugin;
 
 exports.DebugPlugin = DebugPlugin$1;
-//# sourceMappingURL=ai.dbg.3.0.0-beta.2210-01.cjs.js.map
+//# sourceMappingURL=ai.dbg.3.0.0-beta.2210-02.cjs.js.map