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

package/browser/ai.dbg.3.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Debug Plugin, 3.0.0-beta.2210-04
+ * Application Insights JavaScript SDK - Debug Plugin, 3.0.0-beta.2210-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -18,21 +18,23 @@ var ObjDefineProperty = ObjClass$1["defineProperty"];
 var _cachedGlobal$1 = null;
 function getGlobal$1(useCached) {
     if (useCached === void 0) { useCached = true; }
-    if (!_cachedGlobal$1 || !useCached) {
-        if (typeof globalThis !== strShimUndefined && globalThis) {
-            _cachedGlobal$1 = globalThis;
+    var result = useCached === false ? null : _cachedGlobal$1;
+    if (!result) {
+        if (typeof globalThis !== strShimUndefined) {
+            result = globalThis;
         }
-        if (typeof self !== strShimUndefined && self) {
-            _cachedGlobal$1 = self;
+        if (!result && typeof self !== strShimUndefined) {
+            result = self;
         }
-        if (typeof window !== strShimUndefined && window) {
-            _cachedGlobal$1 = window;
+        if (!result && typeof window !== strShimUndefined) {
+            result = window;
         }
-        if (typeof global !== strShimUndefined && global) {
-            _cachedGlobal$1 = global;
+        if (!result && typeof global !== strShimUndefined) {
+            result = global;
         }
+        _cachedGlobal$1 = result;
     }
-    return _cachedGlobal$1;
+    return result;
 }
 function throwTypeError$1(message) {
     throw new TypeError(message);
@@ -82,9 +84,11 @@ function __extendsFn(d, b) {
 }
 
 /*!
- * Microsoft Dynamic Proto Utility, 1.1.6
+ * Microsoft Dynamic Proto Utility, 1.1.7
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
+var _a$2;
+var UNDEFINED$1 = "undefined";
 var Constructor = 'constructor';
 var Prototype = 'prototype';
 var strFunction = 'function';
@@ -98,13 +102,37 @@ 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 _dynamicNames = 0;
+function _getGlobal() {
+    var result;
+    if (typeof globalThis !== UNDEFINED$1) {
+        result = globalThis;
+    }
+    if (!result && typeof self !== UNDEFINED$1) {
+        result = self;
+    }
+    if (!result && typeof window !== UNDEFINED$1) {
+        result = window;
+    }
+    if (!result && typeof global !== UNDEFINED$1) {
+        result = global;
+    }
+    return result || {};
+}
+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 _hasOwnProperty(obj, prop) {
     return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
 }
@@ -298,15 +326,15 @@ function dynamicProto(theClass, target, delegateFunc, options) {
     }
     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];
@@ -323,11 +351,7 @@ function dynamicProto(theClass, target, delegateFunc, options) {
     }
     _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
 }
-var perfDefaults = {
-    setInstFuncs: true,
-    useBaseInst: true
-};
-dynamicProto[DynProtoDefaultOptions] = perfDefaults;
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
 var UNDEF_VALUE = undefined;
 var EMPTY = "";
@@ -349,7 +373,6 @@ var ObjClass = Object;
 var ObjProto = ObjClass[PROTOTYPE];
 var StrCls = String;
 var ArrCls = Array;
-var ArrProto = ArrCls[PROTOTYPE];
 
 function _safeCheck(cb, defValue) {
     var result = defValue;
@@ -386,7 +409,7 @@ function isDefined(arg) {
 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;
@@ -465,19 +488,6 @@ function objForEachKey$1(theObject, callbackfn, thisArg) {
     }
 }
 
-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 throwTypeError(message) {
     throw new TypeError(message);
 }
@@ -538,7 +548,7 @@ function isIterator(value) {
 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();
@@ -554,6 +564,19 @@ function arrAppend(target, elms) {
     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 = "";
@@ -561,16 +584,21 @@ function dumpObj(object, format) {
         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;
@@ -665,9 +693,35 @@ var strIndexOf = _unwrapFunction(INDEX_OF);
 
 var asString = StrCls;
 
+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 _DYN_LENGTH$1 = "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";
@@ -719,7 +773,6 @@ 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 strToString = "toString";
 var strGetPrototypeOf = "getPrototypeOf";
@@ -800,122 +853,6 @@ function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
     }
 }
 
-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;
-                }
-                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 strConsole = "console";
 var strJSON = "JSON";
@@ -1044,7 +981,7 @@ function newId(maxLength) {
 }
 
 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) {
@@ -1117,6 +1054,106 @@ function createElmNodeData(name) {
     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$1 ] = source[_DYN_LENGTH$1 ];
+        }
+        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("InvalidAccess:" + message);
+}
+
+function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+    var defValue;
+    var isDefaultValid = cfgDefaults.dfVal || isDefined;
+    if (theConfig && cfgDefaults.fb) {
+        var fallbacks = cfgDefaults.fb;
+        if (!isArray(fallbacks)) {
+            fallbacks = [fallbacks];
+        }
+        for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1 ]; lp++) {
+            var fallback = fallbacks[lp];
+            var fbValue = theConfig[fallback];
+            if (isDefaultValid(fbValue)) {
+                defValue = fbValue;
+            }
+            else {
+                fbValue = dynamicHandler.cfg[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+            }
+            if (isDefaultValid(defValue)) {
+                break;
+            }
+        }
+    }
+    if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+        defValue = cfgDefaults.v;
+    }
+    return defValue;
+}
+function _applyDefaultValue(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",
@@ -1250,7 +1287,8 @@ function _createState(cfgHandler) {
             theState.act = activeHandler;
             callback({
                 cfg: cfgHandler.cfg,
-                hdlr: cfgHandler
+                set: cfgHandler.set.bind(cfgHandler),
+                setDf: cfgHandler[_DYN_SET_DF ].bind(cfgHandler)
             });
         }
         catch (e) {
@@ -1272,7 +1310,7 @@ function _createState(cfgHandler) {
             var notifyHandlers = _waitingHandlers;
             _waitingHandlers = null;
             if (_watcherTimer) {
-                clearTimeout(_watcherTimer);
+                _watcherTimer.cancel();
                 _watcherTimer = null;
             }
             arrForEach(notifyHandlers, function (handler) {
@@ -1291,7 +1329,7 @@ function _createState(cfgHandler) {
                 _waitingHandlers = [];
             }
             if (!_watcherTimer) {
-                _watcherTimer = setTimeout(function () {
+                _watcherTimer = scheduleTimeout(function () {
                     _watcherTimer = null;
                     _notifyWatchers();
                 }, 0);
@@ -1325,9 +1363,9 @@ function _createAndUseHandler(state, configHandler) {
 }
 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);
@@ -1344,6 +1382,14 @@ function _createDynamicHandler(logger, target, inPlace) {
     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
@@ -1351,6 +1397,7 @@ function _createDynamicHandler(logger, target, inPlace) {
         _a[_DYN_LOGGER ] = logger,
         _a[_DYN_NOTIFY ] = _notifyWatchers,
         _a.set = _setValue,
+        _a[_DYN_SET_DF ] = _applyDefaults,
         _a[_DYN_WATCH ] = _watch,
         _a._block = _block,
         _a);
@@ -1365,11 +1412,11 @@ function _createDynamicHandler(logger, target, inPlace) {
     return cfgHandler;
 }
 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;
 }
 
 var _aiNamespace = null;
@@ -1687,11 +1734,11 @@ function _getNextProxyStart(proxy, core, startAt) {
     }
     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;
@@ -1703,10 +1750,10 @@ function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
                 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,
@@ -1757,18 +1804,21 @@ function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
     }
     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;
@@ -1778,21 +1828,21 @@ function _createInternalContext(telemetryChain, dynamicConfig, core, startAt) {
         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];
         }