@microsoft/applicationinsights-perfmarkmeasure-js 3.0.1 → 3.0.2-nightly3.2305-04

package/browser/es5/ai.prfmm-mgr.3.gbl.js

@@ -1,799 +1,819 @@
 /*!
- * Application Insights JavaScript SDK - Performance Mark and Measure Manager plugin, 3.0.1
+ * Application Insights JavaScript SDK - Performance Mark and Measure Manager plugin, 3.0.2-nightly3.2305-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
-this.Microsoft = this.Microsoft || {};
-(function (exports) {
-    'use strict';
+(function (global, factory) {
+    var undef = "undefined";
+    var nsKey, key, nm, theExports = {}, modName = "es5_ai_prfmm_mgr_3_0_2_nightly3_2305_04", msMod="__ms$mod__";
+    var mods={}, modDetail=mods[modName]={}, ver="3.0.2-nightly3.2305-04";
+    var baseNs=global, nsKey="Microsoft", baseNs=baseNs[nsKey]=(baseNs[nsKey]||{});
+    // Versioned namespace "Microsoft.ApplicationInsights3"
+    var exportNs=baseNs, nsKey="ApplicationInsights3", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
+    // Global namespace "Microsoft.ApplicationInsights"
+    var destNs=baseNs, nsKey="ApplicationInsights", destNs=destNs[nsKey]=(destNs[nsKey]||{});
+    var expNsDetail=(exportNs[msMod]=(exportNs[msMod] || {})), expNameVer=(expNsDetail["v"]=(expNsDetail["v"] || []));
+    var destNsDetail=(destNs[msMod]=(destNs[msMod] || {})), destNameVer=(destNsDetail["v"]=(destNsDetail["v"] || []));
+    (destNsDetail["o"]=(destNsDetail["o"] || [])).push(mods);
+    factory(theExports);
+    for(var key in theExports) {
+        // Always set the imported value into the "export" versioned namespace (last-write wins)
+        nm="x", exportNs[key]=theExports[key], expNameVer[key]=ver;
+        // Copy over any named element that is not already present (first-write wins)
+        typeof destNs[key]===undef ? (nm="n", destNs[key]=theExports[key]) && (destNameVer[key]=ver) : !destNameVer[key] && (destNameVer[key]="---");
+        (modDetail[nm] = (modDetail[nm] || [])).push(key);
+    }
+})(this, (function (exports) {
+'use strict';
 
-    var strShimFunction = "function";
-    var strShimPrototype = "prototype";
-    var ObjClass$1 = Object;
 
-    var UNDEF_VALUE = undefined;
-    var EMPTY = "";
-    var FUNCTION = "function";
-    var NUMBER = "number";
-    var OBJECT = "object";
-    var PROTOTYPE = "prototype";
-    var UNDEFINED = "undefined";
-    var VALUE = "value";
-    var ObjClass = Object;
-    var ObjProto = ObjClass[PROTOTYPE];
-    var ArrCls = Array;
+var strShimFunction = "function";
+var strShimPrototype = "prototype";
+var ObjClass$1 = Object;
 
-    function safeGet(cb, defValue) {
-        var result = defValue;
-        try {
-            result = cb();
-        }
-        catch (e) {
-        }
-        return result;
-    }
+var UNDEF_VALUE = undefined;
+var EMPTY = "";
+var FUNCTION = "function";
+var NUMBER = "number";
+var OBJECT = "object";
+var PROTOTYPE = "prototype";
+var UNDEFINED = "undefined";
+var VALUE = "value";
+var ObjClass = Object;
+var ObjProto = ObjClass[PROTOTYPE];
+var ArrCls = Array;
 
-    function _createIs(theType) {
-        return function (value) {
-            return typeof value === theType;
-        };
+function safeGet(cb, defValue) {
+    var result = defValue;
+    try {
+        result = cb();
     }
-    function _createObjIs(theName) {
-        var theType = "[object " + theName + "]";
-        return function (value) {
-            return !!(value && objToString(value) === theType);
-        };
-    }
-    function objToString(value) {
-        return ObjProto.toString.call(value);
-    }
-    function isUndefined(value) {
-        return typeof value === UNDEFINED || value === UNDEFINED;
+    catch (e) {
     }
-    function isNullOrUndefined(value) {
-        return value === null || isUndefined(value);
-    }
-    var isFunction = _createIs(FUNCTION);
-    function isObject(value) {
-        if (!value && isNullOrUndefined(value)) {
-            return false;
-        }
-        return !!value && typeof value === OBJECT;
+    return result;
+}
+
+function _createIs(theType) {
+    return function (value) {
+        return typeof value === theType;
+    };
+}
+function _createObjIs(theName) {
+    var theType = "[object " + theName + "]";
+    return function (value) {
+        return !!(value && objToString(value) === theType);
+    };
+}
+function objToString(value) {
+    return ObjProto.toString.call(value);
+}
+function isUndefined(value) {
+    return typeof value === UNDEFINED || value === UNDEFINED;
+}
+function isNullOrUndefined(value) {
+    return value === null || isUndefined(value);
+}
+var isFunction = _createIs(FUNCTION);
+function isObject(value) {
+    if (!value && isNullOrUndefined(value)) {
+        return false;
     }
-    var isArray = ArrCls.isArray;
-    var isNumber = _createIs(NUMBER);
-    var isError = _createObjIs("Error");
+    return !!value && typeof value === OBJECT;
+}
+var isArray = ArrCls.isArray;
+var isNumber = _createIs(NUMBER);
+var isError = _createObjIs("Error");
 
-    var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
+var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
 
-    function objHasOwnProperty(obj, prop) {
-        return obj && ObjProto.hasOwnProperty.call(obj, prop);
-    }
+function objHasOwnProperty(obj, prop) {
+    return obj && ObjProto.hasOwnProperty.call(obj, prop);
+}
 
-    var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
-    function polyObjHasOwn(obj, prop) {
-        return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
-    }
+var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
+function polyObjHasOwn(obj, prop) {
+    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+}
 
-    function objForEachKey(theObject, callbackfn, thisArg) {
-        if (theObject && isObject(theObject)) {
-            for (var prop in theObject) {
-                if (objHasOwn(theObject, prop)) {
-                    if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
-                        break;
-                    }
+function objForEachKey(theObject, callbackfn, thisArg) {
+    if (theObject && isObject(theObject)) {
+        for (var prop in theObject) {
+            if (objHasOwn(theObject, prop)) {
+                if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                    break;
                 }
             }
         }
     }
+}
 
-    function throwTypeError(message) {
-        throw new TypeError(message);
-    }
+function throwTypeError(message) {
+    throw new TypeError(message);
+}
 
-    var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
-    var _globalCfg;
-    function _getGlobalValue() {
-        var result;
-        if (typeof globalThis !== UNDEFINED) {
-            result = globalThis;
-        }
-        if (!result && typeof self !== UNDEFINED) {
-            result = self;
-        }
-        if (!result && typeof window !== UNDEFINED) {
-            result = window;
+var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+var _globalCfg;
+function _getGlobalValue() {
+    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;
+}
+function _getGlobalConfig() {
+    if (!_globalCfg) {
+        var gbl = _getGlobalValue() || {};
+        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+    }
+    return _globalCfg;
+}
+
+function dumpObj(object, format) {
+    var propertyValueDump = EMPTY;
+    if (isError(object)) {
+        propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+    }
+    else {
+        try {
+            propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
         }
-        if (!result && typeof global !== UNDEFINED) {
-            result = global;
+        catch (e) {
+            propertyValueDump = " - " + dumpObj(e, format);
         }
-        return result;
     }
-    function _getGlobalConfig() {
-        if (!_globalCfg) {
-            var gbl = _getGlobalValue() || {};
-            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+    return objToString(object) + ": " + propertyValueDump;
+}
+
+var propMap = {
+    e: "enumerable",
+    c: "configurable",
+    v: VALUE,
+    w: "writable",
+    g: "get",
+    s: "set"
+};
+function _createProp(value) {
+    var prop = {};
+    prop[propMap["c"]] = true;
+    prop[propMap["e"]] = true;
+    if (value.l) {
+        prop.get = function () { return value.l.v; };
+        var desc = objGetOwnPropertyDescriptor(value.l, "v");
+        if (desc && desc.set) {
+            prop.set = function (newValue) {
+                value.l.v = newValue;
+            };
         }
-        return _globalCfg;
     }
+    objForEachKey(value, function (key, value) {
+        prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+    });
+    return prop;
+}
+var objDefineProp = ObjClass["defineProperty"];
+function objDefine(target, key, propDesc) {
+    return objDefineProp(target, key, _createProp(propDesc));
+}
 
-    function dumpObj(object, format) {
-        var propertyValueDump = EMPTY;
-        if (isError(object)) {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
-        }
-        else {
-            try {
-                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+var _globalLazyTestHooks;
+var _fetchLazyTestHooks = function () {
+    _globalLazyTestHooks = _getGlobalConfig();
+    _fetchLazyTestHooks = null;
+};
+function getLazy(cb) {
+    var lazyValue = {};
+    _fetchLazyTestHooks && _fetchLazyTestHooks();
+    lazyValue.b = _globalLazyTestHooks.lzy;
+    objDefineProp(lazyValue, "v", {
+        configurable: true,
+        get: function () {
+            var result = cb();
+            if (!_globalLazyTestHooks.lzy) {
+                objDefineProp(lazyValue, "v", {
+                    value: result
+                });
+                if (lazyValue.b) {
+                    delete lazyValue.b;
+                }
             }
-            catch (e) {
-                propertyValueDump = " - " + dumpObj(e, format);
+            if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                lazyValue.b = _globalLazyTestHooks.lzy;
             }
+            return result;
         }
-        return objToString(object) + ": " + propertyValueDump;
-    }
+    });
+    return lazyValue;
+}
 
-    var propMap = {
-        e: "enumerable",
-        c: "configurable",
-        v: VALUE,
-        w: "writable",
-        g: "get",
-        s: "set"
-    };
-    function _createProp(value) {
-        var prop = {};
-        prop[propMap["c"]] = true;
-        prop[propMap["e"]] = true;
-        if (value.l) {
-            prop.get = function () { return value.l.v; };
-            var desc = objGetOwnPropertyDescriptor(value.l, "v");
-            if (desc && desc.set) {
-                prop.set = function (newValue) {
-                    value.l.v = newValue;
-                };
-            }
-        }
-        objForEachKey(value, function (key, value) {
-            prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
-        });
-        return prop;
-    }
-    var objDefineProp = ObjClass["defineProperty"];
-    function objDefine(target, key, propDesc) {
-        return objDefineProp(target, key, _createProp(propDesc));
-    }
+function safeGetLazy(cb, defValue) {
+    return getLazy(function () { return safeGet(cb, defValue); });
+}
 
-    var _globalLazyTestHooks;
-    var _fetchLazyTestHooks = function () {
-        _globalLazyTestHooks = _getGlobalConfig();
-        _fetchLazyTestHooks = null;
-    };
-    function getLazy(cb) {
-        var lazyValue = {};
-        _fetchLazyTestHooks && _fetchLazyTestHooks();
-        lazyValue.b = _globalLazyTestHooks.lzy;
-        objDefineProp(lazyValue, "v", {
-            configurable: true,
-            get: function () {
-                var result = cb();
-                if (!_globalLazyTestHooks.lzy) {
-                    objDefineProp(lazyValue, "v", {
-                        value: result
-                    });
-                    if (lazyValue.b) {
-                        delete lazyValue.b;
-                    }
-                }
-                if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
-                    lazyValue.b = _globalLazyTestHooks.lzy;
-                }
-                return result;
-            }
-        });
-        return lazyValue;
-    }
+var WINDOW = "window";
+var _cachedGlobal;
+var _cachedWindow;
+function lazySafeGetInst(name) {
+    return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+}
+function getGlobal(useCached) {
+    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
+    return _cachedGlobal.v;
+}
+function getInst(name, useCached) {
+    var gbl = getGlobal(useCached);
+    if (gbl && gbl[name]) {
+        return gbl[name];
+    }
+    if (name === WINDOW && _cachedWindow) {
+        return _cachedWindow.v;
+    }
+    return null;
+}
 
-    function safeGetLazy(cb, defValue) {
-        return getLazy(function () { return safeGet(cb, defValue); });
-    }
+function utcNow() {
+    return (Date.now || polyUtcNow)();
+}
+function polyUtcNow() {
+    return new Date().getTime();
+}
 
-    var WINDOW = "window";
-    var _cachedGlobal;
-    var _cachedWindow;
-    function lazySafeGetInst(name) {
-        return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
-    }
-    function getGlobal(useCached) {
-        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
-        return _cachedGlobal.v;
-    }
-    function getInst(name, useCached) {
-        var gbl = getGlobal(useCached);
-        if (gbl && gbl[name]) {
-            return gbl[name];
-        }
-        if (name === WINDOW && _cachedWindow) {
-            return _cachedWindow.v;
-        }
-        return null;
-    }
+var _perf;
+function getPerformance() {
+    (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = lazySafeGetInst("performance"));
+    return _perf.v;
+}
 
-    function utcNow() {
-        return (Date.now || polyUtcNow)();
-    }
-    function polyUtcNow() {
-        return new Date().getTime();
-    }
+var _objCreate = ObjClass["create"];
+var objCreate = _objCreate || polyObjCreate;
+function polyObjCreate(obj) {
+    if (!obj) {
+        return {};
+    }
+    var type = typeof obj;
+    if (type !== OBJECT && type !== FUNCTION) {
+        throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+    }
+    function tempFunc() { }
+    tempFunc[PROTOTYPE] = obj;
+    return new tempFunc();
+}
 
-    var _perf;
-    function getPerformance() {
-        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = lazySafeGetInst("performance"));
-        return _perf.v;
-    }
+(getGlobal() || {})["Symbol"];
+(getGlobal() || {})["Reflect"];
+var strHasOwnProperty = "hasOwnProperty";
+var extendStaticsFn = function (d, b) {
+    extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            for (var p in b) {
+                if (b[strHasOwnProperty](p)) {
+                    d[p] = b[p];
+                }
+            }
+        };
+    return extendStaticsFn(d, b);
+};
+function __extendsFn(d, b) {
+    if (typeof b !== strShimFunction && b !== null) {
+        throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
+    }
+    extendStaticsFn(d, b);
+    function __() {
+        this.constructor = d;
+    }
+    d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+}
 
-    var _objCreate = ObjClass["create"];
-    var objCreate = _objCreate || polyObjCreate;
-    function polyObjCreate(obj) {
-        if (!obj) {
-            return {};
+var _a;
+var Constructor = 'constructor';
+var Prototype = 'prototype';
+var strFunction = 'function';
+var DynInstFuncTable = '_dynInstFuncs';
+var DynProxyTag = '_isDynProxy';
+var DynClassName = '_dynClass';
+var DynClassNamePrefix = '_dynCls$';
+var DynInstChkTag = '_dynInstChk';
+var DynAllowInstChkTag = DynInstChkTag;
+var DynProtoDefaultOptions = '_dfOpts';
+var UnknownValue = '_unknown_';
+var str__Proto = "__proto__";
+var DynProtoBaseProto = "_dyn" + str__Proto;
+var DynProtoGlobalSettings = "__dynProto$Gbl";
+var DynProtoCurrent = "_dynInstProto";
+var strUseBaseInst = 'useBaseInst';
+var strSetInstFuncs = 'setInstFuncs';
+var Obj = Object;
+var _objGetPrototypeOf = Obj["getPrototypeOf"];
+var _objGetOwnProps = Obj["getOwnPropertyNames"];
+var _gbl = getGlobal();
+var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
+    o: (_a = {},
+        _a[strSetInstFuncs] = true,
+        _a[strUseBaseInst] = true,
+        _a),
+    n: 1000
+});
+function _isObjectOrArrayPrototype(target) {
+    return target && (target === Obj[Prototype] || target === Array[Prototype]);
+}
+function _isObjectArrayOrFunctionPrototype(target) {
+    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+}
+function _getObjProto(target) {
+    var newProto;
+    if (target) {
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
+        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+        newProto = target[DynProtoBaseProto] || curProto;
+        if (!objHasOwnProperty(target, DynProtoBaseProto)) {
+            delete target[DynProtoCurrent];
+            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+            target[DynProtoCurrent] = curProto;
+        }
+    }
+    return newProto;
+}
+function _forEachProp(target, func) {
+    var props = [];
+    if (_objGetOwnProps) {
+        props = _objGetOwnProps(target);
+    }
+    else {
+        for (var name_1 in target) {
+            if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                props.push(name_1);
+            }
         }
-        var type = typeof obj;
-        if (type !== OBJECT && type !== FUNCTION) {
-            throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+    }
+    if (props && props.length > 0) {
+        for (var lp = 0; lp < props.length; lp++) {
+            func(props[lp]);
         }
-        function tempFunc() { }
-        tempFunc[PROTOTYPE] = obj;
-        return new tempFunc();
     }
-
-    (getGlobal() || {})["Symbol"];
-    (getGlobal() || {})["Reflect"];
-    var strHasOwnProperty = "hasOwnProperty";
-    var extendStaticsFn = function (d, b) {
-        extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
-            ({ __proto__: [] } instanceof Array && function (d, b) {
-                d.__proto__ = b;
-            }) ||
-            function (d, b) {
-                for (var p in b) {
-                    if (b[strHasOwnProperty](p)) {
-                        d[p] = b[p];
-                    }
-                }
-            };
-        return extendStaticsFn(d, b);
-    };
-    function __extendsFn(d, b) {
-        if (typeof b !== strShimFunction && b !== null) {
-            throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
+}
+function _isDynamicCandidate(target, funcName, skipOwn) {
+    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
+}
+function _throwTypeError(message) {
+    throwTypeError("DynamicProto: " + message);
+}
+function _getInstanceFuncs(thisTarget) {
+    var instFuncs = {};
+    _forEachProp(thisTarget, function (name) {
+        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+            instFuncs[name] = thisTarget[name];
         }
-        extendStaticsFn(d, b);
-        function __() {
-            this.constructor = d;
+    });
+    return instFuncs;
+}
+function _hasVisited(values, value) {
+    for (var lp = values.length - 1; lp >= 0; lp--) {
+        if (values[lp] === value) {
+            return true;
+        }
+    }
+    return false;
+}
+function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+    function _instFuncProxy(target, funcHost, funcName) {
+        var theFunc = funcHost[funcName];
+        if (theFunc[DynProxyTag] && useBaseInst) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
+            }
         }
-        d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+        return function () {
+            return theFunc.apply(target, arguments);
+        };
     }
-
-    var _a;
-    var Constructor = 'constructor';
-    var Prototype = 'prototype';
-    var strFunction = 'function';
-    var DynInstFuncTable = '_dynInstFuncs';
-    var DynProxyTag = '_isDynProxy';
-    var DynClassName = '_dynClass';
-    var DynClassNamePrefix = '_dynCls$';
-    var DynInstChkTag = '_dynInstChk';
-    var DynAllowInstChkTag = DynInstChkTag;
-    var DynProtoDefaultOptions = '_dfOpts';
-    var UnknownValue = '_unknown_';
-    var str__Proto = "__proto__";
-    var DynProtoBaseProto = "_dyn" + str__Proto;
-    var DynProtoGlobalSettings = "__dynProto$Gbl";
-    var DynProtoCurrent = "_dynInstProto";
-    var strUseBaseInst = 'useBaseInst';
-    var strSetInstFuncs = 'setInstFuncs';
-    var Obj = Object;
-    var _objGetPrototypeOf = Obj["getPrototypeOf"];
-    var _objGetOwnProps = Obj["getOwnPropertyNames"];
-    var _gbl = getGlobal();
-    var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
-        o: (_a = {},
-            _a[strSetInstFuncs] = true,
-            _a[strUseBaseInst] = true,
-            _a),
-        n: 1000
+    var baseFuncs = {};
+    _forEachProp(instFuncs, function (name) {
+        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
     });
-    function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
-    }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
-    }
-    function _getObjProto(target) {
-        var newProto;
-        if (target) {
-            if (_objGetPrototypeOf) {
-                return _objGetPrototypeOf(target);
+    var baseProto = _getObjProto(classProto);
+    var visited = [];
+    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+        _forEachProp(baseProto, function (name) {
+            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
             }
-            var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
-            newProto = target[DynProtoBaseProto] || curProto;
-            if (!objHasOwnProperty(target, DynProtoBaseProto)) {
-                delete target[DynProtoCurrent];
-                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-                target[DynProtoCurrent] = curProto;
+        });
+        visited.push(baseProto);
+        baseProto = _getObjProto(baseProto);
+    }
+    return baseFuncs;
+}
+function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+    var instFunc = null;
+    if (target && objHasOwnProperty(proto, DynClassName)) {
+        var instFuncTable = target[DynInstFuncTable] || {};
+        instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+        if (!instFunc) {
+            _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        }
+        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+            var canAddInst = !objHasOwnProperty(target, funcName);
+            var objProto = _getObjProto(target);
+            var visited = [];
+            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                var protoFunc = objProto[funcName];
+                if (protoFunc) {
+                    canAddInst = (protoFunc === currentDynProtoProxy);
+                    break;
+                }
+                visited.push(objProto);
+                objProto = _getObjProto(objProto);
             }
-        }
-        return newProto;
-    }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
-        }
-        else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
-                    props.push(name_1);
+            try {
+                if (canAddInst) {
+                    target[funcName] = instFunc;
                 }
+                instFunc[DynInstChkTag] = 1;
             }
-        }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
+            catch (e) {
+                instFuncTable[DynAllowInstChkTag] = false;
             }
         }
     }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
+    return instFunc;
+}
+function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+    var protoFunc = proto[funcName];
+    if (protoFunc === currentDynProtoProxy) {
+        protoFunc = _getObjProto(proto)[funcName];
     }
-    function _throwTypeError(message) {
-        throwTypeError("DynamicProto: " + message);
+    if (typeof protoFunc !== strFunction) {
+        _throwTypeError("[" + funcName + "] is not a " + strFunction);
     }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
+    return protoFunc;
+}
+function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+    function _createDynamicPrototype(proto, funcName) {
+        var dynProtoProxy = function () {
+            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+            return instFunc.apply(this, arguments);
+        };
+        dynProtoProxy[DynProxyTag] = 1;
+        return dynProtoProxy;
+    }
+    if (!_isObjectOrArrayPrototype(proto)) {
+        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+        var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+        if (instFuncTable[DynAllowInstChkTag] !== false) {
+            instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+        }
+        _forEachProp(target, function (name) {
+            if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                instFuncs_1[name] = target[name];
+                delete target[name];
+                if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                    proto[name] = _createDynamicPrototype(proto, name);
+                }
             }
         });
-        return instFuncs;
     }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
+}
+function _checkPrototype(classProto, thisTarget) {
+    if (_objGetPrototypeOf) {
+        var visited = [];
+        var thisProto = _getObjProto(thisTarget);
+        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+            if (thisProto === classProto) {
                 return true;
             }
+            visited.push(thisProto);
+            thisProto = _getObjProto(thisProto);
         }
         return false;
     }
-    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
-        function _instFuncProxy(target, funcHost, funcName) {
-            var theFunc = funcHost[funcName];
-            if (theFunc[DynProxyTag] && useBaseInst) {
-                var instFuncTable = target[DynInstFuncTable] || {};
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
-                }
-            }
-            return function () {
-                return theFunc.apply(target, arguments);
-            };
+    return true;
+}
+function _getObjName(target, unknownValue) {
+    if (objHasOwnProperty(target, Prototype)) {
+        return target.name || unknownValue || UnknownValue;
+    }
+    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+}
+function dynamicProto(theClass, target, delegateFunc, options) {
+    if (!objHasOwnProperty(theClass, Prototype)) {
+        _throwTypeError("theClass is an invalid class definition.");
+    }
+    var classProto = theClass[Prototype];
+    if (!_checkPrototype(classProto, target)) {
+        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+    }
+    var className = null;
+    if (objHasOwnProperty(classProto, DynClassName)) {
+        className = classProto[DynClassName];
+    }
+    else {
+        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+        _gblInst.n++;
+        classProto[DynClassName] = className;
+    }
+    var perfOptions = dynamicProto[DynProtoDefaultOptions];
+    var useBaseInst = !!perfOptions[strUseBaseInst];
+    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+        useBaseInst = !!options[strUseBaseInst];
+    }
+    var instFuncs = _getInstanceFuncs(target);
+    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+    delegateFunc(target, baseFuncs);
+    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+    if (setInstanceFunc && options) {
+        setInstanceFunc = !!options[strSetInstFuncs];
+    }
+    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+}
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+var _DYN_LENGTH = "length";
+var _DYN_PUSH = "push";
+var _DYN_NAME = "name";
+var _DYN_TIME = "time";
+var _DYN_IS_ASYNC = "isAsync";
+var _DYN_IS_CHILD_EVT = "isChildEvt";
+var _DYN_GET_CTX = "getCtx";
+var _DYN_SET_CTX = "setCtx";
+var _DYN_COMPLETE = "complete";
+
+var STR_PERF_EVENT = "perfEvent";
+var STR_GET_PERF_MGR = "getPerfMgr";
+
+function getSetValue(target, field, defValue) {
+    var theValue;
+    if (target) {
+        theValue = target[field];
+        if (!theValue && isNullOrUndefined(theValue)) {
+            theValue = !isUndefined(defValue) ? defValue : {};
+            target[field] = theValue;
         }
-        var baseFuncs = {};
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
-        });
-        var baseProto = _getObjProto(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+    }
+    else {
+        theValue = !isUndefined(defValue) ? defValue : {};
+    }
+    return theValue;
+}
+
+var strExecutionContextKey = "ctx";
+var strParentContextKey = "ParentContextKey";
+var strChildrenContextKey = "ChildrenContextKey";
+var PerfEvent = /** @class */ (function () {
+    function PerfEvent(name, payloadDetails, isAsync) {
+        var _self = this;
+        _self.start = utcNow();
+        _self[_DYN_NAME ] = name;
+        _self[_DYN_IS_ASYNC ] = isAsync;
+        _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
+        if (isFunction(payloadDetails)) {
+            var theDetails_1;
+            objDefine(_self, "payload", {
+                g: function () {
+                    if (!theDetails_1 && isFunction(payloadDetails)) {
+                        theDetails_1 = payloadDetails();
+                        payloadDetails = null;
+                    }
+                    return theDetails_1;
                 }
             });
-            visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
         }
-        return baseFuncs;
-    }
-    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-        var instFunc = null;
-        if (target && objHasOwnProperty(proto, DynClassName)) {
-            var instFuncTable = target[DynInstFuncTable] || {};
-            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
-            if (!instFunc) {
-                _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        _self[_DYN_GET_CTX ] = function (key) {
+            if (key) {
+                if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
+                    return _self[key];
+                }
+                return (_self[strExecutionContextKey] || {})[key];
             }
-            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-                var canAddInst = !objHasOwnProperty(target, funcName);
-                var objProto = _getObjProto(target);
-                var visited = [];
-                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                    var protoFunc = objProto[funcName];
-                    if (protoFunc) {
-                        canAddInst = (protoFunc === currentDynProtoProxy);
-                        break;
+            return null;
+        };
+        _self[_DYN_SET_CTX ] = function (key, value) {
+            if (key) {
+                if (key === PerfEvent[strParentContextKey]) {
+                    if (!_self[key]) {
+                        _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
                     }
-                    visited.push(objProto);
-                    objProto = _getObjProto(objProto);
+                    _self[key] = value;
                 }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
-                    }
-                    instFunc[DynInstChkTag] = 1;
+                else if (key === PerfEvent[strChildrenContextKey]) {
+                    _self[key] = value;
                 }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
+                else {
+                    var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                    ctx[key] = value;
                 }
             }
-        }
-        return instFunc;
-    }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
-        }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
-        }
-        return protoFunc;
-    }
-    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
-        function _createDynamicPrototype(proto, funcName) {
-            var dynProtoProxy = function () {
-                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
-                return instFunc.apply(this, arguments);
-            };
-            dynProtoProxy[DynProxyTag] = 1;
-            return dynProtoProxy;
-        }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
-            }
-            _forEachProp(target, function (name) {
-                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                    instFuncs_1[name] = target[name];
-                    delete target[name];
-                    if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                        proto[name] = _createDynamicPrototype(proto, name);
+        };
+        _self[_DYN_COMPLETE ] = function () {
+            var childTime = 0;
+            var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+            if (isArray(childEvts)) {
+                for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
+                    var childEvt = childEvts[lp];
+                    if (childEvt) {
+                        childTime += childEvt[_DYN_TIME ];
                     }
                 }
-            });
-        }
-    }
-    function _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf) {
-            var visited = [];
-            var thisProto = _getObjProto(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
-                }
-                visited.push(thisProto);
-                thisProto = _getObjProto(thisProto);
             }
-            return false;
-        }
-        return true;
-    }
-    function _getObjName(target, unknownValue) {
-        if (objHasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
-        }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
-    }
-    function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!objHasOwnProperty(theClass, Prototype)) {
-            _throwTypeError("theClass is an invalid class definition.");
-        }
-        var classProto = theClass[Prototype];
-        if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
-        }
-        var className = null;
-        if (objHasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
-        }
-        else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
-            _gblInst.n++;
-            classProto[DynClassName] = className;
-        }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
-        }
-        var instFuncs = _getInstanceFuncs(target);
-        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
-        delegateFunc(target, baseFuncs);
-        var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
-        if (setInstanceFunc && options) {
-            setInstanceFunc = !!options[strSetInstFuncs];
-        }
-        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
-    }
-    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
-
-    var _DYN_LENGTH = "length";
-    var _DYN_PUSH = "push";
-    var _DYN_NAME = "name";
-    var _DYN_TIME = "time";
-    var _DYN_IS_ASYNC = "isAsync";
-    var _DYN_IS_CHILD_EVT = "isChildEvt";
-    var _DYN_GET_CTX = "getCtx";
-    var _DYN_SET_CTX = "setCtx";
-    var _DYN_COMPLETE = "complete";
-
-    var STR_PERF_EVENT = "perfEvent";
-    var STR_GET_PERF_MGR = "getPerfMgr";
-
-    function getSetValue(target, field, defValue) {
-        var theValue;
-        if (target) {
-            theValue = target[field];
-            if (!theValue && isNullOrUndefined(theValue)) {
-                theValue = !isUndefined(defValue) ? defValue : {};
-                target[field] = theValue;
-            }
-        }
-        else {
-            theValue = !isUndefined(defValue) ? defValue : {};
-        }
-        return theValue;
+            _self[_DYN_TIME ] = utcNow() - _self.start;
+            _self.exTime = _self[_DYN_TIME ] - childTime;
+            _self[_DYN_COMPLETE ] = function () { };
+        };
     }
-
-    var strExecutionContextKey = "ctx";
-    var strParentContextKey = "ParentContextKey";
-    var strChildrenContextKey = "ChildrenContextKey";
-    var PerfEvent = /** @class */ (function () {
-        function PerfEvent(name, payloadDetails, isAsync) {
-            var _self = this;
-            _self.start = utcNow();
-            _self[_DYN_NAME ] = name;
-            _self[_DYN_IS_ASYNC ] = isAsync;
-            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
-            if (isFunction(payloadDetails)) {
-                var theDetails_1;
-                objDefine(_self, "payload", {
-                    g: function () {
-                        if (!theDetails_1 && isFunction(payloadDetails)) {
-                            theDetails_1 = payloadDetails();
-                            payloadDetails = null;
-                        }
-                        return theDetails_1;
-                    }
-                });
-            }
-            _self[_DYN_GET_CTX ] = function (key) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
-                        return _self[key];
+    PerfEvent.ParentContextKey = "parent";
+    PerfEvent.ChildrenContextKey = "childEvts";
+    return PerfEvent;
+}());
+var PerfManager = /** @class */ (function () {
+    function PerfManager(manager) {
+        this.ctx = {};
+        dynamicProto(PerfManager, this, function (_self) {
+            _self.create = function (src, payloadDetails, isAsync) {
+                return new PerfEvent(src, payloadDetails, isAsync);
+            };
+            _self.fire = function (perfEvent) {
+                if (perfEvent) {
+                    perfEvent[_DYN_COMPLETE ]();
+                    if (manager && isFunction(manager[STR_PERF_EVENT ])) {
+                        manager[STR_PERF_EVENT ](perfEvent);
                     }
-                    return (_self[strExecutionContextKey] || {})[key];
                 }
-                return null;
             };
             _self[_DYN_SET_CTX ] = function (key, value) {
                 if (key) {
-                    if (key === PerfEvent[strParentContextKey]) {
-                        if (!_self[key]) {
-                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
-                        }
-                        _self[key] = value;
-                    }
-                    else if (key === PerfEvent[strChildrenContextKey]) {
-                        _self[key] = value;
-                    }
-                    else {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
+                    var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                    ctx[key] = value;
                 }
             };
-            _self[_DYN_COMPLETE ] = function () {
-                var childTime = 0;
-                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                if (isArray(childEvts)) {
-                    for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
-                        var childEvt = childEvts[lp];
-                        if (childEvt) {
-                            childTime += childEvt[_DYN_TIME ];
-                        }
-                    }
-                }
-                _self[_DYN_TIME ] = utcNow() - _self.start;
-                _self.exTime = _self[_DYN_TIME ] - childTime;
-                _self[_DYN_COMPLETE ] = function () { };
+            _self[_DYN_GET_CTX ] = function (key) {
+                return (_self[strExecutionContextKey] || {})[key];
             };
-        }
-        PerfEvent.ParentContextKey = "parent";
-        PerfEvent.ChildrenContextKey = "childEvts";
-        return PerfEvent;
-    }());
-    var PerfManager = /** @class */ (function () {
-        function PerfManager(manager) {
-            this.ctx = {};
-            dynamicProto(PerfManager, this, function (_self) {
-                _self.create = function (src, payloadDetails, isAsync) {
-                    return new PerfEvent(src, payloadDetails, isAsync);
-                };
-                _self.fire = function (perfEvent) {
-                    if (perfEvent) {
-                        perfEvent[_DYN_COMPLETE ]();
-                        if (manager && isFunction(manager[STR_PERF_EVENT ])) {
-                            manager[STR_PERF_EVENT ](perfEvent);
-                        }
-                    }
-                };
-                _self[_DYN_SET_CTX ] = function (key, value) {
-                    if (key) {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
-                };
-                _self[_DYN_GET_CTX ] = function (key) {
-                    return (_self[strExecutionContextKey] || {})[key];
-                };
-            });
-        }
-        PerfManager.__ieDyn=1;
-        return PerfManager;
-    }());
-    var doPerfActiveKey = "CoreUtils.doPerf";
-    function doPerf(mgrSource, getSource, func, details, isAsync) {
-        if (mgrSource) {
-            var perfMgr = mgrSource;
-            if (perfMgr[STR_GET_PERF_MGR]) {
-                perfMgr = perfMgr[STR_GET_PERF_MGR]();
-            }
-            if (perfMgr) {
-                var perfEvt = void 0;
-                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
-                try {
-                    perfEvt = perfMgr.create(getSource(), details, isAsync);
-                    if (perfEvt) {
-                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
-                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
-                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
-                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                                if (!children) {
-                                    children = [];
-                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
-                                }
-                                children[_DYN_PUSH ](perfEvt);
+        });
+    }
+    PerfManager.__ieDyn=1;
+    return PerfManager;
+}());
+var doPerfActiveKey = "CoreUtils.doPerf";
+function doPerf(mgrSource, getSource, func, details, isAsync) {
+    if (mgrSource) {
+        var perfMgr = mgrSource;
+        if (perfMgr[STR_GET_PERF_MGR]) {
+            perfMgr = perfMgr[STR_GET_PERF_MGR]();
+        }
+        if (perfMgr) {
+            var perfEvt = void 0;
+            var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
+            try {
+                perfEvt = perfMgr.create(getSource(), details, isAsync);
+                if (perfEvt) {
+                    if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                        if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                            var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                            if (!children) {
+                                children = [];
+                                currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
                             }
+                            children[_DYN_PUSH ](perfEvt);
                         }
-                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
-                        return func(perfEvt);
                     }
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
+                    return func(perfEvt);
                 }
-                catch (ex) {
-                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
-                        perfEvt[_DYN_SET_CTX ]("exception", ex);
-                    }
+            }
+            catch (ex) {
+                if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                    perfEvt[_DYN_SET_CTX ]("exception", ex);
                 }
-                finally {
-                    if (perfEvt) {
-                        perfMgr.fire(perfEvt);
-                    }
-                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
+            }
+            finally {
+                if (perfEvt) {
+                    perfMgr.fire(perfEvt);
                 }
+                perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
             }
         }
-        return func();
     }
+    return func();
+}
 
-    var _DYN_MEASURE = "measure";
+var _DYN_MEASURE = "measure";
 
-    var strCtxMarkName = "prf-mark";
-    var strCtxMarkEndName = "prf-mark-end";
-    var strCtxMeasureName = "prf-measure";
-    var PerfMarkMeasureManager = /** @class */ (function (_super) {
-        __extendsFn(PerfMarkMeasureManager, _super);
-        function PerfMarkMeasureManager(config, manager) {
-            var _this = _super.call(this, manager) || this;
-            var _config = config || {};
-            var _uniqueId = 0;
-            getSetValue(_config, "useMarks", true);
-            getSetValue(_config, "markPrefix", "ai.prfmrk.");
-            getSetValue(_config, "useEndMarks", false);
-            getSetValue(_config, "markEndPrefix", "ai.prfmrk-end.");
-            getSetValue(_config, "useMeasures", true);
-            getSetValue(_config, "measurePrefix", "ai.prfmsr.");
-            dynamicProto(PerfMarkMeasureManager, _this, function (_self, _base) {
-                var _perf = getPerformance();
-                _self.create = function (src, payloadDetails, isAsync) {
-                    var perfEvent = _base.create(src, payloadDetails, isAsync);
-                    if (perfEvent) {
-                        var markName = _getMarkName(perfEvent);
-                        if (markName) {
-                            _perf.mark(markName);
+var strCtxMarkName = "prf-mark";
+var strCtxMarkEndName = "prf-mark-end";
+var strCtxMeasureName = "prf-measure";
+var PerfMarkMeasureManager = /** @class */ (function (_super) {
+    __extendsFn(PerfMarkMeasureManager, _super);
+    function PerfMarkMeasureManager(config, manager) {
+        var _this = _super.call(this, manager) || this;
+        var _config = config || {};
+        var _uniqueId = 0;
+        getSetValue(_config, "useMarks", true);
+        getSetValue(_config, "markPrefix", "ai.prfmrk.");
+        getSetValue(_config, "useEndMarks", false);
+        getSetValue(_config, "markEndPrefix", "ai.prfmrk-end.");
+        getSetValue(_config, "useMeasures", true);
+        getSetValue(_config, "measurePrefix", "ai.prfmsr.");
+        dynamicProto(PerfMarkMeasureManager, _this, function (_self, _base) {
+            var _perf = getPerformance();
+            _self.create = function (src, payloadDetails, isAsync) {
+                var perfEvent = _base.create(src, payloadDetails, isAsync);
+                if (perfEvent) {
+                    var markName = _getMarkName(perfEvent);
+                    if (markName) {
+                        _perf.mark(markName);
+                    }
+                }
+                return perfEvent;
+            };
+            _self.fire = function (perfEvent) {
+                if (perfEvent) {
+                    var mrkEndName = null;
+                    if (_config.useEndMarks === true) {
+                        mrkEndName = perfEvent.getCtx(strCtxMarkEndName);
+                        if (mrkEndName) {
+                            _perf.mark(mrkEndName);
                         }
                     }
-                    return perfEvent;
-                };
-                _self.fire = function (perfEvent) {
-                    if (perfEvent) {
-                        var mrkEndName = null;
-                        if (_config.useEndMarks === true) {
-                            mrkEndName = perfEvent.getCtx(strCtxMarkEndName);
+                    var measureName = perfEvent.getCtx(strCtxMeasureName);
+                    if (measureName) {
+                        var mrkName = perfEvent.getCtx(strCtxMarkName);
+                        if (mrkName) {
                             if (mrkEndName) {
-                                _perf.mark(mrkEndName);
+                                _perf[_DYN_MEASURE ](measureName, mrkName, mrkEndName);
+                            }
+                            else {
+                                _perf[_DYN_MEASURE ](measureName, mrkName);
                             }
                         }
-                        var measureName = perfEvent.getCtx(strCtxMeasureName);
-                        if (measureName) {
-                            var mrkName = perfEvent.getCtx(strCtxMarkName);
-                            if (mrkName) {
-                                if (mrkEndName) {
-                                    _perf[_DYN_MEASURE ](measureName, mrkName, mrkEndName);
-                                }
-                                else {
-                                    _perf[_DYN_MEASURE ](measureName, mrkName);
-                                }
+                        else {
+                            if (mrkEndName) {
+                                _perf[_DYN_MEASURE ](measureName, undefined, mrkEndName);
                             }
                             else {
-                                if (mrkEndName) {
-                                    _perf[_DYN_MEASURE ](measureName, undefined, mrkEndName);
-                                }
-                                else {
-                                    _perf[_DYN_MEASURE ](measureName);
-                                }
+                                _perf[_DYN_MEASURE ](measureName);
                             }
                         }
-                        _base.fire(perfEvent);
-                    }
-                };
-            });
-            function _getMarkName(perfEvent) {
-                var mrkName = null;
-                var postFix = "";
-                if (_config.uniqueNames) {
-                    postFix = _uniqueId + ".";
-                    _uniqueId++;
-                }
-                if (_config.useMarks) {
-                    var mappedName = _getMappedName(_config.markNameMap, perfEvent.name);
-                    if (mappedName) {
-                        mrkName = (_config.markPrefix || "") + postFix + mappedName;
-                        perfEvent.setCtx(strCtxMarkName, mrkName);
-                        if (_config.useEndMarks === true) {
-                            var mrkEndName = (_config.markEndPrefix || "") + postFix + mappedName;
-                            perfEvent.setCtx(strCtxMarkEndName, mrkEndName);
-                        }
                     }
+                    _base.fire(perfEvent);
                 }
-                if (_config.useMeasures) {
-                    var measureName = null;
-                    var mappedName = _getMappedName(_config.measureNameMap || _config.markNameMap, perfEvent.name);
-                    if (mappedName) {
-                        measureName = (_config.measurePrefix || "") + postFix + mappedName;
-                        perfEvent.setCtx(strCtxMeasureName, measureName);
+            };
+        });
+        function _getMarkName(perfEvent) {
+            var mrkName = null;
+            var postFix = "";
+            if (_config.uniqueNames) {
+                postFix = _uniqueId + ".";
+                _uniqueId++;
+            }
+            if (_config.useMarks) {
+                var mappedName = _getMappedName(_config.markNameMap, perfEvent.name);
+                if (mappedName) {
+                    mrkName = (_config.markPrefix || "") + postFix + mappedName;
+                    perfEvent.setCtx(strCtxMarkName, mrkName);
+                    if (_config.useEndMarks === true) {
+                        var mrkEndName = (_config.markEndPrefix || "") + postFix + mappedName;
+                        perfEvent.setCtx(strCtxMarkEndName, mrkEndName);
                     }
                 }
-                return mrkName;
             }
-            function _getMappedName(map, name) {
-                var mappedName = name;
-                if (map) {
-                    mappedName = map[name];
+            if (_config.useMeasures) {
+                var measureName = null;
+                var mappedName = _getMappedName(_config.measureNameMap || _config.markNameMap, perfEvent.name);
+                if (mappedName) {
+                    measureName = (_config.measurePrefix || "") + postFix + mappedName;
+                    perfEvent.setCtx(strCtxMeasureName, measureName);
                 }
-                return mappedName;
             }
-            return _this;
+            return mrkName;
         }
-        PerfMarkMeasureManager.__ieDyn=1;
-        return PerfMarkMeasureManager;
-    }(PerfManager));
+        function _getMappedName(map, name) {
+            var mappedName = name;
+            if (map) {
+                mappedName = map[name];
+            }
+            return mappedName;
+        }
+        return _this;
+    }
+    PerfMarkMeasureManager.__ieDyn=1;
+    return PerfMarkMeasureManager;
+}(PerfManager));
 
-    exports.PerfMarkMeasureManager = PerfMarkMeasureManager;
-    exports.doPerf = doPerf;
+exports.PerfMarkMeasureManager = PerfMarkMeasureManager;
+exports.doPerf = doPerf;
 
-})(this.Microsoft.ApplicationInsights3 = this.Microsoft.ApplicationInsights3 || {});
+}));
 //# sourceMappingURL=ai.prfmm-mgr.3.gbl.js.map