@microsoft/applicationinsights-react-js 19.3.7-nightly.2507-02 → 19.3.7-nightly.2507-04

package/browser/applicationinsights-react-js.js

@@ -1,3863 +0,0 @@
-/*!
- * Application Insights JavaScript SDK - React Plugin, 19.3.7-nightly.2507-02
- * Copyright (c) Microsoft and contributors. All rights reserved.
- */
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Microsoft = global.Microsoft || {}, global.Microsoft.ApplicationInsights = global.Microsoft.ApplicationInsights || {}), global.React));
-})(this, (function (exports, React) { 'use strict';
-
-    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-    function _interopNamespace(e) {
-        if (e && e.__esModule) return e;
-        var n = Object.create(null);
-        if (e) {
-            Object.keys(e).forEach(function (k) {
-                if (k !== 'default') {
-                    var d = Object.getOwnPropertyDescriptor(e, k);
-                    Object.defineProperty(n, k, d.get ? d : {
-                        enumerable: true,
-                        get: function () { return e[k]; }
-                    });
-                }
-            });
-        }
-        n["default"] = e;
-        return n;
-    }
-
-    var React__namespace = /*#__PURE__*/_interopNamespace(React);
-    var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-    var strShimFunction = "function";
-    var strShimObject = "object";
-    var strShimUndefined = "undefined";
-    var strShimPrototype = "prototype";
-    var ObjClass$1 = Object;
-    var ObjProto$1 = ObjClass$1[strShimPrototype];
-
-    /*! https://github.com/nevware21/ts-utils v0.12.5 */
-    function _pureAssign(func1, func2) {
-        return func1 || func2;
-    }
-    function _pureRef(value, name) {
-        return value[name];
-    }
-    var UNDEF_VALUE = undefined;
-    var NULL_VALUE = null;
-    var EMPTY = "";
-    var FUNCTION = "function";
-    var OBJECT = "object";
-    var PROTOTYPE = "prototype";
-    var __PROTO__ = "__proto__";
-    var UNDEFINED = "undefined";
-    var CONSTRUCTOR = "constructor";
-    var SYMBOL = "Symbol";
-    var LENGTH = "length";
-    var NAME = "name";
-    var CALL = "call";
-    var TO_STRING = "toString";
-    var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
-    var GET_OWN_PROPERTY_NAMES = "getOwnPropertyNames";
-    var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
-    var ObjClass = ( _pureAssign(Object));
-    var ObjProto = ( _pureRef(ObjClass, PROTOTYPE));
-    var StrCls = ( _pureAssign(String));
-    var StrProto = ( _pureRef(StrCls, PROTOTYPE));
-    var MathCls = ( _pureAssign(Math));
-    var ArrCls = ( _pureAssign(Array));
-    var ArrProto = ( _pureRef(ArrCls, PROTOTYPE));
-    var ArrSlice = ( _pureRef(ArrProto, "slice"));
-    var NumberCls = ( _pureAssign(Number));
-    var POLYFILL_TAG = "_polyfill";
-    var POLYFILL_TYPE_NAME = "__nw21$polytype__";
-    function safe(func, argArray) {
-        try {
-            return {
-                v: func.apply(this, argArray)
-            };
-        }
-        catch (e) {
-            return { e: e };
-        }
-    }
-    function safeGet(cb, defValue, argArray) {
-        var result = safe(cb, argArray);
-        return result.e ? defValue : result.v;
-    }
-    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[TO_STRING].call(value);
-    }
-    function isUndefined(value) {
-        return typeof value === UNDEFINED || value === UNDEFINED;
-    }
-    function isStrictUndefined(arg) {
-        return arg === UNDEF_VALUE;
-    }
-    function isNullOrUndefined(value) {
-        return value === NULL_VALUE || isUndefined(value);
-    }
-    function isStrictNullOrUndefined(value) {
-        return value === NULL_VALUE || value === UNDEF_VALUE;
-    }
-    function isDefined(arg) {
-        return !!arg || arg !== UNDEF_VALUE;
-    }
-    var isString = ( _createIs("string"));
-    var isFunction = ( _createIs(FUNCTION));
-    function isObject(value) {
-        if (!value && isNullOrUndefined(value)) {
-            return false;
-        }
-        return !!value && typeof value === OBJECT;
-    }
-    var isArray = ( _pureRef(ArrCls, "isArray"));
-    var isNumber = ( _createIs("number"));
-    var isRegExp = ( _createObjIs("RegExp"));
-    var isError = ( _createObjIs("Error"));
-    function isTruthy(value) {
-        return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));
-    }
-    function _returnNothing() {
-        return;
-    }
-    function _returnEmptyArray() {
-        return [];
-    }
-    function _returnFalse() {
-        return false;
-    }
-    var asString = ( _pureAssign(StrCls));
-    var ERROR_TYPE = "[object Error]";
-    function dumpObj(object, format) {
-        var propertyValueDump = EMPTY;
-        var objType = ObjProto[TO_STRING][CALL](object);
-        if (objType === ERROR_TYPE) {
-            object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
-        }
-        try {
-            propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
-            propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
-        }
-        catch (e) {
-            propertyValueDump = " - " + dumpObj(e, format);
-        }
-        return objType + ": " + propertyValueDump;
-    }
-    function throwTypeError(message) {
-        throw new TypeError(message);
-    }
-    function throwRangeError(message) {
-        throw new RangeError(message);
-    }
-    function _throwIfNullOrUndefined(obj) {
-        if (isStrictNullOrUndefined(obj)) {
-            throwTypeError("Cannot convert undefined or null to object");
-        }
-    }
-    function _throwIfNotString(value) {
-        if (!isString(value)) {
-            throwTypeError("'" + dumpObj(value) + "' is not a string");
-        }
-    }
-    function objHasOwnProperty(obj, prop) {
-        return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
-    }
-    var _objGetOwnPropertyDescriptor$2 = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    var objHasOwn = ( _pureAssign(( _pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
-    function polyObjHasOwn(obj, prop) {
-        _throwIfNullOrUndefined(obj);
-        return objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
-    }
-    function objForEachKey(theObject, callbackfn, thisArg) {
-        if (theObject && (isObject(theObject) || isFunction(theObject))) {
-            for (var prop in theObject) {
-                if (objHasOwn(theObject, prop)) {
-                    if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    function arrForEach(theArray, callbackfn, thisArg) {
-        if (theArray) {
-            var len = theArray[LENGTH] >>> 0;
-            for (var idx = 0; idx < len; idx++) {
-                if (idx in theArray) {
-                    if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    var _unwrapFunction = ( _unwrapFunctionWithPoly);
-    function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
-        var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
-        return function (thisArg) {
-            var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
-            if (theFunc || polyFunc) {
-                var theArgs = arguments;
-                return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
-            }
-            throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
-        };
-    }
-    function _objPropertyIsEnum(obj, propKey) {
-        var desc;
-        var fn = ObjClass.getOwnPropertyDescriptor;
-        if (!isStrictNullOrUndefined(obj) && fn) {
-            desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
-        }
-        if (!desc) {
-            desc = safe(function () {
-                for (var key in obj) {
-                    if (key === propKey) {
-                        return { enumerable: true };
-                    }
-                }
-            }).v;
-        }
-        return (desc && desc.enumerable) || false;
-    }
-    ( _unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
-    var _objGetOwnPropertyDescriptor$1 = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
-    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$1(value.l, "v");
-            if (desc && desc.set) {
-                prop.set = function (newValue) {
-                    value.l.v = newValue;
-                };
-            }
-        }
-        objForEachKey(value, function (key, value) {
-            prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;
-        });
-        return prop;
-    }
-    var objDefineProp = ( _pureRef(ObjClass, "defineProperty"));
-    var objDefineProperties = ( _pureRef(ObjClass, "defineProperties"));
-    function objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {
-        var desc = {
-            e: enumerable,
-            c: configurable
-        };
-        if (getProp) {
-            desc.g = getProp;
-        }
-        if (setProp) {
-            desc.s = setProp;
-        }
-        return objDefineProp(target, prop, _createProp(desc));
-    }
-    function objDefine(target, key, propDesc) {
-        return objDefineProp(target, key, _createProp(propDesc));
-    }
-    function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
-        var theMap = {};
-        objForEachKey(values, function (key, value) {
-            _assignMapValue(theMap, key, keyType ? value : key);
-            _assignMapValue(theMap, value, valueType ? value : key);
-        });
-        return completeFn ? completeFn(theMap) : theMap;
-    }
-    function _assignMapValue(theMap, key, value, writable) {
-        objDefineProp(theMap, key, {
-            value: value,
-            enumerable: true,
-            writable: false
-        });
-    }
-    function _objIterateEntries(obj, mapper) {
-        var result = [];
-        objForEachKey(obj, function (key, val) {
-            result.push(mapper(key, val));
-        });
-        return result;
-    }
-    function polyObjEntries(value) {
-        return _objIterateEntries(value, function (k, v) { return [k, v]; });
-    }
-    function polyObjValues(value) {
-        return _objIterateEntries(value, function (_, v) { return v; });
-    }
-    function polyObjIs(value1, value2) {
-        if (value1 !== value1) {
-            return value2 !== value2;
-        }
-        if (value1 === 0 && value2 === 0) {
-            return 1 / value1 === 1 / value2;
-        }
-        return value1 === value2;
-    }
-    var objIsFrozen = ( _pureAssign(( _pureRef(ObjClass, "isFrozen")), _returnFalse));
-    ( _pureAssign(( _pureRef(ObjClass, "isSealed")), _returnFalse));
-    var _objFreeze = ( _pureRef(ObjClass, "freeze"));
-    function _doNothing(value) {
-        return value;
-    }
-    function _getProto(value) {
-        _throwIfNullOrUndefined(value);
-        return value[__PROTO__] || NULL_VALUE;
-    }
-    var objAssign = ( _pureRef(ObjClass, "assign"));
-    var objKeys = ( _pureRef(ObjClass, "keys"));
-    function _deepFreeze(val, visited) {
-        if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
-            for (var lp = 0; lp < visited.length; lp++) {
-                if (visited[lp] === val) {
-                    return val;
-                }
-            }
-            visited.push(val);
-            objForEachKey(val, function (_key, propValue) {
-                _deepFreeze(propValue, visited);
-            });
-            objFreeze(val);
-        }
-        return val;
-    }
-    function objDeepFreeze(value) {
-        return _objFreeze ? _deepFreeze(value, []) : value;
-    }
-    var objFreeze = ( _pureAssign(_objFreeze, _doNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "seal")), _doNothing));
-    var objGetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "getPrototypeOf")), _getProto));
-    ( _pureAssign(( _pureRef(ObjClass, "entries")), polyObjEntries));
-    ( _pureAssign(( _pureRef(ObjClass, "values")), polyObjValues));
-    ( _pureAssign(( _pureRef(ObjClass, "is")), polyObjIs));
-    function createEnum(values) {
-        return _createKeyValueMap(values, 1 , 0 , objFreeze);
-    }
-    function createEnumKeyMap(values) {
-        return _createKeyValueMap(values, 0 , 0 , objFreeze);
-    }
-    var _wellKnownSymbolMap = ( createEnumKeyMap({
-        asyncIterator: 0 ,
-        hasInstance: 1 ,
-        isConcatSpreadable: 2 ,
-        iterator: 3 ,
-        match: 4 ,
-        matchAll: 5 ,
-        replace: 6 ,
-        search: 7 ,
-        species: 8 ,
-        split: 9 ,
-        toPrimitive: 10 ,
-        toStringTag: 11 ,
-        unscopables: 12
-    }));
-    var 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 = safe(_getGlobalValue).v || {};
-            _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
-        }
-        return _globalCfg;
-    }
-    ( _pureRef(MathCls, "min"));
-    var mathMax = ( _pureRef(MathCls, "max"));
-    var strSlice = ( _unwrapFunction("slice", StrProto));
-    var strSubstring = ( _unwrapFunction("substring", StrProto));
-    ( _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
-    function polyStrSubstr(value, start, length) {
-        _throwIfNullOrUndefined(value);
-        if (length < 0) {
-            return EMPTY;
-        }
-        start = start || 0;
-        if (start < 0) {
-            start = mathMax(start + value[LENGTH], 0);
-        }
-        if (isUndefined(length)) {
-            return strSlice(value, start);
-        }
-        return strSlice(value, start, start + length);
-    }
-    function strLeft(value, count) {
-        return strSubstring(value, 0, count);
-    }
-    function _tagAsPolyfill(target, polyfillTypeName) {
-        if (target) {
-            safe(function () {
-                target[POLYFILL_TAG] = true;
-                target[POLYFILL_TYPE_NAME] = polyfillTypeName;
-            });
-            safe(objDefine, [target, POLYFILL_TAG, {
-                    v: true,
-                    w: false,
-                    e: false
-                }]);
-            safe(objDefine, [target, POLYFILL_TYPE_NAME, {
-                    v: polyfillTypeName,
-                    w: false,
-                    e: false
-                }]);
-        }
-        return target;
-    }
-    var objCreate = ( _pureAssign(( _pureRef(ObjClass, "create")), polyObjCreate));
-    function polyObjCreate(obj, properties) {
-        var newObj = null;
-        function tempFunc() { }
-        if (!isStrictNullOrUndefined(obj)) {
-            var type = typeof obj;
-            if (type !== OBJECT && type !== FUNCTION) {
-                throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
-            }
-            tempFunc[PROTOTYPE] = obj;
-            safe(function () {
-                tempFunc[__PROTO__] = obj;
-            });
-            newObj = new tempFunc();
-        }
-        else {
-            newObj = {};
-        }
-        if (properties) {
-            safe(objDefineProperties, [newObj, properties]);
-        }
-        return newObj;
-    }
-    function utcNow() {
-        return (Date.now || polyUtcNow)();
-    }
-    function polyUtcNow() {
-        return new Date().getTime();
-    }
-    function fnApply(fn, thisArg, argArray) {
-        return fn.apply(thisArg, argArray);
-    }
-    var _globalLazyTestHooks;
-    function _initTestHooks() {
-        _globalLazyTestHooks = _getGlobalConfig();
-    }
-    function getLazy(cb, argArray) {
-        var lazyValue = {};
-        !_globalLazyTestHooks && _initTestHooks();
-        lazyValue.b = _globalLazyTestHooks.lzy;
-        objDefineProp(lazyValue, "v", {
-            configurable: true,
-            get: function () {
-                var result = fnApply(cb, null, argArray);
-                if (!_globalLazyTestHooks.lzy) {
-                    objDefineProp(lazyValue, "v", {
-                        value: result
-                    });
-                }
-                lazyValue.b = _globalLazyTestHooks.lzy;
-                return result;
-            }
-        });
-        return lazyValue;
-    }
-    var mathRandom = ( _pureRef(MathCls, "random"));
-    var _uniqueInstanceId = ( getLazy(function () {
-        var value = (utcNow().toString(36).slice(2));
-        while (value.length < 16) {
-            value += mathRandom().toString(36).slice(2);
-        }
-        value = value.substring(0, 16);
-        return value;
-    }));
-    var UNIQUE_REGISTRY_ID = "_urid";
-    var POLY_SYM = "$nw21sym";
-    var _polySymbols;
-    var _polyId = 0;
-    function _globalSymbolRegistry() {
-        if (!_polySymbols) {
-            var gblCfg = _getGlobalConfig();
-            _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
-        }
-        return _polySymbols;
-    }
-    var _wellKnownSymbolCache;
-    function polyNewSymbol(description) {
-        var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
-        var symString = SYMBOL + "(" + description + ")";
-        function _setProp(name, value) {
-            objDefine(theSymbol, name, {
-                v: value,
-                e: false,
-                w: false
-            });
-        }
-        var theSymbol = objCreate(null);
-        _setProp("description", asString(description));
-        _setProp(TO_STRING, function () { return symString + POLY_SYM + uniqueId; });
-        _setProp("valueOf", function () { return theSymbol; });
-        _setProp("v", symString);
-        _setProp("_uid", uniqueId);
-        return _tagAsPolyfill(theSymbol, "symbol");
-    }
-    function polySymbolFor(key) {
-        var registry = _globalSymbolRegistry();
-        if (!objHasOwn(registry.k, key)) {
-            var newSymbol_1 = polyNewSymbol(key);
-            var regId_1 = objKeys(registry.s).length;
-            newSymbol_1[UNIQUE_REGISTRY_ID] = function () { return regId_1 + "_" + newSymbol_1[TO_STRING](); };
-            registry.k[key] = newSymbol_1;
-            registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
-        }
-        return registry.k[key];
-    }
-    function polyGetKnownSymbol(name) {
-        !_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
-        var result;
-        var knownName = _wellKnownSymbolMap[name];
-        if (knownName) {
-            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
-        }
-        return result;
-    }
-    function createCachedValue(value) {
-        return objDefineProp({
-            toJSON: function () { return value; }
-        }, "v", { value: value });
-    }
-    var WINDOW = "window";
-    var _cachedGlobal;
-    function _getGlobalInstFn(getFn, theArgs) {
-        var cachedValue;
-        return function () {
-            !_globalLazyTestHooks && _initTestHooks();
-            if (!cachedValue || _globalLazyTestHooks.lzy) {
-                cachedValue = createCachedValue(safe(getFn, theArgs).v);
-            }
-            return cachedValue.v;
-        };
-    }
-    function getGlobal(useCached) {
-        !_globalLazyTestHooks && _initTestHooks();
-        if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
-            _cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
-        }
-        return _cachedGlobal.v;
-    }
-    function getInst(name, useCached) {
-        var gbl;
-        if (!_cachedGlobal || useCached === false) {
-            gbl = getGlobal(useCached);
-        }
-        else {
-            gbl = _cachedGlobal.v;
-        }
-        if (gbl && gbl[name]) {
-            return gbl[name];
-        }
-        if (name === WINDOW) {
-            try {
-                return window;
-            }
-            catch (e) {
-            }
-        }
-        return NULL_VALUE;
-    }
-    var getDocument = ( _getGlobalInstFn(getInst, ["document"]));
-    function hasWindow() {
-        return !!( getWindow());
-    }
-    var getWindow = ( _getGlobalInstFn(getInst, [WINDOW]));
-    var getNavigator = ( _getGlobalInstFn(getInst, ["navigator"]));
-    var _symbol;
-    var _symbolFor;
-    function _initSymbol() {
-        _symbol = ( createCachedValue(safe((getInst), [SYMBOL]).v));
-        return _symbol;
-    }
-    function _getSymbolKey(key) {
-        var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
-        return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
-    }
-    function getKnownSymbol(name, noPoly) {
-        var knownName = _wellKnownSymbolMap[name];
-        !_globalLazyTestHooks && _initTestHooks();
-        var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
-        return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
-    }
-    function newSymbol(description, noPoly) {
-        !_globalLazyTestHooks && _initTestHooks();
-        var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
-        return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
-    }
-    function symbolFor(key) {
-        !_globalLazyTestHooks && _initTestHooks();
-        _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( createCachedValue(safe((_getSymbolKey), ["for"]).v)));
-        return (_symbolFor.v || polySymbolFor)(key);
-    }
-    function isIterator(value) {
-        return !!value && isFunction(value.next);
-    }
-    function isIterable(value) {
-        return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
-    }
-    var _iterSymbol$1;
-    function iterForOf(iter, callbackfn, thisArg) {
-        if (iter) {
-            if (!isIterator(iter)) {
-                !_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));
-                iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
-            }
-            if (isIterator(iter)) {
-                var err = UNDEF_VALUE;
-                var iterResult = UNDEF_VALUE;
-                try {
-                    var count = 0;
-                    while (!(iterResult = iter.next()).done) {
-                        if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
-                            break;
-                        }
-                        count++;
-                    }
-                }
-                catch (failed) {
-                    err = { e: failed };
-                    if (iter.throw) {
-                        iterResult = NULL_VALUE;
-                        iter.throw(err);
-                    }
-                }
-                finally {
-                    try {
-                        if (iterResult && !iterResult.done) {
-                            iter.return && iter.return(iterResult);
-                        }
-                    }
-                    finally {
-                        if (err) {
-                            throw err.e;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    function arrAppend(target, elms) {
-        if (!isUndefined(elms) && target) {
-            if (isArray(elms)) {
-                fnApply(target.push, target, elms);
-            }
-            else if (isIterator(elms) || isIterable(elms)) {
-                iterForOf(elms, function (elm) {
-                    target.push(elm);
-                });
-            }
-            else {
-                target.push(elms);
-            }
-        }
-        return target;
-    }
-    _unwrapFunction("every", ArrProto);
-    _unwrapFunction("filter", ArrProto);
-    var arrIndexOf = ( _unwrapFunction("indexOf", ArrProto));
-    ( _unwrapFunction("lastIndexOf", ArrProto));
-    var arrMap = ( _unwrapFunction("map", ArrProto));
-    function arrSlice(theArray, start, end) {
-        return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
-    }
-    function polyArrIncludes(theArray, searchElement, fromIndex) {
-        return arrIndexOf(theArray, searchElement, fromIndex) !== -1;
-    }
-    function polyArrFind(theArray, callbackFn, thisArg) {
-        var result;
-        var idx = polyArrFindIndex(theArray, callbackFn, thisArg);
-        return idx !== -1 ? theArray[idx] : result;
-    }
-    function polyArrFindIndex(theArray, callbackFn, thisArg) {
-        var result = -1;
-        arrForEach(theArray, function (value, index) {
-            if (callbackFn[CALL](thisArg | theArray, value, index, theArray)) {
-                result = index;
-                return -1;
-            }
-        });
-        return result;
-    }
-    function polyArrFindLast(theArray, callbackFn, thisArg) {
-        var result;
-        var idx = polyArrFindLastIndex(theArray, callbackFn, thisArg);
-        return idx !== -1 ? theArray[idx] : result;
-    }
-    function polyArrFindLastIndex(theArray, callbackFn, thisArg) {
-        var result = -1;
-        var len = theArray[LENGTH] >>> 0;
-        for (var idx = len - 1; idx >= 0; idx--) {
-            if (idx in theArray && callbackFn[CALL](thisArg | theArray, theArray[idx], idx, theArray)) {
-                result = idx;
-                break;
-            }
-        }
-        return result;
-    }
-    function polyArrFrom(theValue, mapFn, thisArg) {
-        if (isArray(theValue)) {
-            var result_1 = arrSlice(theValue);
-            return mapFn ? arrMap(result_1, mapFn, thisArg) : result_1;
-        }
-        var result = [];
-        iterForOf(theValue, function (value, cnt) {
-            return result.push(mapFn ? mapFn[CALL](thisArg, value, cnt) : value);
-        });
-        return result;
-    }
-    _unwrapFunctionWithPoly("find", ArrProto, polyArrFind);
-    _unwrapFunctionWithPoly("findIndex", ArrProto, polyArrFindIndex);
-    _unwrapFunctionWithPoly("findLast", ArrProto, polyArrFindLast);
-    _unwrapFunctionWithPoly("findLastIndex", ArrProto, polyArrFindLastIndex);
-    ( _pureAssign(( _pureRef(ArrCls, "from")), polyArrFrom));
-    ( _unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
-    ( _unwrapFunction("reduce", ArrProto));
-    ( _unwrapFunction("some", ArrProto));
-    var _isProtoArray;
-    var objSetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "setPrototypeOf")), _polyObjSetPrototypeOf));
-    function _polyObjSetPrototypeOf(obj, proto) {
-        var _a;
-        !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
-        _isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function (key, value) { return obj[key] = value; });
-        return obj;
-    }
-    function _createCustomError(name, d, b) {
-        safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
-        d = objSetPrototypeOf(d, b);
-        function __() {
-            this[CONSTRUCTOR] = d;
-            safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
-        }
-        d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
-        return d;
-    }
-    function _setName(baseClass, name) {
-        name && (baseClass[NAME] = name);
-    }
-    function createCustomError(name, constructCb, errorBase) {
-        var theBaseClass = errorBase || Error;
-        var orgName = theBaseClass[PROTOTYPE][NAME];
-        var captureFn = Error.captureStackTrace;
-        return _createCustomError(name, function () {
-            var _this = this;
-            var theArgs = arguments;
-            try {
-                safe(_setName, [theBaseClass, name]);
-                var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
-                if (_self !== _this) {
-                    var orgProto = objGetPrototypeOf(_this);
-                    if (orgProto !== objGetPrototypeOf(_self)) {
-                        objSetPrototypeOf(_self, orgProto);
-                    }
-                }
-                captureFn && captureFn(_self, _this[CONSTRUCTOR]);
-                constructCb && constructCb(_self, theArgs);
-                return _self;
-            }
-            finally {
-                safe(_setName, [theBaseClass, orgName]);
-            }
-        }, theBaseClass);
-    }
-    function _createTrimFn(exp) {
-        return function _doTrim(value) {
-            _throwIfNullOrUndefined(value);
-            if (value && value.replace) {
-                value = value.replace(exp, EMPTY);
-            }
-            return value;
-        };
-    }
-    var polyStrTrim = ( _createTrimFn(/^\s+|(?=\s)\s+$/g));
-    var polyStrTrimStart = ( _createTrimFn(/^\s+/g));
-    var polyStrTrimEnd = ( _createTrimFn(/(?=\s)\s+$/g));
-    var strTrim = ( _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim));
-    ( _unwrapFunctionWithPoly("trimStart", StrProto, polyStrTrimStart));
-    ( _unwrapFunctionWithPoly("trimEnd", StrProto, polyStrTrimEnd));
-    ( _unwrapFunction("toUpperCase", StrProto));
-    ( _unwrapFunction("toLowerCase", StrProto));
-    var mathFloor = ( _pureRef(MathCls, "floor"));
-    var mathCeil = ( _pureRef(MathCls, "ceil"));
-    var mathTrunc = ( _pureAssign(( _pureRef(MathCls, "trunc")), polyMathTrunc));
-    function polyMathTrunc(value) {
-        var theValue = +value;
-        return (theValue > 0 ? mathFloor : mathCeil)(theValue);
-    }
-    function mathToInt(value, throwInfinity) {
-        var result = +value;
-        if (throwInfinity && (result === Infinity || result == Infinity)) {
-            throwRangeError("invalid value [" + dumpObj(value) + "]");
-        }
-        return result !== result || result === 0 ? 0 : mathTrunc(result);
-    }
-    var strRepeat = ( _unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
-    function polyStrRepeat(value, count) {
-        _throwIfNullOrUndefined(value);
-        count = mathToInt(count, true);
-        if (count < 0) {
-            throwRangeError("invalid count must be >= 0 && < Infinity");
-        }
-        var pad = isString(value) ? value : asString(value);
-        var result = EMPTY;
-        for (; count > 0; (count >>>= 1) && (pad += pad)) {
-            if (count & 1) {
-                result += pad;
-            }
-        }
-        return result;
-    }
-    function _padValue(value, targetLength, padString) {
-        var result = EMPTY;
-        targetLength = mathToInt(targetLength, true);
-        targetLength >>= 0;
-        var len = value[LENGTH];
-        if (len < targetLength) {
-            result = isNullOrUndefined(padString) ? " " : asString(padString);
-            targetLength = targetLength - len;
-            if (targetLength > result[LENGTH]) {
-                result = strRepeat(result, mathCeil(targetLength / result[LENGTH]));
-            }
-            if (result[LENGTH] > targetLength) {
-                result = strSubstring(result, 0, targetLength);
-            }
-        }
-        return result;
-    }
-    ( _unwrapFunctionWithPoly("padStart", StrProto, polyStrPadStart));
-    ( _unwrapFunctionWithPoly("padEnd", StrProto, polyStrPadEnd));
-    function polyStrPadStart(value, targetLength, padString) {
-        return _padValue(value, targetLength, padString) + value;
-    }
-    function polyStrPadEnd(value, targetLength, padString) {
-        return value + _padValue(value, targetLength, padString);
-    }
-    var _fnToString;
-    var _objCtrFnString;
-    var _gblWindow;
-    function isPlainObject(value) {
-        if (!value || typeof value !== OBJECT) {
-            return false;
-        }
-        if (!_gblWindow) {
-            _gblWindow = hasWindow() ? getWindow() : true;
-        }
-        var result = false;
-        if (value !== _gblWindow) {
-            if (!_objCtrFnString) {
-                _fnToString = Function[PROTOTYPE][TO_STRING];
-                _objCtrFnString = _fnToString[CALL](ObjClass);
-            }
-            try {
-                var proto = objGetPrototypeOf(value);
-                result = !proto;
-                if (!result) {
-                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
-                        proto = proto[CONSTRUCTOR];
-                    }
-                    result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
-                }
-            }
-            catch (ex) {
-            }
-        }
-        return result;
-    }
-    function polyStrSymSplit(value, splitter, limit) {
-        var splitFn = splitter ? splitter[getKnownSymbol(9 )] : UNDEF_VALUE;
-        return splitFn ? splitFn(value, limit) : [value];
-    }
-    ( _unwrapFunction("split", StrProto));
-    ( _unwrapFunctionWithPoly("split", StrProto, polyStrSymSplit));
-    ( _pureAssign(( _pureRef(NumberCls, "isInteger")), _polyNumberIsInteger));
-    function _polyNumberIsInteger(value) {
-        return isNumber(value) && !isNaN(value) &&
-            isFinite(value) &&
-            mathFloor(value) === value;
-    }
-    ( _pureRef(MathCls, "abs"));
-    ( _pureRef(MathCls, "exp"));
-    ( _pureRef(MathCls, "log"));
-    ( _pureRef(MathCls, "asin"));
-    ( _pureRef(MathCls, "acos"));
-    ( _pureRef(MathCls, "atan"));
-    ( _pureRef(MathCls, "atan2"));
-    ( _pureRef(MathCls, "pow"));
-    ( _pureRef(MathCls, "sqrt"));
-    ( _pureRef(MathCls, "round"));
-    ( _pureRef(MathCls, "sin"));
-    ( _pureRef(MathCls, "cos"));
-    ( _pureRef(MathCls, "tan"));
-    var _recursionCheckOwnDescriptors;
-    var _recursionCheckOwnSymbols;
-    var _objGetOwnPropertyNames = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
-    var _objGetOwnPropertyDescriptor = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    function polyObjGetOwnPropertyDescriptors(obj) {
-        var result = {};
-        _throwIfNullOrUndefined(obj);
-        if (!_recursionCheckOwnDescriptors) {
-            try {
-                _recursionCheckOwnDescriptors = true;
-                arrForEach(_objGetOwnPropertyNames(obj), function (propName) {
-                    var descriptor = _objGetOwnPropertyDescriptor(obj, propName);
-                    if (descriptor !== undefined) {
-                        result[propName] = descriptor;
-                    }
-                });
-                arrForEach(_polyObjGetOwnPropertySymbols(obj), function (sym) {
-                    var descriptor = _objGetOwnPropertyDescriptor(obj, sym);
-                    if (descriptor !== undefined) {
-                        result[sym] = descriptor;
-                    }
-                });
-            }
-            finally {
-                _recursionCheckOwnDescriptors = false;
-            }
-        }
-        return result;
-    }
-    function _polyObjGetOwnPropertySymbols(obj) {
-        var result = [];
-        var objHasOwn = ObjClass.hasOwn || polyObjHasOwn;
-        if (!_recursionCheckOwnSymbols) {
-            try {
-                _recursionCheckOwnSymbols = true;
-                var symEnum = 0 ;
-                while (symEnum <= 12 ) {
-                    var sym = getKnownSymbol(symEnum);
-                    if (sym && objHasOwn(obj, sym)) {
-                        result.push(sym);
-                    }
-                    symEnum++;
-                }
-            }
-            finally {
-                _recursionCheckOwnSymbols = false;
-            }
-        }
-        return result;
-    }
-    var objGetOwnPropertyDescriptor = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertyDescriptors")), polyObjGetOwnPropertyDescriptors));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
-    function polyObjFromEntries(entries) {
-        var result = {};
-        function addEntry(entry) {
-            if (isArray(entry) && entry.length >= 2) {
-                result[entry[0]] = entry[1];
-            }
-        }
-        if (isArray(entries)) {
-            arrForEach(entries, addEntry);
-        }
-        else if (isIterable(entries)) {
-            iterForOf(entries, addEntry);
-        }
-        return result;
-    }
-    ( _pureAssign(( _pureRef(ObjClass, "fromEntries")), polyObjFromEntries));
-    ( _pureAssign(( _pureRef(ObjClass, "preventExtensions")), _doNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "isExtensible")), _returnFalse));
-    var strEndsWith = ( _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
-    function polyStrEndsWith(value, searchString, length) {
-        _throwIfNotString(value);
-        var searchValue = isString(searchString) ? searchString : asString(searchString);
-        var end = (!isUndefined(length) && length < value[LENGTH]) ? length : value[LENGTH];
-        return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
-    }
-    var strIndexOf = ( _unwrapFunction("indexOf", StrProto));
-    ( _unwrapFunction("lastIndexOf", StrProto));
-    ( _unwrapFunctionWithPoly("includes", StrProto, polyStrIncludes));
-    function polyStrIncludes(value, searchString, position) {
-        if (isRegExp(searchString)) {
-            throwTypeError("'searchString' must not be a regular expression" + dumpObj(searchString));
-        }
-        return strIndexOf(value, asString(searchString), position) !== -1;
-    }
-    ( _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith));
-    function polyStrStartsWith(value, searchString, position) {
-        _throwIfNotString(value);
-        var searchValue = isString(searchString) ? searchString : asString(searchString);
-        var pos = position > 0 ? position : 0;
-        return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
-    }
-    var REF = "ref";
-    var UNREF = "unref";
-    var HAS_REF = "hasRef";
-    var ENABLED = "enabled";
-    function _createTimerHandler(startTimer, refreshFn, cancelFn) {
-        var ref = true;
-        var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
-        var theTimerHandler;
-        function _unref() {
-            ref = false;
-            timerId && timerId[UNREF] && timerId[UNREF]();
-            return theTimerHandler;
-        }
-        function _cancel() {
-            timerId && cancelFn(timerId);
-            timerId = NULL_VALUE;
-        }
-        function _refresh() {
-            timerId = refreshFn(timerId);
-            if (!ref) {
-                _unref();
-            }
-            return theTimerHandler;
-        }
-        function _setEnabled(value) {
-            !value && timerId && _cancel();
-            value && !timerId && _refresh();
-        }
-        theTimerHandler = {
-            cancel: _cancel,
-            refresh: _refresh
-        };
-        theTimerHandler[HAS_REF] = function () {
-            if (timerId && timerId[HAS_REF]) {
-                return timerId[HAS_REF]();
-            }
-            return ref;
-        };
-        theTimerHandler[REF] = function () {
-            ref = true;
-            timerId && timerId[REF] && timerId[REF]();
-            return theTimerHandler;
-        };
-        theTimerHandler[UNREF] = _unref;
-        theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
-            get: function () { return !!timerId; },
-            set: _setEnabled
-        });
-        return {
-            h: theTimerHandler,
-            dn: function () {
-                timerId = NULL_VALUE;
-            }
-        };
-    }
-    var _setTimeoutFn;
-    var _clearTimeoutFn;
-    function _resolveTimeoutFn(timeoutFn) {
-        var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
-        if (!result) {
-            var globalOverrides = _getGlobalConfig().tmOut || [];
-            if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
-                result = globalOverrides[0];
-            }
-        }
-        return result || setTimeout;
-    }
-    function _resolveClearTimeoutFn(timeoutFn) {
-        var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
-        if (!result) {
-            var globalOverrides = _getGlobalConfig().tmOut || [];
-            if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
-                result = globalOverrides[1];
-            }
-        }
-        return result || clearTimeout;
-    }
-    function _createTimeoutWith(startTimer, overrideFn, theArgs) {
-        var isArr = isArray(overrideFn);
-        var len = isArr ? overrideFn.length : 0;
-        var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE));
-        var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
-        var timerFn = theArgs[0];
-        theArgs[0] = function () {
-            handler.dn();
-            fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
-        };
-        var handler = _createTimerHandler(startTimer, function (timerId) {
-            if (timerId) {
-                if (timerId.refresh) {
-                    timerId.refresh();
-                    return timerId;
-                }
-                fnApply(clearFn, UNDEF_VALUE, [timerId]);
-            }
-            return fnApply(setFn, UNDEF_VALUE, theArgs);
-        }, function (timerId) {
-            fnApply(clearFn, UNDEF_VALUE, [timerId]);
-        });
-        return handler.h;
-    }
-    function scheduleTimeout(callback, timeout) {
-        return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
-    }
-
-    (getGlobal() || {})["Symbol"];
-    (getGlobal() || {})["Reflect"];
-    var strHasOwnProperty = "hasOwnProperty";
-    var __objAssignFnImpl = function (t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) {
-                if (ObjProto$1[strHasOwnProperty].call(s, p)) {
-                    t[p] = s[p];
-                }
-            }
-        }
-        return t;
-    };
-    var __assignFn = objAssign || __objAssignFnImpl;
-    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 _a$3;
-    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$3 = {},
-            _a$3[strSetInstFuncs] = true,
-            _a$3[strUseBaseInst] = true,
-            _a$3),
-        n: 1000
-    });
-    function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
-    }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
-    }
-    function _getObjProto(target) {
-        var newProto;
-        if (target) {
-            if (_objGetPrototypeOf) {
-                return _objGetPrototypeOf(target);
-            }
-            var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
-            newProto = target[DynProtoBaseProto] || curProto;
-            if (!objHasOwnProperty(target, DynProtoBaseProto)) {
-                delete target[DynProtoCurrent];
-                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-                target[DynProtoCurrent] = curProto;
-            }
-        }
-        return newProto;
-    }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
-        }
-        else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
-                    props.push(name_1);
-                }
-            }
-        }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
-            }
-        }
-    }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype);
-    }
-    function _throwTypeError(message) {
-        throwTypeError("DynamicProto: " + message);
-    }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = objCreate(null);
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
-            }
-        });
-        return instFuncs;
-    }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
-        function _instFuncProxy(target, funcHost, funcName) {
-            var theFunc = funcHost[funcName];
-            if (theFunc[DynProxyTag] && useBaseInst) {
-                var instFuncTable = target[DynInstFuncTable] || {};
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
-                }
-            }
-            return function () {
-                return theFunc.apply(target, arguments);
-            };
-        }
-        var baseFuncs = objCreate(null);
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
-        });
-        var baseProto = _getObjProto(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
-                }
-            });
-            visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
-        }
-        return baseFuncs;
-    }
-    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-        var instFunc = null;
-        if (target && objHasOwnProperty(proto, DynClassName)) {
-            var instFuncTable = target[DynInstFuncTable] || objCreate(null);
-            instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
-            if (!instFunc) {
-                _throwTypeError("Missing [" + funcName + "] " + strFunction);
-            }
-            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-                var canAddInst = !objHasOwnProperty(target, funcName);
-                var objProto = _getObjProto(target);
-                var visited = [];
-                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                    var protoFunc = objProto[funcName];
-                    if (protoFunc) {
-                        canAddInst = (protoFunc === currentDynProtoProxy);
-                        break;
-                    }
-                    visited.push(objProto);
-                    objProto = _getObjProto(objProto);
-                }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
-                    }
-                    instFunc[DynInstChkTag] = 1;
-                }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
-                }
-            }
-        }
-        return instFunc;
-    }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
-        }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
-        }
-        return protoFunc;
-    }
-    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
-        function _createDynamicPrototype(proto, funcName) {
-            var dynProtoProxy = function () {
-                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
-                return instFunc.apply(this, arguments);
-            };
-            dynProtoProxy[DynProxyTag] = 1;
-            return dynProtoProxy;
-        }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
-            if (!_isObjectOrArrayPrototype(instFuncTable)) {
-                var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || objCreate(null));
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
-                }
-                if (!_isObjectOrArrayPrototype(instFuncs_1)) {
-                    _forEachProp(target, function (name) {
-                        if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                            instFuncs_1[name] = target[name];
-                            delete target[name];
-                            if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                                proto[name] = _createDynamicPrototype(proto, name);
-                            }
-                        }
-                    });
-                }
-            }
-        }
-    }
-    function _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf) {
-            var visited = [];
-            var thisProto = _getObjProto(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
-                }
-                visited.push(thisProto);
-                thisProto = _getObjProto(thisProto);
-            }
-            return false;
-        }
-        return true;
-    }
-    function _getObjName(target, unknownValue) {
-        if (objHasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
-        }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
-    }
-    function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!objHasOwnProperty(theClass, Prototype)) {
-            _throwTypeError("theClass is an invalid class definition.");
-        }
-        var classProto = theClass[Prototype];
-        if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
-        }
-        var className = null;
-        if (objHasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
-        }
-        else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
-            _gblInst.n++;
-            classProto[DynClassName] = className;
-        }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
-        }
-        var instFuncs = _getInstanceFuncs(target);
-        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
-        delegateFunc(target, baseFuncs);
-        var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
-        if (setInstanceFunc && options) {
-            setInstanceFunc = !!options[strSetInstFuncs];
-        }
-        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
-    }
-    dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
-
-    var createEnumStyle = createEnum;
-
-    var _DYN_TO_LOWER_CASE = "toLowerCase";
-    var _DYN_LENGTH = "length";
-    var _DYN_WARN_TO_CONSOLE = "warnToConsole";
-    var _DYN_THROW_INTERNAL = "throwInternal";
-    var _DYN_WATCH = "watch";
-    var _DYN_APPLY = "apply";
-    var _DYN_PUSH = "push";
-    var _DYN_SPLICE = "splice";
-    var _DYN_LOGGER = "logger";
-    var _DYN_CANCEL = "cancel";
-    var _DYN_INITIALIZE = "initialize";
-    var _DYN_IDENTIFIER = "identifier";
-    var _DYN_IS_INITIALIZED = "isInitialized";
-    var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_NAME = "name";
-    var _DYN_PROCESS_NEXT = "processNext";
-    var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
-    var _DYN_ENABLED = "enabled";
-    var _DYN_UNLOAD = "unload";
-    var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
-    var _DYN_CREATE_NEW = "createNew";
-    var _DYN_TEARDOWN = "teardown";
-    var _DYN_MESSAGE_ID = "messageId";
-    var _DYN_MESSAGE = "message";
-    var _DYN_DIAG_LOG = "diagLog";
-    var _DYN__DO_TEARDOWN = "_doTeardown";
-    var _DYN_UPDATE = "update";
-    var _DYN_GET_NEXT = "getNext";
-    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-    var _DYN_USER_AGENT = "userAgent";
-    var _DYN_SPLIT = "split";
-    var _DYN_REPLACE = "replace";
-    var _DYN_IS_CHILD_EVT = "isChildEvt";
-    var _DYN_GET_CTX = "getCtx";
-    var _DYN_SET_CTX = "setCtx";
-
-    var aggregationErrorType;
-    function throwAggregationError(message, sourceErrors) {
-        if (!aggregationErrorType) {
-            aggregationErrorType = createCustomError("AggregationError", function (self, args) {
-                if (args[_DYN_LENGTH ] > 1) {
-                    self.errors = args[1];
-                }
-            });
-        }
-        var theMessage = message || "One or more errors occurred.";
-        arrForEach(sourceErrors, function (srcError, idx) {
-            theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
-        });
-        throw new aggregationErrorType(theMessage, sourceErrors || []);
-    }
-
-    var UNDEFINED_VALUE = undefined;
-    var STR_EMPTY = "";
-    var STR_CORE = "core";
-    var STR_DISABLED = "disabled";
-    var STR_EXTENSION_CONFIG = "extensionConfig";
-    var STR_PROCESS_TELEMETRY = "processTelemetry";
-    var STR_PRIORITY = "priority";
-    var STR_GET_PERF_MGR = "getPerfMgr";
-    var STR_DOMAIN = "domain";
-    var STR_PATH = "path";
-    var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
-
-    var rCamelCase = /-([a-z])/g;
-    var rNormalizeInvalid = /([^\w\d_$])/g;
-    var rLeadingNumeric = /^(\d+[\w\d_$])/;
-    function isNotNullOrUndefined(value) {
-        return !isNullOrUndefined(value);
-    }
-    function normalizeJsName(name) {
-        var value = name;
-        if (value && isString(value)) {
-            value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
-                return letter.toUpperCase();
-            });
-            value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
-            value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
-                return "_" + match;
-            });
-        }
-        return value;
-    }
-    function strContains(value, search) {
-        if (value && search) {
-            return strIndexOf(value, search) !== -1;
-        }
-        return false;
-    }
-    function getExceptionName(object) {
-        if (isError(object)) {
-            return object[_DYN_NAME ];
-        }
-        return STR_EMPTY;
-    }
-    function setValue(target, field, value, valChk, srcChk) {
-        var theValue = value;
-        if (target) {
-            theValue = target[field];
-            if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
-                theValue = value;
-                target[field] = theValue;
-            }
-        }
-        return theValue;
-    }
-    function _createProxyFunction(source, funcName) {
-        var srcFunc = null;
-        var src = null;
-        if (isFunction(source)) {
-            srcFunc = source;
-        }
-        else {
-            src = source;
-        }
-        return function () {
-            var originalArguments = arguments;
-            if (srcFunc) {
-                src = srcFunc();
-            }
-            if (src) {
-                return src[funcName][_DYN_APPLY ](src, originalArguments);
-            }
-        };
-    }
-    function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
-        if (target && name && source) {
-            if (overwriteTarget !== false || isUndefined(target[name])) {
-                target[name] = _createProxyFunction(source, theFunc);
-            }
-        }
-    }
-    function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
-        if (target && source && isObject(target) && isArray(functionsToProxy)) {
-            arrForEach(functionsToProxy, function (theFuncName) {
-                if (isString(theFuncName)) {
-                    proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
-                }
-            });
-        }
-        return target;
-    }
-
-    var strLocation = "location";
-    var strConsole = "console";
-    var strJSON = "JSON";
-    var strCrypto = "crypto";
-    var strMsCrypto = "msCrypto";
-    var strMsie = "msie";
-    var strTrident = "trident/";
-    var _isTrident = null;
-    var _navUserAgentCheck = null;
-    var _enableMocks = false;
-    function getLocation(checkForMock) {
-        if (checkForMock && _enableMocks) {
-            var mockLocation = getInst("__mockLocation");
-            if (mockLocation) {
-                return mockLocation;
-            }
-        }
-        if (typeof location === strShimObject && location) {
-            return location;
-        }
-        return getInst(strLocation);
-    }
-    function getConsole() {
-        if (typeof console !== strShimUndefined) {
-            return console;
-        }
-        return getInst(strConsole);
-    }
-    function hasJSON() {
-        return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
-    }
-    function getJSON() {
-        if (hasJSON()) {
-            return JSON || getInst(strJSON);
-        }
-        return null;
-    }
-    function getCrypto() {
-        return getInst(strCrypto);
-    }
-    function getMsCrypto() {
-        return getInst(strMsCrypto);
-    }
-    function isIE() {
-        var nav = getNavigator();
-        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
-            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
-        }
-        return _isTrident;
-    }
-
-    var UInt32Mask = 0x100000000;
-    var MaxUInt32 = 0xffffffff;
-    var SEED1 = 123456789;
-    var SEED2 = 987654321;
-    var _mwcSeeded = false;
-    var _mwcW = SEED1;
-    var _mwcZ = SEED2;
-    function _mwcSeed(seedValue) {
-        if (seedValue < 0) {
-            seedValue >>>= 0;
-        }
-        _mwcW = (SEED1 + seedValue) & MaxUInt32;
-        _mwcZ = (SEED2 - seedValue) & MaxUInt32;
-        _mwcSeeded = true;
-    }
-    function _autoSeedMwc() {
-        try {
-            var now = utcNow() & 0x7fffffff;
-            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
-        }
-        catch (e) {
-        }
-    }
-    function random32(signed) {
-        var value = 0;
-        var c = getCrypto() || getMsCrypto();
-        if (c && c.getRandomValues) {
-            value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
-        }
-        if (value === 0 && isIE()) {
-            if (!_mwcSeeded) {
-                _autoSeedMwc();
-            }
-            value = mwcRandom32() & MaxUInt32;
-        }
-        if (value === 0) {
-            value = mathFloor((UInt32Mask * Math.random()) | 0);
-        }
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function mwcRandom32(signed) {
-        _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
-        _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
-        var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function newId(maxLength) {
-        if (maxLength === void 0) { maxLength = 22; }
-        var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        var number = random32() >>> 0;
-        var chars = 0;
-        var result = STR_EMPTY;
-        while (result[_DYN_LENGTH ] < maxLength) {
-            chars++;
-            result += base64chars.charAt(number & 0x3F);
-            number >>>= 6;
-            if (chars === 5) {
-                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-                chars = 0;
-            }
-        }
-        return result;
-    }
-
-    var version = '3.3.10-nightly3.2507-02';
-    var instanceName = "." + newId(6);
-    var _dataUid = 0;
-    function _canAcceptData(target) {
-        return target.nodeType === 1 || target.nodeType === 9 || !(+target.nodeType);
-    }
-    function _getCache(data, target) {
-        var theCache = target[data.id];
-        if (!theCache) {
-            theCache = {};
-            try {
-                if (_canAcceptData(target)) {
-                    objDefine(target, data.id, {
-                        e: false,
-                        v: theCache
-                    });
-                }
-            }
-            catch (e) {
-            }
-        }
-        return theCache;
-    }
-    function createUniqueNamespace(name, includeVersion) {
-        if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
-    }
-    function createElmNodeData(name) {
-        var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
-            accept: function (target) {
-                return _canAcceptData(target);
-            },
-            get: function (target, name, defValue, addDefault) {
-                var theCache = target[data.id];
-                if (!theCache) {
-                    if (addDefault) {
-                        theCache = _getCache(data, target);
-                        theCache[normalizeJsName(name)] = defValue;
-                    }
-                    return defValue;
-                }
-                return theCache[normalizeJsName(name)];
-            },
-            kill: function (target, name) {
-                if (target && target[name]) {
-                    try {
-                        delete target[name];
-                    }
-                    catch (e) {
-                    }
-                }
-            }
-        };
-        return data;
-    }
-
-    function _isConfigDefaults(value) {
-        return (value && isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
-    }
-    function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
-        var defValue;
-        var isDefaultValid = cfgDefaults.dfVal || isDefined;
-        if (theConfig && cfgDefaults.fb) {
-            var fallbacks = cfgDefaults.fb;
-            if (!isArray(fallbacks)) {
-                fallbacks = [fallbacks];
-            }
-            for (var lp = 0; lp < fallbacks[_DYN_LENGTH ]; lp++) {
-                var fallback = fallbacks[lp];
-                var fbValue = theConfig[fallback];
-                if (isDefaultValid(fbValue)) {
-                    defValue = fbValue;
-                }
-                else if (dynamicHandler) {
-                    fbValue = dynamicHandler.cfg[fallback];
-                    if (isDefaultValid(fbValue)) {
-                        defValue = fbValue;
-                    }
-                    dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
-                }
-                if (isDefaultValid(defValue)) {
-                    break;
-                }
-            }
-        }
-        if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
-            defValue = cfgDefaults.v;
-        }
-        return defValue;
-    }
-    function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
-        var theValue = cfgDefaults;
-        if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
-            theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
-        }
-        if (theValue) {
-            if (_isConfigDefaults(theValue)) {
-                theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
-            }
-            var newValue_1;
-            if (isArray(theValue)) {
-                newValue_1 = [];
-                newValue_1[_DYN_LENGTH ] = theValue[_DYN_LENGTH ];
-            }
-            else if (isPlainObject(theValue)) {
-                newValue_1 = {};
-            }
-            if (newValue_1) {
-                objForEachKey(theValue, function (key, value) {
-                    if (value && _isConfigDefaults(value)) {
-                        value = _resolveDefaultValue(dynamicHandler, theConfig, value);
-                    }
-                    newValue_1[key] = value;
-                });
-                theValue = newValue_1;
-            }
-        }
-        return theValue;
-    }
-    function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
-        var isValid;
-        var setFn;
-        var defValue;
-        var cfgDefaults = defaultValue;
-        var mergeDf;
-        var reference;
-        var readOnly;
-        var blkDynamicValue;
-        if (_isConfigDefaults(cfgDefaults)) {
-            isValid = cfgDefaults.isVal;
-            setFn = cfgDefaults.set;
-            readOnly = cfgDefaults.rdOnly;
-            blkDynamicValue = cfgDefaults.blkVal;
-            mergeDf = cfgDefaults.mrg;
-            reference = cfgDefaults.ref;
-            if (!reference && isUndefined(reference)) {
-                reference = !!mergeDf;
-            }
-            defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
-        }
-        else {
-            defValue = defaultValue;
-        }
-        if (blkDynamicValue) {
-            dynamicHandler.blkVal(theConfig, name);
-        }
-        var theValue;
-        var usingDefault = true;
-        var cfgValue = theConfig[name];
-        if (cfgValue || !isNullOrUndefined(cfgValue)) {
-            theValue = cfgValue;
-            usingDefault = false;
-            if (isValid && theValue !== defValue && !isValid(theValue)) {
-                theValue = defValue;
-                usingDefault = true;
-            }
-            if (setFn) {
-                theValue = setFn(theValue, defValue, theConfig);
-                usingDefault = theValue === defValue;
-            }
-        }
-        if (!usingDefault) {
-            if (isPlainObject(theValue) || isArray(defValue)) {
-                if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {
-                    objForEachKey(defValue, function (dfName, dfValue) {
-                        _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
-                    });
-                }
-            }
-        }
-        else if (defValue) {
-            theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
-        }
-        else {
-            theValue = defValue;
-        }
-        dynamicHandler.set(theConfig, name, theValue);
-        if (reference) {
-            dynamicHandler.ref(theConfig, name);
-        }
-        if (readOnly) {
-            dynamicHandler.rdOnly(theConfig, name);
-        }
-    }
-
-    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
-    var BLOCK_DYNAMIC = symbolFor("[[ai_blkDynCfg_1]]");
-    var FORCE_DYNAMIC = symbolFor("[[ai_frcDynCfg_1]]");
-    function _cfgDeepCopy(source) {
-        if (source) {
-            var target_1;
-            if (isArray(source)) {
-                target_1 = [];
-                target_1[_DYN_LENGTH ] = source[_DYN_LENGTH ];
-            }
-            else if (isPlainObject(source)) {
-                target_1 = {};
-            }
-            if (target_1) {
-                objForEachKey(source, function (key, value) {
-                    target_1[key] = _cfgDeepCopy(value);
-                });
-                return target_1;
-            }
-        }
-        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 blockDynamicConversion(value) {
-        if (value && (isPlainObject(value) || isArray(value))) {
-            try {
-                value[BLOCK_DYNAMIC] = true;
-            }
-            catch (e) {
-            }
-        }
-        return value;
-    }
-    function _canMakeDynamic(getFunc, state, value) {
-        var result = false;
-        if (value && !getFunc[state.blkVal]) {
-            result = value[FORCE_DYNAMIC];
-            if (!result && !value[BLOCK_DYNAMIC]) {
-                result = isPlainObject(value) || isArray(value);
-            }
-        }
-        return result;
-    }
-    function throwInvalidAccess(message) {
-        throwTypeError("InvalidAccess:" + message);
-    }
-
-    var arrayMethodsToPatch = [
-        "push",
-        "pop",
-        "shift",
-        "unshift",
-        "splice"
-    ];
-    var _throwDynamicError = function (logger, name, desc, e) {
-        logger && logger[_DYN_THROW_INTERNAL ](3 , 108 , "".concat(desc, " [").concat(name, "] failed - ") + dumpObj(e));
-    };
-    function _patchArray(state, target, name) {
-        if (isArray(target)) {
-            arrForEach(arrayMethodsToPatch, function (method) {
-                var orgMethod = target[method];
-                target[method] = function () {
-                    var args = [];
-                    for (var _i = 0; _i < arguments.length; _i++) {
-                        args[_i] = arguments[_i];
-                    }
-                    var result = orgMethod[_DYN_APPLY ](this, args);
-                    _makeDynamicObject(state, target, name, "Patching");
-                    return result;
-                };
-            });
-        }
-    }
-    function _getOwnPropGetter(target, name) {
-        var propDesc = objGetOwnPropertyDescriptor(target, name);
-        return propDesc && propDesc.get;
-    }
-    function _createDynamicProperty(state, theConfig, name, value) {
-        var detail = {
-            n: name,
-            h: [],
-            trk: function (handler) {
-                if (handler && handler.fn) {
-                    if (arrIndexOf(detail.h, handler) === -1) {
-                        detail.h[_DYN_PUSH ](handler);
-                    }
-                    state.trk(handler, detail);
-                }
-            },
-            clr: function (handler) {
-                var idx = arrIndexOf(detail.h, handler);
-                if (idx !== -1) {
-                    detail.h[_DYN_SPLICE ](idx, 1);
-                }
-            }
-        };
-        var checkDynamic = true;
-        var isObjectOrArray = false;
-        function _getProperty() {
-            if (checkDynamic) {
-                isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
-                if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
-                    value = _makeDynamicObject(state, value, name, "Converting");
-                }
-                checkDynamic = false;
-            }
-            var activeHandler = state.act;
-            if (activeHandler) {
-                detail.trk(activeHandler);
-            }
-            return value;
-        }
-        _getProperty[state.prop] = {
-            chng: function () {
-                state.add(detail);
-            }
-        };
-        function _setProperty(newValue) {
-            if (value !== newValue) {
-                if (!!_getProperty[state.ro] && !state.upd) {
-                    throwInvalidAccess("[" + name + "] is read-only:" + dumpObj(theConfig));
-                }
-                if (checkDynamic) {
-                    isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
-                    checkDynamic = false;
-                }
-                var isReferenced = isObjectOrArray && _getProperty[state.rf];
-                if (isObjectOrArray) {
-                    if (isReferenced) {
-                        objForEachKey(value, function (key) {
-                            value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
-                        });
-                        try {
-                            objForEachKey(newValue, function (key, theValue) {
-                                _setDynamicProperty(state, value, key, theValue);
-                            });
-                            newValue = value;
-                        }
-                        catch (e) {
-                            _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Assigning", e);
-                            isObjectOrArray = false;
-                        }
-                    }
-                    else if (value && value[CFG_HANDLER_LINK]) {
-                        objForEachKey(value, function (key) {
-                            var getter = _getOwnPropGetter(value, key);
-                            if (getter) {
-                                var valueState = getter[state.prop];
-                                valueState && valueState.chng();
-                            }
-                        });
-                    }
-                }
-                if (newValue !== value) {
-                    var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
-                    if (!isReferenced && newIsObjectOrArray) {
-                        newValue = _makeDynamicObject(state, newValue, name, "Converting");
-                    }
-                    value = newValue;
-                    isObjectOrArray = newIsObjectOrArray;
-                }
-                state.add(detail);
-            }
-        }
-        objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
-    }
-    function _setDynamicProperty(state, target, name, value) {
-        if (target) {
-            var getter = _getOwnPropGetter(target, name);
-            var isDynamic = getter && !!getter[state.prop];
-            if (!isDynamic) {
-                _createDynamicProperty(state, target, name, value);
-            }
-            else {
-                target[name] = value;
-            }
-        }
-        return target;
-    }
-    function _setDynamicPropertyState(state, target, name, flags) {
-        if (target) {
-            var getter = _getOwnPropGetter(target, name);
-            var isDynamic = getter && !!getter[state.prop];
-            var inPlace = flags && flags[0 ];
-            var rdOnly = flags && flags[1 ];
-            var blkProp = flags && flags[2 ];
-            if (!isDynamic) {
-                if (blkProp) {
-                    try {
-                        blockDynamicConversion(target);
-                    }
-                    catch (e) {
-                        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Blocking", e);
-                    }
-                }
-                try {
-                    _setDynamicProperty(state, target, name, target[name]);
-                    getter = _getOwnPropGetter(target, name);
-                }
-                catch (e) {
-                    _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "State", e);
-                }
-            }
-            if (inPlace) {
-                getter[state.rf] = inPlace;
-            }
-            if (rdOnly) {
-                getter[state.ro] = rdOnly;
-            }
-            if (blkProp) {
-                getter[state.blkVal] = true;
-            }
-        }
-        return target;
-    }
-    function _makeDynamicObject(state, target, name, desc) {
-        try {
-            objForEachKey(target, function (key, value) {
-                _setDynamicProperty(state, target, key, value);
-            });
-            if (!target[CFG_HANDLER_LINK]) {
-                objDefineProp(target, CFG_HANDLER_LINK, {
-                    get: function () {
-                        return state.hdlr;
-                    }
-                });
-                _patchArray(state, target, name);
-            }
-        }
-        catch (e) {
-            _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, desc, e);
-        }
-        return target;
-    }
-
-    var symPrefix = "[[ai_";
-    var symPostfix = "]]";
-    function _createState(cfgHandler) {
-        var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
-        var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
-        var dynamicPropertyReferenced = newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
-        var dynamicPropertyBlockValue = newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
-        var dynamicPropertyDetail = newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
-        var _waitingHandlers = null;
-        var _watcherTimer = null;
-        var theState;
-        function _useHandler(activeHandler, callback) {
-            var prevWatcher = theState.act;
-            try {
-                theState.act = activeHandler;
-                if (activeHandler && activeHandler[dynamicPropertyDetail]) {
-                    arrForEach(activeHandler[dynamicPropertyDetail], function (detail) {
-                        detail.clr(activeHandler);
-                    });
-                    activeHandler[dynamicPropertyDetail] = [];
-                }
-                callback({
-                    cfg: cfgHandler.cfg,
-                    set: cfgHandler.set.bind(cfgHandler),
-                    setDf: cfgHandler.setDf.bind(cfgHandler),
-                    ref: cfgHandler.ref.bind(cfgHandler),
-                    rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
-                });
-            }
-            catch (e) {
-                var logger = cfgHandler[_DYN_LOGGER ];
-                if (logger) {
-                    logger[_DYN_THROW_INTERNAL ](1 , 107 , dumpObj(e));
-                }
-                throw e;
-            }
-            finally {
-                theState.act = prevWatcher || null;
-            }
-        }
-        function _notifyWatchers() {
-            if (_waitingHandlers) {
-                var notifyHandlers = _waitingHandlers;
-                _waitingHandlers = null;
-                _watcherTimer && _watcherTimer[_DYN_CANCEL ]();
-                _watcherTimer = null;
-                var watcherFailures_1 = [];
-                arrForEach(notifyHandlers, function (handler) {
-                    if (handler) {
-                        if (handler[dynamicPropertyDetail]) {
-                            arrForEach(handler[dynamicPropertyDetail], function (detail) {
-                                detail.clr(handler);
-                            });
-                            handler[dynamicPropertyDetail] = null;
-                        }
-                        if (handler.fn) {
-                            try {
-                                _useHandler(handler, handler.fn);
-                            }
-                            catch (e) {
-                                watcherFailures_1[_DYN_PUSH ](e);
-                            }
-                        }
-                    }
-                });
-                if (_waitingHandlers) {
-                    try {
-                        _notifyWatchers();
-                    }
-                    catch (e) {
-                        watcherFailures_1[_DYN_PUSH ](e);
-                    }
-                }
-                if (watcherFailures_1[_DYN_LENGTH ] > 0) {
-                    throwAggregationError("Watcher error(s): ", watcherFailures_1);
-                }
-            }
-        }
-        function _addWatcher(detail) {
-            if (detail && detail.h[_DYN_LENGTH ] > 0) {
-                if (!_waitingHandlers) {
-                    _waitingHandlers = [];
-                }
-                if (!_watcherTimer) {
-                    _watcherTimer = scheduleTimeout(function () {
-                        _watcherTimer = null;
-                        _notifyWatchers();
-                    }, 0);
-                }
-                for (var idx = 0; idx < detail.h[_DYN_LENGTH ]; idx++) {
-                    var handler = detail.h[idx];
-                    if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
-                        _waitingHandlers[_DYN_PUSH ](handler);
-                    }
-                }
-            }
-        }
-        function _trackHandler(handler, detail) {
-            if (handler) {
-                var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
-                if (arrIndexOf(details, detail) === -1) {
-                    details[_DYN_PUSH ](detail);
-                }
-            }
-        }
-        theState = {
-            prop: dynamicPropertySymbol,
-            ro: dynamicPropertyReadOnly,
-            rf: dynamicPropertyReferenced,
-            blkVal: dynamicPropertyBlockValue,
-            hdlr: cfgHandler,
-            add: _addWatcher,
-            notify: _notifyWatchers,
-            use: _useHandler,
-            trk: _trackHandler
-        };
-        return theState;
-    }
-
-    function _createAndUseHandler(state, configHandler) {
-        var handler = {
-            fn: configHandler,
-            rm: function () {
-                handler.fn = null;
-                state = null;
-                configHandler = null;
-            }
-        };
-        objDefine(handler, "toJSON", { v: function () { return "WatcherHandler" + (handler.fn ? "" : "[X]"); } });
-        state.use(handler, configHandler);
-        return handler;
-    }
-    function _createDynamicHandler(logger, target, inPlace) {
-        var dynamicHandler = getDynamicConfigHandler(target);
-        if (dynamicHandler) {
-            return dynamicHandler;
-        }
-        var uid = createUniqueNamespace("dyncfg", true);
-        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
-        var theState;
-        function _notifyWatchers() {
-            theState.notify();
-        }
-        function _setValue(target, name, value) {
-            try {
-                target = _setDynamicProperty(theState, target, name, value);
-            }
-            catch (e) {
-                _throwDynamicError(logger, name, "Setting value", e);
-            }
-            return target[name];
-        }
-        function _watch(configHandler) {
-            return _createAndUseHandler(theState, configHandler);
-        }
-        function _block(configHandler, allowUpdate) {
-            theState.use(null, function (details) {
-                var prevUpd = theState.upd;
-                try {
-                    if (!isUndefined(allowUpdate)) {
-                        theState.upd = allowUpdate;
-                    }
-                    configHandler(details);
-                }
-                finally {
-                    theState.upd = prevUpd;
-                }
-            });
-        }
-        function _ref(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 ] = true, _a))[name];
-        }
-        function _rdOnly(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 ] = true, _a))[name];
-        }
-        function _blkPropValue(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 ] = true, _a))[name];
-        }
-        function _applyDefaults(theConfig, defaultValues) {
-            if (defaultValues) {
-                objForEachKey(defaultValues, function (name, value) {
-                    _applyDefaultValue(cfgHandler, theConfig, name, value);
-                });
-            }
-            return theConfig;
-        }
-        var cfgHandler = {
-            uid: null,
-            cfg: newTarget,
-            logger: logger,
-            notify: _notifyWatchers,
-            set: _setValue,
-            setDf: _applyDefaults,
-            watch: _watch,
-            ref: _ref,
-            rdOnly: _rdOnly,
-            blkVal: _blkPropValue,
-            _block: _block
-        };
-        objDefine(cfgHandler, "uid", {
-            c: false,
-            e: false,
-            w: false,
-            v: uid
-        });
-        theState = _createState(cfgHandler);
-        _makeDynamicObject(theState, newTarget, "config", "Creating");
-        return cfgHandler;
-    }
-    function _logInvalidAccess(logger, message) {
-        if (logger) {
-            logger[_DYN_WARN_TO_CONSOLE ](message);
-            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
-        }
-        else {
-            throwInvalidAccess(message);
-        }
-    }
-    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
-        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
-        if (defaultConfig) {
-            dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
-        }
-        return dynamicHandler;
-    }
-    function onConfigChange(config, configHandler, logger) {
-        var handler = config[CFG_HANDLER_LINK] || config;
-        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-            return handler[_DYN_WATCH ](configHandler);
-        }
-        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
-    }
-
-    function cfgDfMerge(defaultValue) {
-        return {
-            mrg: true,
-            v: defaultValue
-        };
-    }
-
-    var _aiNamespace = null;
-    function _getExtensionNamespace() {
-        var target = getInst("Microsoft");
-        if (target) {
-            _aiNamespace = target["ApplicationInsights"];
-        }
-        return _aiNamespace;
-    }
-    function getDebugExt(config) {
-        var ns = _aiNamespace;
-        if (!ns && config.disableDbgExt !== true) {
-            ns = _aiNamespace || _getExtensionNamespace();
-        }
-        return ns ? ns["ChromeDbgExt"] : null;
-    }
-
-    var _a$2;
-    var STR_WARN_TO_CONSOLE = "warnToConsole";
-    var AiNonUserActionablePrefix = "AI (Internal): ";
-    var AiUserActionablePrefix = "AI: ";
-    var AIInternalMessagePrefix = "AITR_";
-    var defaultValues$1 = {
-        loggingLevelConsole: 0,
-        loggingLevelTelemetry: 1,
-        maxMessageLimit: 25,
-        enableDebug: false
-    };
-    var _logFuncs = (_a$2 = {},
-        _a$2[0 ] = null,
-        _a$2[1 ] = "errorToConsole",
-        _a$2[2 ] = STR_WARN_TO_CONSOLE,
-        _a$2[3 ] = "debugToConsole",
-        _a$2);
-    function _sanitizeDiagnosticText(text) {
-        if (text) {
-            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
-        }
-        return STR_EMPTY;
-    }
-    function _logToConsole(func, message) {
-        var theConsole = getConsole();
-        if (!!theConsole) {
-            var logFunc = "log";
-            if (theConsole[func]) {
-                logFunc = func;
-            }
-            if (isFunction(theConsole[logFunc])) {
-                theConsole[logFunc](message);
-            }
-        }
-    }
-    var _InternalLogMessage = /** @class */ (function () {
-        function _InternalLogMessage(msgId, msg, isUserAct, properties) {
-            if (isUserAct === void 0) { isUserAct = false; }
-            var _self = this;
-            _self[_DYN_MESSAGE_ID ] = msgId;
-            _self[_DYN_MESSAGE ] =
-                (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
-                    msgId;
-            var strProps = STR_EMPTY;
-            if (hasJSON()) {
-                strProps = getJSON().stringify(properties);
-            }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
-            _self[_DYN_MESSAGE ] += diagnosticText;
-        }
-        _InternalLogMessage.dataType = "MessageData";
-        return _InternalLogMessage;
-    }());
-    function safeGetLogger(core, config) {
-        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
-    }
-    var DiagnosticLogger = /** @class */ (function () {
-        function DiagnosticLogger(config) {
-            this.identifier = "DiagnosticLogger";
-            this.queue = [];
-            var _messageCount = 0;
-            var _messageLogged = {};
-            var _loggingLevelConsole;
-            var _loggingLevelTelemetry;
-            var _maxInternalMessageLimit;
-            var _enableDebug;
-            var _unloadHandler;
-            dynamicProto(DiagnosticLogger, this, function (_self) {
-                _unloadHandler = _setDefaultsFromConfig(config || {});
-                _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
-                _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
-                    if (isUserAct === void 0) { isUserAct = false; }
-                    var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                    if (_enableDebug) {
-                        throw dumpObj(message);
-                    }
-                    else {
-                        var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
-                        if (!isUndefined(message[_DYN_MESSAGE ])) {
-                            if (isUserAct) {
-                                var messageKey = +message[_DYN_MESSAGE_ID ];
-                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE ]);
-                                    _messageLogged[messageKey] = true;
-                                }
-                            }
-                            else {
-                                if (_loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE ]);
-                                }
-                            }
-                            _logInternalMessage(severity, message);
-                        }
-                        else {
-                            _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
-                        }
-                    }
-                };
-                _self.debugToConsole = function (message) {
-                    _logToConsole("debug", message);
-                    _debugExtMsg("warning", message);
-                };
-                _self[_DYN_WARN_TO_CONSOLE ] = function (message) {
-                    _logToConsole("warn", message);
-                    _debugExtMsg("warning", message);
-                };
-                _self.errorToConsole = function (message) {
-                    _logToConsole("error", message);
-                    _debugExtMsg("error", message);
-                };
-                _self.resetInternalMessageCount = function () {
-                    _messageCount = 0;
-                    _messageLogged = {};
-                };
-                _self.logInternalMessage = _logInternalMessage;
-                _self[_DYN_UNLOAD ] = function (isAsync) {
-                    _unloadHandler && _unloadHandler.rm();
-                    _unloadHandler = null;
-                };
-                function _logInternalMessage(severity, message) {
-                    if (_areInternalMessagesThrottled()) {
-                        return;
-                    }
-                    var logMessage = true;
-                    var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
-                    if (_messageLogged[messageKey]) {
-                        logMessage = false;
-                    }
-                    else {
-                        _messageLogged[messageKey] = true;
-                    }
-                    if (logMessage) {
-                        if (severity <= _loggingLevelTelemetry) {
-                            _self.queue[_DYN_PUSH ](message);
-                            _messageCount++;
-                            _debugExtMsg((severity === 1  ? "error" : "warn"), message);
-                        }
-                        if (_messageCount === _maxInternalMessageLimit) {
-                            var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                            var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                            _self.queue[_DYN_PUSH ](throttleMessage);
-                            if (severity === 1 ) {
-                                _self.errorToConsole(throttleLimitMessage);
-                            }
-                            else {
-                                _self[_DYN_WARN_TO_CONSOLE ](throttleLimitMessage);
-                            }
-                        }
-                    }
-                }
-                function _setDefaultsFromConfig(config) {
-                    return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
-                        var config = details.cfg;
-                        _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
-                        _loggingLevelTelemetry = config.loggingLevelTelemetry;
-                        _maxInternalMessageLimit = config.maxMessageLimit;
-                        _enableDebug = config.enableDebug;
-                    });
-                }
-                function _areInternalMessagesThrottled() {
-                    return _messageCount >= _maxInternalMessageLimit;
-                }
-                function _debugExtMsg(name, data) {
-                    var dbgExt = getDebugExt(config || {});
-                    if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
-                        dbgExt[_DYN_DIAG_LOG ](name, data);
-                    }
-                }
-            });
-        }
-        DiagnosticLogger.__ieDyn=1;
-        return DiagnosticLogger;
-    }());
-    function _getLogger(logger) {
-        return (logger || new DiagnosticLogger());
-    }
-    function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
-        if (isUserAct === void 0) { isUserAct = false; }
-        _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
-    }
-
-    var _a$1, _b;
-    var strToGMTString = "toGMTString";
-    var strToUTCString = "toUTCString";
-    var strCookie = "cookie";
-    var strExpires = "expires";
-    var strIsCookieUseDisabled = "isCookieUseDisabled";
-    var strDisableCookiesUsage = "disableCookiesUsage";
-    var strConfigCookieMgr = "_ckMgr";
-    var _supportsCookies = null;
-    var _allowUaSameSite = null;
-    var _parsedCookieValue = null;
-    var _doc;
-    var _cookieCache = {};
-    var _globalCookieConfig = {};
-    var rootDefaultConfig = (_a$1 = {
-            cookieCfg: cfgDfMerge((_b = {},
-                _b[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
-                _b.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
-                _b.enabled = UNDEFINED_VALUE,
-                _b.ignoreCookies = UNDEFINED_VALUE,
-                _b.blockedCookies = UNDEFINED_VALUE,
-                _b)),
-            cookieDomain: UNDEFINED_VALUE,
-            cookiePath: UNDEFINED_VALUE
-        },
-        _a$1[strDisableCookiesUsage] = UNDEFINED_VALUE,
-        _a$1);
-    function _getDoc() {
-        !_doc && (_doc = getLazy(function () { return getDocument(); }));
-    }
-    function _gblCookieMgr(config, logger) {
-        var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
-        if (!inst) {
-            inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
-            _globalCookieConfig[strConfigCookieMgr] = inst;
-        }
-        return inst;
-    }
-    function _isMgrEnabled(cookieMgr) {
-        if (cookieMgr) {
-            return cookieMgr.isEnabled();
-        }
-        return true;
-    }
-    function _isIgnoredCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
-            return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
-        }
-        return false;
-    }
-    function _isBlockedCookie(cookieMgrCfg, name) {
-        if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
-            if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
-                return true;
-            }
-        }
-        return _isIgnoredCookie(cookieMgrCfg, name);
-    }
-    function _isCfgEnabled(rootConfig, cookieMgrConfig) {
-        var isCfgEnabled = cookieMgrConfig[_DYN_ENABLED ];
-        if (isNullOrUndefined(isCfgEnabled)) {
-            var cookieEnabled = void 0;
-            if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
-                cookieEnabled = !rootConfig[strIsCookieUseDisabled];
-            }
-            if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
-                cookieEnabled = !rootConfig[strDisableCookiesUsage];
-            }
-            isCfgEnabled = cookieEnabled;
-        }
-        return isCfgEnabled;
-    }
-    function safeGetCookieMgr(core, config) {
-        var cookieMgr;
-        if (core) {
-            cookieMgr = core.getCookieMgr();
-        }
-        else if (config) {
-            var cookieCfg = config.cookieCfg;
-            if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
-                cookieMgr = cookieCfg[strConfigCookieMgr];
-            }
-            else {
-                cookieMgr = createCookieMgr(config);
-            }
-        }
-        if (!cookieMgr) {
-            cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER ]);
-        }
-        return cookieMgr;
-    }
-    function createCookieMgr(rootConfig, logger) {
-        var cookieMgrConfig;
-        var _path;
-        var _domain;
-        var unloadHandler;
-        var _enabled;
-        var _getCookieFn;
-        var _setCookieFn;
-        var _delCookieFn;
-        rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
-        unloadHandler = onConfigChange(rootConfig, function (details) {
-            details.setDf(details.cfg, rootDefaultConfig);
-            cookieMgrConfig = details.ref(details.cfg, "cookieCfg");
-            _path = cookieMgrConfig[STR_PATH ] || "/";
-            _domain = cookieMgrConfig[STR_DOMAIN ];
-            _enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false;
-            _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
-            _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
-            _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
-        }, logger);
-        var cookieMgr = {
-            isEnabled: function () {
-                var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger);
-                var gblManager = _globalCookieConfig[strConfigCookieMgr];
-                if (enabled && gblManager && cookieMgr !== gblManager) {
-                    enabled = _isMgrEnabled(gblManager);
-                }
-                return enabled;
-            },
-            setEnabled: function (value) {
-                _enabled = value !== false;
-                cookieMgrConfig[_DYN_ENABLED ] = value;
-            },
-            set: function (name, value, maxAgeSec, domain, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
-                    var values = {};
-                    var theValue = strTrim(value || STR_EMPTY);
-                    var idx = strIndexOf(theValue, ";");
-                    if (idx !== -1) {
-                        theValue = strTrim(strLeft(value, idx));
-                        values = _extractParts(strSubstring(value, idx + 1));
-                    }
-                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
-                    if (!isNullOrUndefined(maxAgeSec)) {
-                        var _isIE = isIE();
-                        if (isUndefined(values[strExpires])) {
-                            var nowMs = utcNow();
-                            var expireMs = nowMs + (maxAgeSec * 1000);
-                            if (expireMs > 0) {
-                                var expiry = new Date();
-                                expiry.setTime(expireMs);
-                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
-                            }
-                        }
-                        if (!_isIE) {
-                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
-                        }
-                    }
-                    var location_1 = getLocation();
-                    if (location_1 && location_1.protocol === "https:") {
-                        setValue(values, "secure", null, null, isUndefined);
-                        if (_allowUaSameSite === null) {
-                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
-                        }
-                        if (_allowUaSameSite) {
-                            setValue(values, "SameSite", "None", null, isUndefined);
-                        }
-                    }
-                    setValue(values, STR_PATH, path || _path, null, isUndefined);
-                    _setCookieFn(name, _formatCookieValue(theValue, values));
-                    result = true;
-                }
-                return result;
-            },
-            get: function (name) {
-                var value = STR_EMPTY;
-                if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                    value = _getCookieFn(name);
-                }
-                return value;
-            },
-            del: function (name, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr)) {
-                    result = cookieMgr.purge(name, path);
-                }
-                return result;
-            },
-            purge: function (name, path) {
-                var _a;
-                var result = false;
-                if (areCookiesSupported(logger)) {
-                    var values = (_a = {},
-                        _a[STR_PATH] = path ? path : "/",
-                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
-                        _a);
-                    if (!isIE()) {
-                        values["max-age"] = "0";
-                    }
-                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
-                    result = true;
-                }
-                return result;
-            },
-            unload: function (isAsync) {
-                unloadHandler && unloadHandler.rm();
-                unloadHandler = null;
-            }
-        };
-        cookieMgr[strConfigCookieMgr] = cookieMgr;
-        return cookieMgr;
-    }
-    function areCookiesSupported(logger) {
-        if (_supportsCookies === null) {
-            _supportsCookies = false;
-            !_doc && _getDoc();
-            try {
-                var doc = _doc.v || {};
-                _supportsCookies = doc[strCookie] !== undefined;
-            }
-            catch (e) {
-                _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
-            }
-        }
-        return _supportsCookies;
-    }
-    function _extractParts(theValue) {
-        var values = {};
-        if (theValue && theValue[_DYN_LENGTH ]) {
-            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
-            arrForEach(parts, function (thePart) {
-                thePart = strTrim(thePart || STR_EMPTY);
-                if (thePart) {
-                    var idx = strIndexOf(thePart, "=");
-                    if (idx === -1) {
-                        values[thePart] = null;
-                    }
-                    else {
-                        values[strTrim(strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
-                    }
-                }
-            });
-        }
-        return values;
-    }
-    function _formatDate(theDate, func) {
-        if (isFunction(theDate[func])) {
-            return theDate[func]();
-        }
-        return null;
-    }
-    function _formatCookieValue(value, values) {
-        var cookieValue = value || STR_EMPTY;
-        objForEachKey(values, function (name, theValue) {
-            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
-        });
-        return cookieValue;
-    }
-    function _getCookieValue(name) {
-        var cookieValue = STR_EMPTY;
-        !_doc && _getDoc();
-        if (_doc.v) {
-            var theCookie = _doc.v[strCookie] || STR_EMPTY;
-            if (_parsedCookieValue !== theCookie) {
-                _cookieCache = _extractParts(theCookie);
-                _parsedCookieValue = theCookie;
-            }
-            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
-        }
-        return cookieValue;
-    }
-    function _setCookieValue(name, cookieValue) {
-        !_doc && _getDoc();
-        if (_doc.v) {
-            _doc.v[strCookie] = name + "=" + cookieValue;
-        }
-    }
-    function uaDisallowsSameSiteNone(userAgent) {
-        if (!isString(userAgent)) {
-            return false;
-        }
-        if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
-            return true;
-        }
-        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
-            return true;
-        }
-        if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
-            return true;
-        }
-        if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
-            return true;
-        }
-        if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
-            return true;
-        }
-        if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
-            return true;
-        }
-        return false;
-    }
-
-    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.isAsync = 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];
-                    }
-                    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;
-                    }
-                }
-            };
-            _self.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.time;
-                        }
-                    }
-                }
-                _self.time = utcNow() - _self.start;
-                _self.exTime = _self.time - childTime;
-                _self.complete = function () { };
-            };
-        }
-        PerfEvent.ParentContextKey = "parent";
-        PerfEvent.ChildrenContextKey = "childEvts";
-        return PerfEvent;
-    }());
-    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);
-                    }
-                }
-                catch (ex) {
-                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
-                        perfEvt[_DYN_SET_CTX ]("exception", ex);
-                    }
-                }
-                finally {
-                    if (perfEvt) {
-                        perfMgr.fire(perfEvt);
-                    }
-                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
-                }
-            }
-        }
-        return func();
-    }
-
-    var pluginStateData = createElmNodeData("plugin");
-    function _getPluginState(plugin) {
-        return pluginStateData.get(plugin, "state", {}, true);
-    }
-
-    var strTelemetryPluginChain = "TelemetryPluginChain";
-    var strHasRunFlags = "_hasRun";
-    var strGetTelCtx = "_getTelCtx";
-    var _chainId = 0;
-    function _getNextProxyStart(proxy, core, startAt) {
-        while (proxy) {
-            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
-                return proxy;
-            }
-            proxy = proxy[_DYN_GET_NEXT ]();
-        }
-        return createTelemetryProxyChain([startAt], core.config || {}, core);
-    }
-    function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
-        var _nextProxy = null;
-        var _onComplete = [];
-        if (!dynamicHandler) {
-            dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
-        }
-        if (startAt !== null) {
-            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
-        }
-        var context = {
-            _next: _moveNext,
-            ctx: {
-                core: function () {
-                    return core;
-                },
-                diagLog: function () {
-                    return safeGetLogger(core, dynamicHandler.cfg);
-                },
-                getCfg: function () {
-                    return dynamicHandler.cfg;
-                },
-                getExtCfg: _resolveExtCfg,
-                getConfig: _getConfig,
-                hasNext: function () {
-                    return !!_nextProxy;
-                },
-                getNext: function () {
-                    return _nextProxy;
-                },
-                setNext: function (nextPlugin) {
-                    _nextProxy = nextPlugin;
-                },
-                iterate: _iterateChain,
-                onComplete: _addOnComplete
-            }
-        };
-        function _addOnComplete(onComplete, that) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
-            }
-            if (onComplete) {
-                _onComplete[_DYN_PUSH ]({
-                    func: onComplete,
-                    self: !isUndefined(that) ? that : context.ctx,
-                    args: args
-                });
-            }
-        }
-        function _moveNext() {
-            var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
-            if (!nextProxy) {
-                var onComplete = _onComplete;
-                if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
-                    arrForEach(onComplete, function (completeDetails) {
-                        try {
-                            completeDetails.func.call(completeDetails.self, completeDetails.args);
-                        }
-                        catch (e) {
-                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
-                        }
-                    });
-                    _onComplete = [];
-                }
-            }
-            return nextProxy;
-        }
-        function _getExtCfg(identifier, createIfMissing) {
-            var idCfg = null;
-            var cfg = dynamicHandler.cfg;
-            if (cfg && identifier) {
-                var extCfg = cfg[STR_EXTENSION_CONFIG ];
-                if (!extCfg && createIfMissing) {
-                    extCfg = {};
-                }
-                cfg[STR_EXTENSION_CONFIG] = extCfg;
-                extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
-                if (extCfg) {
-                    idCfg = extCfg[identifier];
-                    if (!idCfg && createIfMissing) {
-                        idCfg = {};
-                    }
-                    extCfg[identifier] = idCfg;
-                    idCfg = dynamicHandler.ref(extCfg, identifier);
-                }
-            }
-            return idCfg;
-        }
-        function _resolveExtCfg(identifier, defaultValues) {
-            var newConfig = _getExtCfg(identifier, true);
-            if (defaultValues) {
-                objForEachKey(defaultValues, function (field, defaultValue) {
-                    if (isNullOrUndefined(newConfig[field])) {
-                        var cfgValue = dynamicHandler.cfg[field];
-                        if (cfgValue || !isNullOrUndefined(cfgValue)) {
-                            newConfig[field] = cfgValue;
-                        }
-                    }
-                    _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
-                });
-            }
-            return dynamicHandler.setDf(newConfig, defaultValues);
-        }
-        function _getConfig(identifier, field, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = false; }
-            var theValue;
-            var extConfig = _getExtCfg(identifier, false);
-            var rootConfig = dynamicHandler.cfg;
-            if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
-                theValue = extConfig[field];
-            }
-            else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
-                theValue = rootConfig[field];
-            }
-            return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
-        }
-        function _iterateChain(cb) {
-            var nextPlugin;
-            while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
-                if (plugin) {
-                    cb(plugin);
-                }
-            }
-        }
-        return context;
-    }
-    function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
-        var config = createDynamicConfig(cfg);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(env) {
-            var nextPlugin = internalContext._next();
-            if (nextPlugin) {
-                nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
-            }
-            return !nextPlugin;
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
-        }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
-    }
-    function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core.config);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(unloadState) {
-            var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin[_DYN_UNLOAD ](context, unloadState);
-            return !nextPlugin;
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
-        }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
-    }
-    function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = createDynamicConfig(core.config);
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(updateState) {
-            return context.iterate(function (plugin) {
-                if (isFunction(plugin[_DYN_UPDATE ])) {
-                    plugin[_DYN_UPDATE ](context, updateState);
-                }
-            });
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
-            }
-            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
-        }
-        context[_DYN_PROCESS_NEXT ] = _processNext;
-        context[_DYN_CREATE_NEW ] = _createNew;
-        return context;
-    }
-    function createTelemetryProxyChain(plugins, config, core, startAt) {
-        var firstProxy = null;
-        var add = startAt ? false : true;
-        if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
-            var lastProxy_1 = null;
-            arrForEach(plugins, function (thePlugin) {
-                if (!add && startAt === thePlugin) {
-                    add = true;
-                }
-                if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
-                    var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
-                    if (!firstProxy) {
-                        firstProxy = newProxy;
-                    }
-                    if (lastProxy_1) {
-                        lastProxy_1._setNext(newProxy);
-                    }
-                    lastProxy_1 = newProxy;
-                }
-            });
-        }
-        if (startAt && !firstProxy) {
-            return createTelemetryProxyChain([startAt], config, core);
-        }
-        return firstProxy;
-    }
-    function createTelemetryPluginProxy(plugin, config, core) {
-        var nextProxy = null;
-        var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
-        var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
-        var chainId;
-        if (plugin) {
-            chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
-        }
-        else {
-            chainId = "Unknown-0-" + _chainId++;
-        }
-        var proxyChain = {
-            getPlugin: function () {
-                return plugin;
-            },
-            getNext: function () {
-                return nextProxy;
-            },
-            processTelemetry: _processTelemetry,
-            unload: _unloadPlugin,
-            update: _updatePlugin,
-            _id: chainId,
-            _setNext: function (nextPlugin) {
-                nextProxy = nextPlugin;
-            }
-        };
-        function _getTelCtx() {
-            var itemCtx;
-            if (plugin && isFunction(plugin[strGetTelCtx])) {
-                itemCtx = plugin[strGetTelCtx]();
-            }
-            if (!itemCtx) {
-                itemCtx = createProcessTelemetryContext(proxyChain, config, core);
-            }
-            return itemCtx;
-        }
-        function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
-            var hasRun = false;
-            var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
-            var hasRunContext = itemCtx[strHasRunFlags];
-            if (!hasRunContext) {
-                hasRunContext = itemCtx[strHasRunFlags] = {};
-            }
-            itemCtx.setNext(nextProxy);
-            if (plugin) {
-                doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
-                    hasRunContext[chainId] = true;
-                    try {
-                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
-                        if (nextId) {
-                            hasRunContext[nextId] = false;
-                        }
-                        hasRun = processPluginFn(itemCtx);
-                    }
-                    catch (error) {
-                        var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
-                        if (hasNextRun) {
-                            hasRun = true;
-                        }
-                        if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
-                        }
-                    }
-                }, details, isAsync);
-            }
-            return hasRun;
-        }
-        function _processTelemetry(env, itemCtx) {
-            itemCtx = itemCtx || _getTelCtx();
-            function _callProcessTelemetry(itemCtx) {
-                if (!plugin || !hasProcessTelemetry) {
-                    return false;
-                }
-                var pluginState = _getPluginState(plugin);
-                if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
-                    return false;
-                }
-                if (hasSetNext) {
-                    plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
-                }
-                plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
-                return true;
-            }
-            if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function () { return ({ item: env }); }, !(env.sync))) {
-                itemCtx[_DYN_PROCESS_NEXT ](env);
-            }
-        }
-        function _unloadPlugin(unloadCtx, unloadState) {
-            function _callTeardown() {
-                var hasRun = false;
-                if (plugin) {
-                    var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
-                    if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
-                        pluginState[STR_CORE ] = null;
-                        pluginState[_DYN_TEARDOWN ] = true;
-                        pluginState[_DYN_IS_INITIALIZED ] = false;
-                        if (plugin[_DYN_TEARDOWN ] && plugin[_DYN_TEARDOWN ](unloadCtx, unloadState) === true) {
-                            hasRun = true;
-                        }
-                    }
-                }
-                return hasRun;
-            }
-            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState.isAsync)) {
-                unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
-            }
-        }
-        function _updatePlugin(updateCtx, updateState) {
-            function _callUpdate() {
-                var hasRun = false;
-                if (plugin) {
-                    var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
-                    if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
-                        if (plugin[_DYN_UPDATE ] && plugin[_DYN_UPDATE ](updateCtx, updateState) === true) {
-                            hasRun = true;
-                        }
-                    }
-                }
-                return hasRun;
-            }
-            if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
-                updateCtx[_DYN_PROCESS_NEXT ](updateState);
-            }
-        }
-        return objFreeze(proxyChain);
-    }
-
-    function createUnloadHandlerContainer() {
-        var handlers = [];
-        function _addHandler(handler) {
-            if (handler) {
-                handlers[_DYN_PUSH ](handler);
-            }
-        }
-        function _runHandlers(unloadCtx, unloadState) {
-            arrForEach(handlers, function (handler) {
-                try {
-                    handler(unloadCtx, unloadState);
-                }
-                catch (e) {
-                    _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
-                }
-            });
-            handlers = [];
-        }
-        return {
-            add: _addHandler,
-            run: _runHandlers
-        };
-    }
-
-    function createUnloadHookContainer() {
-        var _hooks = [];
-        function _doUnload(logger) {
-            var oldHooks = _hooks;
-            _hooks = [];
-            arrForEach(oldHooks, function (fn) {
-                try {
-                    (fn.rm || fn.remove).call(fn);
-                }
-                catch (e) {
-                    _throwInternal(logger, 2 , 73 , "Unloading:" + dumpObj(e));
-                }
-            });
-        }
-        function _addHook(hooks) {
-            if (hooks) {
-                arrAppend(_hooks, hooks);
-            }
-        }
-        return {
-            run: _doUnload,
-            add: _addHook
-        };
-    }
-
-    var _a;
-    var strGetPlugin = "getPlugin";
-    var defaultValues = (_a = {},
-        _a[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} },
-        _a);
-    var BaseTelemetryPlugin = /** @class */ (function () {
-        function BaseTelemetryPlugin() {
-            var _self = this;
-            var _isinitialized;
-            var _rootCtx;
-            var _nextPlugin;
-            var _unloadHandlerContainer;
-            var _hookContainer;
-            _initDefaults();
-            dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-                _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
-                    _setDefaults(config, core, pluginChain);
-                    _isinitialized = true;
-                };
-                _self[_DYN_TEARDOWN ] = function (unloadCtx, unloadState) {
-                    var core = _self[STR_CORE ];
-                    if (!core || (unloadCtx && core !== unloadCtx[STR_CORE ]())) {
-                        return;
-                    }
-                    var result;
-                    var unloadDone = false;
-                    var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
-                    var theUnloadState = unloadState || {
-                        reason: 0 ,
-                        isAsync: false
-                    };
-                    function _unloadCallback() {
-                        if (!unloadDone) {
-                            unloadDone = true;
-                            _unloadHandlerContainer.run(theUnloadCtx, unloadState);
-                            _hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG ]());
-                            if (result === true) {
-                                theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
-                            }
-                            _initDefaults();
-                        }
-                    }
-                    if (!_self[_DYN__DO_TEARDOWN ] || _self[_DYN__DO_TEARDOWN ](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
-                        _unloadCallback();
-                    }
-                    else {
-                        result = true;
-                    }
-                    return result;
-                };
-                _self[_DYN_UPDATE ] = function (updateCtx, updateState) {
-                    var core = _self[STR_CORE ];
-                    if (!core || (updateCtx && core !== updateCtx[STR_CORE ]())) {
-                        return;
-                    }
-                    var result;
-                    var updateDone = false;
-                    var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
-                    var theUpdateState = updateState || {
-                        reason: 0
-                    };
-                    function _updateCallback() {
-                        if (!updateDone) {
-                            updateDone = true;
-                            _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT ]());
-                        }
-                    }
-                    if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
-                        _updateCallback();
-                    }
-                    else {
-                        result = true;
-                    }
-                    return result;
-                };
-                proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
-                proxyFunctionAs(_self, "_addHook", function () { return _hookContainer; }, "add");
-                objDefine(_self, "_unloadHooks", { g: function () { return _hookContainer; } });
-            });
-            _self[_DYN_DIAG_LOG ] = function (itemCtx) {
-                return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
-            };
-            _self[_DYN_IS_INITIALIZED ] = function () {
-                return _isinitialized;
-            };
-            _self.setInitialized = function (isInitialized) {
-                _isinitialized = isInitialized;
-            };
-            _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
-                _nextPlugin = next;
-            };
-            _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
-                if (itemCtx) {
-                    itemCtx[_DYN_PROCESS_NEXT ](env);
-                }
-                else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
-                    _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
-                }
-            };
-            _self._getTelCtx = _getTelCtx;
-            function _getTelCtx(currentCtx) {
-                if (currentCtx === void 0) { currentCtx = null; }
-                var itemCtx = currentCtx;
-                if (!itemCtx) {
-                    var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
-                    if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
-                    }
-                    else {
-                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
-                    }
-                }
-                return itemCtx;
-            }
-            function _setDefaults(config, core, pluginChain) {
-                createDynamicConfig(config, defaultValues, safeGetLogger(core));
-                if (!pluginChain && core) {
-                    pluginChain = core[_DYN_GET_PROCESS_TEL_CONT2 ]()[_DYN_GET_NEXT ]();
-                }
-                var nextPlugin = _nextPlugin;
-                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                    nextPlugin = _nextPlugin[strGetPlugin]();
-                }
-                _self[STR_CORE ] = core;
-                _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
-            }
-            function _initDefaults() {
-                _isinitialized = false;
-                _self[STR_CORE ] = null;
-                _rootCtx = null;
-                _nextPlugin = null;
-                _hookContainer = createUnloadHookContainer();
-                _unloadHandlerContainer = createUnloadHandlerContainer();
-            }
-        }
-        BaseTelemetryPlugin.__ieDyn=1;
-        return BaseTelemetryPlugin;
-    }());
-
-    var SeverityLevel = createEnumStyle({
-        Verbose: 0 ,
-        Information: 1 ,
-        Warning: 2 ,
-        Error: 3 ,
-        Critical: 4
-    });
-
-    var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
-    var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
-
-    var defaultReactExtensionConfig = objDeepFreeze({
-        history: { blkVal: true, v: undefined }
-    });
-    var ReactPlugin = /** @class */ (function (_super) {
-        __extendsFn(ReactPlugin, _super);
-        function ReactPlugin() {
-            var _this = _super.call(this) || this;
-            _this.priority = 185;
-            _this.identifier = 'ReactPlugin';
-            var _analyticsPlugin;
-            var _extensionConfig;
-            var _unlisten;
-            var _pageViewTimer;
-            var _pageViewTracked;
-            var properties;
-            dynamicProto(ReactPlugin, _this, function (_self, _base) {
-                _initDefaults();
-                _self.initialize = function (config, core, extensions, pluginChain) {
-                    _super.prototype.initialize.call(_this, config, core, extensions, pluginChain);
-                    var thePlugin = core.getPlugin(PropertiesPluginIdentifier);
-                    if (thePlugin) {
-                        properties = thePlugin.plugin;
-                    }
-                    objDefine(_self, "context", {
-                        g: function () { return properties ? properties.context : null; }
-                    });
-                    _self._addHook(onConfigChange(config, function (details) {
-                        var _a;
-                        var ctx = _self._getTelCtx();
-                        _extensionConfig = ctx.getExtCfg(_this.identifier, defaultReactExtensionConfig);
-                        _analyticsPlugin = (_a = core.getPlugin(AnalyticsPluginIdentifier)) === null || _a === void 0 ? void 0 : _a.plugin;
-                        if (isFunction(_unlisten)) {
-                            _unlisten();
-                            _unlisten = null;
-                        }
-                        if (_extensionConfig.history) {
-                            _addHistoryListener(_extensionConfig.history);
-                            if (!_pageViewTracked) {
-                                var pageViewTelemetry = {
-                                    uri: _extensionConfig.history.location.pathname
-                                };
-                                _self.trackPageView(pageViewTelemetry);
-                                _pageViewTracked = true;
-                            }
-                        }
-                    }));
-                };
-                _self.getCookieMgr = function () {
-                    return safeGetCookieMgr(_self.core);
-                };
-                _self.getAppInsights = _getAnalytics;
-                _self.processTelemetry = function (event, itemCtx) {
-                    _self.processNext(event, itemCtx);
-                };
-                _self._doTeardown = function (unloadCtx, unloadState, asyncCallback) {
-                    if (isFunction(_unlisten)) {
-                        _unlisten();
-                    }
-                    if (_pageViewTimer) {
-                        clearTimeout(_pageViewTimer);
-                    }
-                    _initDefaults();
-                };
-                proxyFunctions(_self, _getAnalytics, [
-                    "trackMetric",
-                    "trackPageView",
-                    "trackEvent",
-                    "trackException",
-                    "trackTrace",
-                ]);
-                function _initDefaults() {
-                    _analyticsPlugin = null;
-                    _extensionConfig = null;
-                    _unlisten = null;
-                    _pageViewTimer = null;
-                    _pageViewTracked = false;
-                    properties = null;
-                }
-                function _getAnalytics() {
-                    if (!_analyticsPlugin) {
-                        _throwInternal(_self.diagLog(), 1 , 64 , "Analytics plugin is not available, React plugin telemetry will not be sent: ");
-                    }
-                    return _analyticsPlugin;
-                }
-                function _addHistoryListener(history) {
-                    var locationListener = function (arg) {
-                        var locn = null;
-                        if ("location" in arg) {
-                            locn = arg["location"];
-                        }
-                        else {
-                            locn = arg;
-                        }
-                        _pageViewTimer = setTimeout(function () {
-                            _pageViewTimer = null;
-                            var pageViewTelemetry = { uri: locn.pathname };
-                            _self.trackPageView(pageViewTelemetry);
-                        }, 500);
-                    };
-                    _unlisten = history.listen(locationListener);
-                }
-                objDefineAccessors(_self, "_extensionConfig", function () { return _extensionConfig; });
-            });
-            return _this;
-        }
-        ReactPlugin.__ieDyn=1;
-        return ReactPlugin;
-    }(BaseTelemetryPlugin));
-    var ReactPlugin$1 = ReactPlugin;
-
-    var AITrackedComponentBase = /** @class */ (function (_super) {
-        __extendsFn(AITrackedComponentBase, _super);
-        function AITrackedComponentBase(props, reactPlugin, componentName) {
-            var _this = _super.call(this, props) || this;
-            _this._mountTimestamp = 0;
-            _this._firstActiveTimestamp = 0;
-            _this._idleStartTimestamp = 0;
-            _this._lastActiveTimestamp = 0;
-            _this._totalIdleTime = 0;
-            _this._idleCount = 0;
-            _this._idleTimeout = 5000;
-            _this.trackActivity = function (e) {
-                if (_this._firstActiveTimestamp === 0) {
-                    _this._firstActiveTimestamp = utcNow();
-                    _this._lastActiveTimestamp = _this._firstActiveTimestamp;
-                }
-                else {
-                    _this._lastActiveTimestamp = utcNow();
-                }
-                if (_this._idleStartTimestamp > 0) {
-                    var lastIdleTime = _this._lastActiveTimestamp - _this._idleStartTimestamp;
-                    _this._totalIdleTime += lastIdleTime;
-                    _this._idleStartTimestamp = 0;
-                }
-            };
-            _this._reactPlugin = reactPlugin;
-            _this._componentName = componentName;
-            return _this;
-        }
-        AITrackedComponentBase.prototype.componentDidMount = function () {
-            var _this = this;
-            this._mountTimestamp = utcNow();
-            this._firstActiveTimestamp = 0;
-            this._totalIdleTime = 0;
-            this._lastActiveTimestamp = 0;
-            this._idleStartTimestamp = 0;
-            this._idleCount = 0;
-            this._intervalId = setInterval(function () {
-                if (_this._lastActiveTimestamp > 0 && _this._idleStartTimestamp === 0 && utcNow() - _this._lastActiveTimestamp >= _this._idleTimeout) {
-                    _this._idleStartTimestamp = utcNow();
-                    _this._idleCount++;
-                }
-            }, 100);
-        };
-        AITrackedComponentBase.prototype.componentWillUnmount = function () {
-            if (this._mountTimestamp === 0) {
-                throw new Error('withAITracking:componentWillUnmount: mountTimestamp is not initialized.');
-            }
-            if (this._intervalId) {
-                clearInterval(this._intervalId);
-            }
-            if (this._firstActiveTimestamp === 0) {
-                return;
-            }
-            var engagementTime = this.getEngagementTimeSeconds();
-            var metricData = {
-                average: engagementTime,
-                name: 'React Component Engaged Time (seconds)',
-                sampleCount: 1
-            };
-            var additionalProperties = { 'Component Name': this._componentName };
-            this._reactPlugin.trackMetric(metricData, additionalProperties);
-        };
-        AITrackedComponentBase.prototype.getEngagementTimeSeconds = function () {
-            return (utcNow() - this._firstActiveTimestamp - this._totalIdleTime - this._idleCount * this._idleTimeout) / 1000;
-        };
-        return AITrackedComponentBase;
-    }(React__namespace.Component));
-    function withAITracking(reactPlugin, Component, componentName, className) {
-        if (componentName === undefined || componentName === null || typeof componentName !== 'string') {
-            componentName = Component.prototype &&
-                Component.prototype.constructor &&
-                Component.prototype.constructor.name ||
-                'Unknown';
-        }
-        if (className === undefined || className === null || typeof className !== 'string') {
-            className = '';
-        }
-        return /** @class */ (function (_super) {
-            __extendsFn(class_1, _super);
-            function class_1(props) {
-                return _super.call(this, props, reactPlugin, componentName) || this;
-            }
-            class_1.prototype.render = function () {
-                return (React__namespace.createElement("div", { onKeyDown: this.trackActivity, onMouseMove: this.trackActivity, onScroll: this.trackActivity, onMouseDown: this.trackActivity, onTouchStart: this.trackActivity, onTouchMove: this.trackActivity, className: className },
-                    React__namespace.createElement(Component, __assignFn({}, this.props))));
-            };
-            return class_1;
-        }(AITrackedComponentBase));
-    }
-
-    var AppInsightsErrorBoundary = /** @class */ (function (_super) {
-        __extendsFn(AppInsightsErrorBoundary, _super);
-        function AppInsightsErrorBoundary() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.state = { hasError: false };
-            return _this;
-        }
-        AppInsightsErrorBoundary.prototype.componentDidCatch = function (error, errorInfo) {
-            this.setState({ hasError: true });
-            this.props.appInsights.trackException({
-                error: error,
-                exception: error,
-                severityLevel: SeverityLevel.Error,
-                properties: errorInfo
-            });
-        };
-        AppInsightsErrorBoundary.prototype.render = function () {
-            if (this.state.hasError) {
-                var onError = this.props.onError;
-                return React__default["default"].createElement(onError);
-            }
-            return this.props.children;
-        };
-        return AppInsightsErrorBoundary;
-    }(React__default["default"].Component));
-    var AppInsightsErrorBoundary$1 = AppInsightsErrorBoundary;
-
-    var AppInsightsContext = React.createContext(undefined);
-    var useAppInsightsContext = function () { return React.useContext(AppInsightsContext); };
-
-    function useCustomEvent(reactPlugin, eventName, eventData, skipFirstRun) {
-        if (skipFirstRun === void 0) { skipFirstRun = true; }
-        var _a = React.useState(eventData), data = _a[0], setData = _a[1];
-        var firstRun = React.useRef(skipFirstRun);
-        var savedSkipFirstRun = React.useRef(skipFirstRun);
-        React.useEffect(function () {
-            if (firstRun.current) {
-                firstRun.current = false;
-                return;
-            }
-            reactPlugin.trackEvent({ name: eventName }, data);
-        }, [reactPlugin, data, eventName]);
-        React.useEffect(function () {
-            return function () {
-                firstRun.current = savedSkipFirstRun.current;
-            };
-        }, []);
-        return setData;
-    }
-
-    function getEngagementTimeSeconds(trackedData) {
-        return ((utcNow() -
-            trackedData.firstActiveTimestamp -
-            trackedData.totalIdleTime -
-            trackedData.idleCount * trackedData.idleTimeout) /
-            1000);
-    }
-    var useComponentTracking = function (reactPlugin, componentName, customProperties) {
-        var tracking = React.useRef({
-            hookTimestamp: utcNow(),
-            firstActiveTimestamp: 0,
-            totalIdleTime: 0,
-            lastActiveTimestamp: 0,
-            idleStartTimestamp: 0,
-            idleCount: 0,
-            idleTimeout: 5000
-        });
-        var savedCallback = React.useRef(null);
-        var callback = function () {
-            var trackedData = tracking.current;
-            if (trackedData.lastActiveTimestamp > 0 &&
-                trackedData.idleStartTimestamp === 0 &&
-                utcNow() - trackedData.lastActiveTimestamp >= trackedData.idleTimeout) {
-                trackedData.idleStartTimestamp = utcNow();
-                trackedData.idleCount++;
-            }
-        };
-        var delay = 100;
-        savedCallback.current = callback;
-        React.useEffect(function () {
-            var id = setInterval(savedCallback.current, delay);
-            return function () {
-                clearInterval(id);
-                var trackedData = tracking.current;
-                if (trackedData.hookTimestamp === 0) {
-                    throw new Error("useAppInsights:unload hook: hookTimestamp is not initialized.");
-                }
-                if (trackedData.firstActiveTimestamp === 0) {
-                    return;
-                }
-                var engagementTime = getEngagementTimeSeconds(trackedData);
-                var metricData = {
-                    average: engagementTime,
-                    name: "React Component Engaged Time (seconds)",
-                    sampleCount: 1
-                };
-                var additionalProperties = __assignFn({ "Component Name": componentName }, customProperties);
-                reactPlugin.trackMetric(metricData, additionalProperties);
-            };
-        }, []);
-        var trackActivity = function () {
-            var trackedData = tracking.current;
-            if (trackedData.firstActiveTimestamp === 0) {
-                trackedData.firstActiveTimestamp = utcNow();
-                trackedData.lastActiveTimestamp = trackedData.firstActiveTimestamp;
-            }
-            else {
-                trackedData.lastActiveTimestamp = utcNow();
-            }
-            if (trackedData.idleStartTimestamp > 0) {
-                var lastIdleTime = trackedData.lastActiveTimestamp - trackedData.idleStartTimestamp;
-                trackedData.totalIdleTime += lastIdleTime;
-                trackedData.idleStartTimestamp = 0;
-            }
-        };
-        return trackActivity;
-    };
-    var useComponentTracking$1 = useComponentTracking;
-
-    exports.AITrackedComponentBase = AITrackedComponentBase;
-    exports.AppInsightsContext = AppInsightsContext;
-    exports.AppInsightsErrorBoundary = AppInsightsErrorBoundary$1;
-    exports.ReactPlugin = ReactPlugin$1;
-    exports.useAppInsightsContext = useAppInsightsContext;
-    exports.useTrackEvent = useCustomEvent;
-    exports.useTrackMetric = useComponentTracking$1;
-    exports.withAITracking = withAITracking;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=applicationinsights-react-js.js.map