@microsoft/applicationinsights-core-js 3.0.0-beta.2210-04 → 3.0.0-beta.2210-07

package/dist/applicationinsights-core-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.0.0-beta.2210-04
+ * Application Insights JavaScript SDK - Core, 3.0.0-beta.2210-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -18,7 +18,8 @@
     var OBJECT = "object";
     var PROTOTYPE = "prototype";
     var STRING = "string";
-    var UNDEFINED = "undefined";
+    var UNDEFINED$1 = "undefined";
+    var CONSTRUCTOR = "constructor";
     var HAS_OWN_PROPERTY = "hasOwnProperty";
     var SYMBOL = "Symbol";
     var POLYFILL_TAG = "_polyfill";
@@ -32,7 +33,6 @@
     var StrProto = StrCls[PROTOTYPE];
     var MathCls = Math;
     var ArrCls = Array;
-    var ArrProto = ArrCls[PROTOTYPE];
 
     function _safeCheck(cb, defValue) {
         var result = defValue;
@@ -44,6 +44,7 @@
         return result;
     }
 
+    var PRIMITIVE_TYPES = [STRING, NUMBER, BOOLEAN, UNDEFINED$1, "symbol", "bigint"];
     function _createIs(theType) {
         return function (value) {
             return typeof value === theType;
@@ -61,7 +62,7 @@
         return typeof value === theType;
     }
     function isUndefined(value) {
-        return typeof value === UNDEFINED || value === UNDEFINED;
+        return typeof value === UNDEFINED$1 || value === UNDEFINED$1;
     }
     function isNullOrUndefined(value) {
         return value === null || isUndefined(value);
@@ -69,10 +70,17 @@
     function isDefined(arg) {
         return !!arg || arg !== UNDEF_VALUE;
     }
+    function isPrimitive(value) {
+        var theType = typeof value;
+        if (value && theType === OBJECT) {
+            return false;
+        }
+        return value === null || PRIMITIVE_TYPES.indexOf(theType) !== -1;
+    }
     var isString = _createIs(STRING);
     var isFunction = _createIs(FUNCTION);
     function isObject(value) {
-        if (isNullOrUndefined(value)) {
+        if (!value && isNullOrUndefined(value)) {
             return false;
         }
         return !!value && typeof value === OBJECT;
@@ -103,16 +111,16 @@
     function getGlobal$1(useCached) {
         var result = useCached === false ? null : _cachedGlobal$1;
         if (!result) {
-            if (!result && typeof globalThis !== UNDEFINED) {
+            if (!result && typeof globalThis !== UNDEFINED$1) {
                 result = globalThis;
             }
-            if (!result && typeof self !== UNDEFINED) {
+            if (!result && typeof self !== UNDEFINED$1) {
                 result = self;
             }
-            if (!result && typeof window !== UNDEFINED) {
+            if (!result && typeof window !== UNDEFINED$1) {
                 result = window;
             }
-            if (!result && typeof global !== UNDEFINED) {
+            if (!result && typeof global !== UNDEFINED$1) {
                 result = global;
             }
             _cachedGlobal$1 = result;
@@ -177,19 +185,6 @@
         }
     }
 
-    function arrForEach(arr, callbackfn, thisArg) {
-        if (arr) {
-            var len = arr[LENGTH];
-            for (var idx = 0; idx < len; idx++) {
-                if (idx in arr) {
-                    if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
     function throwError(message) {
         throw new Error(message);
     }
@@ -207,27 +202,6 @@
         }
         return ObjClass$1.keys(value);
     }
-    function objDeepCopy(source) {
-        if (isArray(source)) {
-            var result_1 = [];
-            arrForEach(source, function (value) {
-                result_1.push(objDeepCopy(value));
-            });
-            return result_1;
-        }
-        if (isObject(source)) {
-            return objCopyProps({}, source);
-        }
-        return source;
-    }
-    function objCopyProps(target, source) {
-        if (!isNullOrUndefined(source)) {
-            objForEachKey$1(source, function (key, value) {
-                target[key] = objDeepCopy(value);
-            });
-        }
-        return target;
-    }
     function objDeepFreeze(value) {
         if (_objFreeze) {
             objForEachKey$1(value, function (key, value) {
@@ -240,6 +214,7 @@
     }
     var objFreeze = _objFreeze || _doNothing;
     var objSeal = ObjClass$1["seal"] || _doNothing;
+    var objGetPrototypeOf = ObjClass$1["getPrototypeOf"] || _doNothing;
 
     function createEnum(values) {
         var theEnum = {};
@@ -305,7 +280,7 @@
     function arrAppend(target, elms) {
         if (!isUndefined(elms) && target) {
             if (isArray(elms)) {
-                ArrProto.push.apply(target, elms);
+                target.push.apply(target, elms);
             }
             else if (isIterator(elms)) {
                 var value = elms.next();
@@ -321,6 +296,19 @@
         return target;
     }
 
+    function arrForEach(arr, callbackfn, thisArg) {
+        if (arr) {
+            var len = arr[LENGTH];
+            for (var idx = 0; idx < len; idx++) {
+                if (idx in arr) {
+                    if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
     function dumpObj(object, format) {
         var objectTypeDump = objToString(object);
         var propertyValueDump = "";
@@ -328,16 +316,21 @@
             propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
         }
         else {
-            if (format) {
-                if (isNumber(format)) {
-                    propertyValueDump = JSON.stringify(object, null, format);
+            try {
+                if (format) {
+                    if (isNumber(format)) {
+                        propertyValueDump = JSON.stringify(object, null, format);
+                    }
+                    else {
+                        propertyValueDump = JSON.stringify(object, null, 4);
+                    }
                 }
                 else {
-                    propertyValueDump = JSON.stringify(object, null, format ? 4 : 0);
+                    propertyValueDump = JSON.stringify(object);
                 }
             }
-            else {
-                propertyValueDump = JSON.stringify(object);
+            catch (e) {
+                propertyValueDump = objToString(object) + " - " + dumpObj(e, format);
             }
         }
         return objectTypeDump + ": " + propertyValueDump;
@@ -403,20 +396,6 @@
         throw new _unsupportedError(message);
     }
 
-    function _doExtend(target, theArgs) {
-        arrForEach(theArgs, function (theArg) {
-            objCopyProps(target, theArg);
-        });
-        return target;
-    }
-    function deepExtend(target) {
-        var theArgs = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            theArgs[_i - 1] = arguments[_i];
-        }
-        return _doExtend(objDeepCopy(target) || {}, theArgs);
-    }
-
     var _objDefineProperty$1 = ObjClass$1["defineProperty"];
     function objDefineProp(target, key, descriptor) {
         if (_objDefineProperty$1) {
@@ -446,6 +425,178 @@
         }
     }
 
+    var _fnToString$1;
+    var _objCtrFnString;
+    var _gblWindow;
+    function isPlainObject$1(value) {
+        if (!value || typeof value !== OBJECT) {
+            return false;
+        }
+        if (!_gblWindow) {
+            _gblWindow = hasWindow() ? getWindow() : true;
+        }
+        var result = false;
+        if (value !== _gblWindow) {
+            if (!_objCtrFnString) {
+                _fnToString$1 = Function[PROTOTYPE].toString;
+                _objCtrFnString = _fnToString$1.call(ObjClass$1);
+            }
+            try {
+                var proto = objGetPrototypeOf(value);
+                result = !proto;
+                if (!result) {
+                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
+                        proto = proto[CONSTRUCTOR];
+                    }
+                    result = proto && typeof proto === FUNCTION && _fnToString$1.call(proto) === _objCtrFnString;
+                }
+            }
+            catch (ex) {
+            }
+        }
+        return result;
+    }
+
+    function _defaultDeepCopyHandler(details) {
+        var target = details.result = {};
+        details.copyTo(target, details.value);
+        return true;
+    }
+    var defaultDeepCopyHandlers = [
+        arrayDeepCopyHandler,
+        plainObjDeepCopyHandler,
+        functionDeepCopyHandler,
+        dateDeepCopyHandler
+    ];
+    function _getSetVisited(visitMap, source, newPath, cb) {
+        var theEntry;
+        arrForEach(visitMap, function (entry) {
+            if (entry.k === source) {
+                theEntry = entry;
+                return -1;
+            }
+        });
+        if (!theEntry) {
+            theEntry = { k: source, v: source };
+            visitMap.push(theEntry);
+            cb(theEntry);
+        }
+        return theEntry.v;
+    }
+    function _deepCopy(visitMap, value, ctx, key) {
+        var userHandler = ctx.handler;
+        var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];
+        var newCtx = {
+            handler: ctx.handler,
+            src: ctx.src,
+            path: newPath
+        };
+        var details = {
+            type: typeof value,
+            isPrim: isPrimitive(value),
+            value: value,
+            result: value,
+            path: newPath,
+            origin: ctx.src,
+            copy: function (source, newKey) {
+                return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
+            },
+            copyTo: function (target, source) {
+                return _copyProps(visitMap, target, source, newCtx);
+            }
+        };
+        if (!details.isPrim) {
+            return _getSetVisited(visitMap, value, newPath, function (newEntry) {
+                objDefineAccessors(details, "result", function () {
+                    return newEntry.v;
+                }, function (newValue) {
+                    newEntry.v = newValue;
+                }, true);
+                var idx = 0;
+                var handler = userHandler;
+                while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler)).call(ctx, details)) {
+                    handler = null;
+                }
+            });
+        }
+        if (userHandler && userHandler.call(ctx, details)) {
+            return details.result;
+        }
+        return value;
+    }
+    function _copyProps(visitMap, target, source, ctx) {
+        if (!isNullOrUndefined(source)) {
+            for (var key in source) {
+                target[key] = _deepCopy(visitMap, source[key], ctx, key);
+            }
+        }
+        return target;
+    }
+    function objCopyProps(target, source, handler) {
+        var ctx = {
+            handler: handler,
+            src: source,
+            path: []
+        };
+        return _copyProps([], target, source, ctx);
+    }
+    function objDeepCopy(source, handler) {
+        var ctx = {
+            handler: handler,
+            src: source
+        };
+        return _deepCopy([], source, ctx);
+    }
+    function arrayDeepCopyHandler(details) {
+        var value = details.value;
+        if (isArray(value)) {
+            var target_1 = details.result = [];
+            target_1.length = value.length;
+            arrForEach(value, function (theValue, idx) {
+                target_1[idx] = details.copy(theValue, idx);
+            });
+            return true;
+        }
+        return false;
+    }
+    function dateDeepCopyHandler(details) {
+        var value = details.value;
+        if (isDate(value)) {
+            details.result = new Date(value.getTime());
+            return true;
+        }
+        return false;
+    }
+    function functionDeepCopyHandler(details) {
+        if (details.type === FUNCTION) {
+            return true;
+        }
+        return false;
+    }
+    function plainObjDeepCopyHandler(details) {
+        var value = details.value;
+        if (isPlainObject$1(value)) {
+            var target = details.result = {};
+            details.copyTo(target, value);
+            return true;
+        }
+        return false;
+    }
+
+    function _doExtend(target, theArgs) {
+        arrForEach(theArgs, function (theArg) {
+            objCopyProps(target, theArg);
+        });
+        return target;
+    }
+    function deepExtend(target) {
+        var theArgs = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            theArgs[_i - 1] = arguments[_i];
+        }
+        return _doExtend(objDeepCopy(target) || {}, theArgs);
+    }
+
     var mathMax = MathCls.max;
 
     var strSlice = _unwrapFunction("slice");
@@ -515,6 +666,31 @@
     var TRIM = "trim";
     var strTrim = StrProto[TRIM] ? _unwrapFunction(TRIM) : polyStrTrim;
 
+    function _extractArgs(args, startAt) {
+        var theArgs = [];
+        for (var lp = startAt; lp < args[LENGTH]; lp++) {
+            theArgs[lp - startAt] = args[lp];
+        }
+        return theArgs;
+    }
+
+    function _scheduleTimeoutWith(self, overrideFn, theArgs) {
+        var timeoutId = overrideFn.apply(self, theArgs);
+        return {
+            cancel: function () {
+                clearTimeout(timeoutId);
+            },
+            refresh: function () {
+                clearTimeout(timeoutId);
+                timeoutId = overrideFn.apply(self, theArgs);
+                return this;
+            }
+        };
+    }
+    function scheduleTimeout(callback, timeout) {
+        return _scheduleTimeoutWith(this, setTimeout, _extractArgs(arguments, 0));
+    }
+
     var createEnumStyle = createEnum;
     var createValueMap = createTypeMap;
 
@@ -540,21 +716,23 @@
     var _cachedGlobal = null;
     function getGlobal(useCached) {
         if (useCached === void 0) { useCached = true; }
-        if (!_cachedGlobal || !useCached) {
-            if (typeof globalThis !== strShimUndefined && globalThis) {
-                _cachedGlobal = globalThis;
+        var result = useCached === false ? null : _cachedGlobal;
+        if (!result) {
+            if (typeof globalThis !== strShimUndefined) {
+                result = globalThis;
             }
-            if (typeof self !== strShimUndefined && self) {
-                _cachedGlobal = self;
+            if (!result && typeof self !== strShimUndefined) {
+                result = self;
             }
-            if (typeof window !== strShimUndefined && window) {
-                _cachedGlobal = window;
+            if (!result && typeof window !== strShimUndefined) {
+                result = window;
             }
-            if (typeof global !== strShimUndefined && global) {
-                _cachedGlobal = global;
+            if (!result && typeof global !== strShimUndefined) {
+                result = global;
             }
+            _cachedGlobal = result;
         }
-        return _cachedGlobal;
+        return result;
     }
     function throwTypeError(message) {
         throw new TypeError(message);
@@ -610,9 +788,11 @@
     }
 
     /*!
-     * Microsoft Dynamic Proto Utility, 1.1.6
+     * Microsoft Dynamic Proto Utility, 1.1.7
      * Copyright (c) Microsoft and contributors. All rights reserved.
      */
+    var _a$4;
+    var UNDEFINED = "undefined";
     var Constructor = 'constructor';
     var Prototype = 'prototype';
     var strFunction = 'function';
@@ -626,13 +806,37 @@
     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 _dynamicNames = 0;
+    function _getGlobal() {
+        var result;
+        if (typeof globalThis !== UNDEFINED) {
+            result = globalThis;
+        }
+        if (!result && typeof self !== UNDEFINED) {
+            result = self;
+        }
+        if (!result && typeof window !== UNDEFINED) {
+            result = window;
+        }
+        if (!result && typeof global !== UNDEFINED) {
+            result = global;
+        }
+        return result || {};
+    }
+    var _gbl = _getGlobal();
+    var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
+        o: (_a$4 = {},
+            _a$4[strSetInstFuncs] = true,
+            _a$4[strUseBaseInst] = true,
+            _a$4),
+        n: 1000
+    });
     function _hasOwnProperty(obj, prop) {
         return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
     }
@@ -826,15 +1030,15 @@
         }
         var classProto = theClass[Prototype];
         if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
+            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
         }
         var className = null;
         if (_hasOwnProperty(classProto, DynClassName)) {
             className = classProto[DynClassName];
         }
         else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _dynamicNames;
-            _dynamicNames++;
+            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+            _gblInst.n++;
             classProto[DynClassName] = className;
         }
         var perfOptions = dynamicProto[DynProtoDefaultOptions];
@@ -851,15 +1055,12 @@
         }
         _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
     }
-    var perfDefaults = {
-        setInstFuncs: true,
-        useBaseInst: true
-    };
-    dynamicProto[DynProtoDefaultOptions] = perfDefaults;
+    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
     var _DYN_LENGTH = "length";
     var _DYN_NOTIFY = "notify";
     var _DYN_THROW_INTERNAL = "throwInternal";
+    var _DYN_SET_DF = "setDf";
     var _DYN_WATCH = "watch";
     var _DYN_LOGGER = "logger";
     var _DYN_CONFIGURABLE = "configurable";
@@ -1156,122 +1357,6 @@
         return extended;
     }
 
-    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
-    function _cfgDeepCopy(source) {
-        if (source) {
-            if (isArray(source)) {
-                var result_1 = [];
-                result_1[_DYN_LENGTH ] = source[_DYN_LENGTH ];
-                arrForEach(source, function (value, idx) {
-                    result_1[idx] = _cfgDeepCopy(value);
-                });
-                return result_1;
-            }
-            if (isPlainObject(source)) {
-                var target_1 = {};
-                objForEachKey$1(source, function (key, value) {
-                    target_1[key] = _cfgDeepCopy(value);
-                });
-                return target_1;
-            }
-        }
-        return source;
-    }
-    function getDynamicConfigHandler(value) {
-        if (value) {
-            var handler = value[CFG_HANDLER_LINK] || value;
-            if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-                return handler;
-            }
-        }
-        return null;
-    }
-    function throwInvalidAccess(message) {
-        throwTypeError$1("InvalidAccess:" + message);
-    }
-
-    function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
-        var defValue;
-        var isDefaultValid = cfgDefaults.dfVal || isDefined;
-        if (theConfig && cfgDefaults.fb) {
-            var fallbacks = cfgDefaults.fb;
-            if (!isArray(fallbacks)) {
-                fallbacks = [fallbacks];
-            }
-            for (var lp = 0; lp < fallbacks[_DYN_LENGTH ]; lp++) {
-                var fallback = fallbacks[lp];
-                var fbValue = theConfig[fallback];
-                if (isDefaultValid(fbValue)) {
-                    defValue = fbValue;
-                }
-                else {
-                    fbValue = dynamicHandler.cfg[fallback];
-                    if (isDefaultValid(fbValue)) {
-                        defValue = fbValue;
-                    }
-                    dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
-                }
-                if (isDefaultValid(defValue)) {
-                    break;
-                }
-            }
-        }
-        if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
-            defValue = cfgDefaults.v;
-        }
-        return defValue;
-    }
-    function _applyDefaultValue(theConfig, name, defaultValue) {
-        var dynamicHandler = theConfig[CFG_HANDLER_LINK];
-        if (!dynamicHandler) {
-            throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
-        }
-        var isValid;
-        var setFn;
-        var defValue;
-        var cfgDefaults = defaultValue;
-        if (cfgDefaults && isObject(cfgDefaults) && (cfgDefaults.isVal || cfgDefaults.set || cfgDefaults.fb || objHasOwn(cfgDefaults, "v"))) {
-            isValid = cfgDefaults.isVal;
-            setFn = cfgDefaults.set;
-            defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
-        }
-        else {
-            defValue = defaultValue;
-        }
-        var theValue = defValue;
-        var usingDefault = true;
-        var cfgValue = theConfig[name];
-        if (cfgValue || !isNullOrUndefined(cfgValue)) {
-            theValue = cfgValue;
-            usingDefault = false;
-        }
-        if (!usingDefault) {
-            if (isValid && theValue !== defValue && !isValid(theValue)) {
-                theValue = defValue;
-                usingDefault = true;
-            }
-            if (setFn) {
-                theValue = setFn(theValue, defValue, theConfig);
-                usingDefault = theValue === defValue;
-            }
-        }
-        if (theValue && usingDefault && (isPlainObject(theValue) || isArray(theValue))) {
-            theValue = _cfgDeepCopy(theValue);
-        }
-        dynamicHandler.set(theConfig, name, theValue);
-    }
-    function applyDefaults(theConfig, defaultValues) {
-        if (defaultValues) {
-            if (theConfig && !theConfig[CFG_HANDLER_LINK] && (isPlainObject(theConfig) || isArray(theConfig))) {
-                throwInvalidAccess(STR_NOT_DYNAMIC_ERROR + dumpObj(theConfig));
-            }
-            objForEachKey(defaultValues, function (name, value) {
-                _applyDefaultValue(theConfig, name, value);
-            });
-        }
-        return theConfig;
-    }
-
     var strDocumentMode = "documentMode";
     var strLocation = "location";
     var strConsole = "console";
@@ -1546,7 +1631,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2210-04";
+    var version = "3.0.0-beta.2210-07";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1619,6 +1704,106 @@
         return data;
     }
 
+    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_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$1(source, function (key, value) {
+                    target_1[key] = _cfgDeepCopy(value);
+                });
+                return target_1;
+            }
+        }
+        return source;
+    }
+    function getDynamicConfigHandler(value) {
+        if (value) {
+            var handler = value[CFG_HANDLER_LINK] || value;
+            if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+                return handler;
+            }
+        }
+        return null;
+    }
+    function throwInvalidAccess(message) {
+        throwTypeError$1("InvalidAccess:" + message);
+    }
+
+    function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+        var defValue;
+        var isDefaultValid = cfgDefaults.dfVal || isDefined;
+        if (theConfig && cfgDefaults.fb) {
+            var fallbacks = cfgDefaults.fb;
+            if (!isArray(fallbacks)) {
+                fallbacks = [fallbacks];
+            }
+            for (var lp = 0; lp < fallbacks[_DYN_LENGTH ]; lp++) {
+                var fallback = fallbacks[lp];
+                var fbValue = theConfig[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                else {
+                    fbValue = dynamicHandler.cfg[fallback];
+                    if (isDefaultValid(fbValue)) {
+                        defValue = fbValue;
+                    }
+                    dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+                }
+                if (isDefaultValid(defValue)) {
+                    break;
+                }
+            }
+        }
+        if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+            defValue = cfgDefaults.v;
+        }
+        return defValue;
+    }
+    function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
+        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);
+    }
+
     var arrayMethodsToPatch = [
         "push",
         "pop",
@@ -1752,7 +1937,8 @@
                 theState.act = activeHandler;
                 callback({
                     cfg: cfgHandler.cfg,
-                    hdlr: cfgHandler
+                    set: cfgHandler.set.bind(cfgHandler),
+                    setDf: cfgHandler[_DYN_SET_DF ].bind(cfgHandler)
                 });
             }
             catch (e) {
@@ -1774,7 +1960,7 @@
                 var notifyHandlers = _waitingHandlers;
                 _waitingHandlers = null;
                 if (_watcherTimer) {
-                    clearTimeout(_watcherTimer);
+                    _watcherTimer.cancel();
                     _watcherTimer = null;
                 }
                 arrForEach(notifyHandlers, function (handler) {
@@ -1793,7 +1979,7 @@
                     _waitingHandlers = [];
                 }
                 if (!_watcherTimer) {
-                    _watcherTimer = setTimeout(function () {
+                    _watcherTimer = scheduleTimeout(function () {
                         _watcherTimer = null;
                         _notifyWatchers();
                     }, 0);
@@ -1827,9 +2013,9 @@
     }
     function _createDynamicHandler(logger, target, inPlace) {
         var _a, _b;
-        var dynamicConfig = getDynamicConfigHandler(target);
-        if (dynamicConfig) {
-            return dynamicConfig;
+        var dynamicHandler = getDynamicConfigHandler(target);
+        if (dynamicHandler) {
+            return dynamicHandler;
         }
         var uid = createUniqueNamespace("dyncfg", true);
         var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
@@ -1846,6 +2032,14 @@
         function _block(configHandler) {
             theState.use(null, configHandler);
         }
+        function _applyDefaults(theConfig, defaultValues) {
+            if (defaultValues) {
+                objForEachKey(defaultValues, function (name, value) {
+                    _applyDefaultValue(cfgHandler, theConfig, name, value);
+                });
+            }
+            return theConfig;
+        }
         var cfgHandler = (_a = {
                 uid: null,
                 cfg: newTarget
@@ -1853,6 +2047,7 @@
             _a[_DYN_LOGGER ] = logger,
             _a[_DYN_NOTIFY ] = _notifyWatchers,
             _a.set = _setValue,
+            _a[_DYN_SET_DF ] = _applyDefaults,
             _a[_DYN_WATCH ] = _watch,
             _a._block = _block,
             _a);
@@ -1876,11 +2071,11 @@
         }
     }
     function createDynamicConfig(config, defaultConfig, logger, inPlace) {
-        var dynamic = _createDynamicHandler(logger, config || {}, inPlace);
+        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
         if (defaultConfig) {
-            applyDefaults(dynamic.cfg, defaultConfig);
+            dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
         }
-        return dynamic;
+        return dynamicHandler;
     }
     function onConfigChange(config, configHandler, logger) {
         var handler = config[CFG_HANDLER_LINK] || config;
@@ -2519,11 +2714,11 @@
         }
         return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
     }
-    function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
+    function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
         var _nextProxy = null;
         var _onComplete = [];
-        if (!dynamicConfig) {
-            dynamicConfig = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
+        if (!dynamicHandler) {
+            dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
         }
         if (startAt !== null) {
             _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
@@ -2535,10 +2730,10 @@
                     return core;
                 },
                 diagLog: function () {
-                    return safeGetLogger(core, dynamicConfig.cfg);
+                    return safeGetLogger(core, dynamicHandler.cfg);
                 },
                 getCfg: function () {
-                    return dynamicConfig.cfg;
+                    return dynamicHandler.cfg;
                 },
                 getExtCfg: _resolveExtCfg,
                 getConfig: _getConfig,
@@ -2589,18 +2784,21 @@
         }
         function _getExtCfg(identifier, createIfMissing) {
             var idCfg = null;
-            if (dynamicConfig.cfg && identifier) {
-                var extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+            var cfg = dynamicHandler.cfg;
+            if (cfg && identifier) {
+                var extCfg = cfg[STR_EXTENSION_CONFIG ];
                 if (!extCfg && createIfMissing) {
-                    dynamicConfig.set(dynamicConfig.cfg, "extensionConfig", {});
-                    extCfg = dynamicConfig.cfg[STR_EXTENSION_CONFIG ];
+                    extCfg = {};
                 }
+                dynamicHandler.set(cfg, "extensionConfig", extCfg);
+                extCfg = cfg[STR_EXTENSION_CONFIG ];
                 if (extCfg) {
                     idCfg = extCfg[identifier];
                     if (!idCfg && createIfMissing) {
-                        dynamicConfig.set(extCfg, identifier, {});
-                        idCfg = extCfg[identifier];
+                        idCfg = {};
                     }
+                    dynamicHandler.set(extCfg, identifier, idCfg);
+                    idCfg = extCfg[identifier];
                 }
             }
             return idCfg;
@@ -2610,21 +2808,21 @@
             if (defaultValues) {
                 objForEachKey(defaultValues, function (field, defaultValue) {
                     if (isNullOrUndefined(newConfig[field])) {
-                        var cfgValue = dynamicConfig.cfg[field];
+                        var cfgValue = dynamicHandler.cfg[field];
                         if (cfgValue || !isNullOrUndefined(cfgValue)) {
                             newConfig[field] = cfgValue;
                         }
                     }
-                    _applyDefaultValue(newConfig, field, defaultValue);
+                    _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
                 });
             }
-            return applyDefaults(newConfig, defaultValues);
+            return dynamicHandler[_DYN_SET_DF ](newConfig, defaultValues);
         }
         function _getConfig(identifier, field, defaultValue) {
             if (defaultValue === void 0) { defaultValue = false; }
             var theValue;
             var extConfig = _getExtCfg(identifier, false);
-            var rootConfig = dynamicConfig.cfg;
+            var rootConfig = dynamicHandler.cfg;
             if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
                 theValue = extConfig[field];
             }
@@ -3150,8 +3348,8 @@
         var _delCookieFn;
         rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
         onConfigChange(rootConfig, function (details) {
-            applyDefaults(details.cfg, rootDefaultConfig);
-            cookieMgrConfig = applyDefaults(details.cfg.cookieCfg, defaultConfig$1);
+            details[_DYN_SET_DF ](details.cfg, rootDefaultConfig);
+            cookieMgrConfig = details[_DYN_SET_DF ](details.cfg.cookieCfg, defaultConfig$1);
             var isEnabled = cookieMgrConfig.enabled;
             if (isNullOrUndefined(isEnabled)) {
                 var cookieEnabled = void 0;
@@ -3726,7 +3924,7 @@
                     _deepMergeConfig(details, target[key], value, merge);
                 }
                 else {
-                    details.hdlr.set(target, key, value);
+                    details.set(target, key, value);
                 }
             });
         }
@@ -4048,11 +4246,11 @@
                         if (!mergeExisting) {
                             objForEachKey(theConfig, function (key) {
                                 if (!objHasOwn(newConfig, key)) {
-                                    details.hdlr.set(theConfig, key, UNDEFINED_VALUE);
+                                    details.set(theConfig, key, UNDEFINED_VALUE);
                                 }
                             });
                         }
-                        applyDefaults(theConfig, defaultConfig);
+                        details[_DYN_SET_DF ](theConfig, defaultConfig);
                         _initExtConfig();
                     });
                     _configHandler[_DYN_NOTIFY ]();
@@ -4856,7 +5054,6 @@
     exports.addPageHideEventListener = addPageHideEventListener;
     exports.addPageShowEventListener = addPageShowEventListener;
     exports.addPageUnloadEventListener = addPageUnloadEventListener;
-    exports.applyDefaults = applyDefaults;
     exports.areCookiesSupported = areCookiesSupported;
     exports.arrForEach = arrForEach;
     exports.arrIndexOf = arrIndexOf;