@microsoft/applicationinsights-teechannel-js 3.0.2-nightly3.2305-03 → 3.0.2-nightly3.2305-04

package/browser/es5/applicationinsights-teechannel-js.3.0.2-nightly3.2305-04.gbl.js

@@ -0,0 +1,3241 @@
+/*!
+ * Application Insights JavaScript SDK - Tee Channel, 3.0.2-nightly3.2305-04
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+(function (global, factory) {
+    var undef = "undefined";
+    var nsKey, key, nm, theExports = {}, modName = "es5_applicationinsights_teechannel_js_3_0_2_nightly3_2305_04", msMod="__ms$mod__";
+    var mods={}, modDetail=mods[modName]={}, ver="3.0.2-nightly3.2305-04";
+    var baseNs=global, nsKey="Microsoft", baseNs=baseNs[nsKey]=(baseNs[nsKey]||{});
+    // Versioned namespace "Microsoft.ApplicationInsights3"
+    var exportNs=baseNs, nsKey="ApplicationInsights3", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
+    // Global namespace "Microsoft.ApplicationInsights"
+    var destNs=baseNs, nsKey="ApplicationInsights", destNs=destNs[nsKey]=(destNs[nsKey]||{});
+    var expNsDetail=(exportNs[msMod]=(exportNs[msMod] || {})), expNameVer=(expNsDetail["v"]=(expNsDetail["v"] || []));
+    var destNsDetail=(destNs[msMod]=(destNs[msMod] || {})), destNameVer=(destNsDetail["v"]=(destNsDetail["v"] || []));
+    (destNsDetail["o"]=(destNsDetail["o"] || [])).push(mods);
+    factory(theExports);
+    for(var key in theExports) {
+        // Always set the imported value into the "export" versioned namespace (last-write wins)
+        nm="x", exportNs[key]=theExports[key], expNameVer[key]=ver;
+        // Copy over any named element that is not already present (first-write wins)
+        typeof destNs[key]===undef ? (nm="n", destNs[key]=theExports[key]) && (destNameVer[key]=ver) : !destNameVer[key] && (destNameVer[key]="---");
+        (modDetail[nm] = (modDetail[nm] || [])).push(key);
+    }
+})(this, (function (exports) {
+'use strict';
+
+
+var strShimFunction = "function";
+var strShimObject = "object";
+var strShimUndefined = "undefined";
+var strShimPrototype = "prototype";
+var ObjClass$1 = Object;
+
+var UNDEF_VALUE = undefined;
+var EMPTY = "";
+var BOOLEAN = "boolean";
+var FUNCTION = "function";
+var NUMBER = "number";
+var OBJECT = "object";
+var PROTOTYPE = "prototype";
+var STRING = "string";
+var UNDEFINED = "undefined";
+var CONSTRUCTOR = "constructor";
+var SYMBOL = "Symbol";
+var POLYFILL_TAG = "_polyfill";
+var INDEX_OF = "indexOf";
+var LENGTH = "length";
+var DONE = "done";
+var VALUE = "value";
+var NAME = "name";
+var SLICE = "slice";
+var ObjClass = Object;
+var ObjProto = ObjClass[PROTOTYPE];
+var StrCls = String;
+var StrProto = StrCls[PROTOTYPE];
+var ArrCls = Array;
+var ArrProto = ArrCls[PROTOTYPE];
+
+function safeGet(cb, defValue) {
+    var result = defValue;
+    try {
+        result = cb();
+    }
+    catch (e) {
+    }
+    return result;
+}
+
+function _createIs(theType) {
+    return function (value) {
+        return typeof value === theType;
+    };
+}
+function _createObjIs(theName) {
+    var theType = "[object " + theName + "]";
+    return function (value) {
+        return !!(value && objToString(value) === theType);
+    };
+}
+function objToString(value) {
+    return ObjProto.toString.call(value);
+}
+function isUndefined(value) {
+    return typeof value === UNDEFINED || value === UNDEFINED;
+}
+function isNullOrUndefined(value) {
+    return value === null || isUndefined(value);
+}
+function isStrictNullOrUndefined(value) {
+    return value === null || !isDefined(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 = ArrCls.isArray;
+var isNumber = _createIs(NUMBER);
+var isBoolean = _createIs(BOOLEAN);
+var isError = _createObjIs("Error");
+function isPromiseLike(value) {
+    return !!value && isFunction(value.then);
+}
+
+var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
+
+function objHasOwnProperty(obj, prop) {
+    return obj && ObjProto.hasOwnProperty.call(obj, prop);
+}
+
+var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
+function polyObjHasOwn(obj, prop) {
+    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+}
+
+function objForEachKey(theObject, callbackfn, thisArg) {
+    if (theObject && isObject(theObject)) {
+        for (var prop in theObject) {
+            if (objHasOwn(theObject, prop)) {
+                if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+function _createKeyValueMap(values, keyType, valueType, completeFn) {
+    var theMap = {};
+    objForEachKey(values, function (key, value) {
+        theMap[key] = keyType ? value : key;
+        theMap[value] = valueType ? value : key;
+    });
+    return completeFn(theMap);
+}
+
+function throwError(message) {
+    throw new Error(message);
+}
+function throwTypeError(message) {
+    throw new TypeError(message);
+}
+
+var _objFreeze = ObjClass["freeze"];
+var _doNothing = function (value) { return value; };
+function objDeepFreeze(value) {
+    if (_objFreeze) {
+        objForEachKey(value, function (key, value) {
+            if (isArray(value) || isObject(value)) {
+                _objFreeze(value);
+            }
+        });
+    }
+    return objFreeze(value);
+}
+var objFreeze = _objFreeze || _doNothing;
+var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _doNothing;
+
+function createEnumKeyMap(values) {
+    return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+}
+
+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 asString = StrCls;
+
+var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+var _globalCfg;
+function _getGlobalValue() {
+    var result;
+    if (typeof globalThis !== UNDEFINED) {
+        result = globalThis;
+    }
+    if (!result && typeof self !== UNDEFINED) {
+        result = self;
+    }
+    if (!result && typeof window !== UNDEFINED) {
+        result = window;
+    }
+    if (!result && typeof global !== UNDEFINED) {
+        result = global;
+    }
+    return result;
+}
+function _getGlobalConfig() {
+    if (!_globalCfg) {
+        var gbl = _getGlobalValue() || {};
+        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+    }
+    return _globalCfg;
+}
+
+function dumpObj(object, format) {
+    var propertyValueDump = EMPTY;
+    if (isError(object)) {
+        propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+    }
+    else {
+        try {
+            propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+        }
+        catch (e) {
+            propertyValueDump = " - " + dumpObj(e, format);
+        }
+    }
+    return objToString(object) + ": " + propertyValueDump;
+}
+
+function _unwrapFunction(funcName, target, polyFunc) {
+    return function (thisArg) {
+        var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
+        if (theFunc || polyFunc) {
+            var theArgs = arguments;
+            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
+        }
+        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+    };
+}
+
+var _polySymbols;
+function _globalSymbolRegistry() {
+    if (!_polySymbols) {
+        var gblCfg = _getGlobalConfig();
+        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
+    }
+    return _polySymbols;
+}
+var _wellKnownSymbolCache = {};
+function polyNewSymbol(description) {
+    var theSymbol = {
+        description: asString(description),
+        toString: function () { return SYMBOL + "(" + description + ")"; }
+    };
+    theSymbol[POLYFILL_TAG] = true;
+    return theSymbol;
+}
+function polySymbolFor(key) {
+    var registry = _globalSymbolRegistry();
+    if (!objHasOwn(registry, key)) {
+        var newSymbol = polyNewSymbol(key);
+        registry.k[key] = newSymbol;
+        registry.s[newSymbol] = asString(key);
+    }
+    return registry.k[key];
+}
+function polyGetKnownSymbol(name) {
+    var result;
+    var knownName = _wellKnownSymbolMap[name];
+    if (knownName) {
+        result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+    }
+    return result;
+}
+
+var propMap = {
+    e: "enumerable",
+    c: "configurable",
+    v: VALUE,
+    w: "writable",
+    g: "get",
+    s: "set"
+};
+function _createProp(value) {
+    var prop = {};
+    prop[propMap["c"]] = true;
+    prop[propMap["e"]] = true;
+    if (value.l) {
+        prop.get = function () { return value.l.v; };
+        var desc = objGetOwnPropertyDescriptor(value.l, "v");
+        if (desc && desc.set) {
+            prop.set = function (newValue) {
+                value.l.v = newValue;
+            };
+        }
+    }
+    objForEachKey(value, function (key, value) {
+        prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+    });
+    return prop;
+}
+var objDefineProp = ObjClass["defineProperty"];
+function objDefine(target, key, propDesc) {
+    return objDefineProp(target, key, _createProp(propDesc));
+}
+
+var _globalLazyTestHooks;
+var _fetchLazyTestHooks = function () {
+    _globalLazyTestHooks = _getGlobalConfig();
+    _fetchLazyTestHooks = null;
+};
+function getLazy(cb) {
+    var lazyValue = {};
+    _fetchLazyTestHooks && _fetchLazyTestHooks();
+    lazyValue.b = _globalLazyTestHooks.lzy;
+    objDefineProp(lazyValue, "v", {
+        configurable: true,
+        get: function () {
+            var result = cb();
+            if (!_globalLazyTestHooks.lzy) {
+                objDefineProp(lazyValue, "v", {
+                    value: result
+                });
+                if (lazyValue.b) {
+                    delete lazyValue.b;
+                }
+            }
+            if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                lazyValue.b = _globalLazyTestHooks.lzy;
+            }
+            return result;
+        }
+    });
+    return lazyValue;
+}
+
+function safeGetLazy(cb, defValue) {
+    return getLazy(function () { return safeGet(cb, defValue); });
+}
+
+var WINDOW = "window";
+var _cachedGlobal;
+var _cachedWindow;
+var _cachedDocument;
+var _cachedNavigator;
+var _isNode;
+function lazySafeGetInst(name) {
+    return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+}
+function getGlobal(useCached) {
+    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
+    return _cachedGlobal.v;
+}
+function getInst(name, useCached) {
+    var gbl = getGlobal(useCached);
+    if (gbl && gbl[name]) {
+        return gbl[name];
+    }
+    if (name === WINDOW && _cachedWindow) {
+        return _cachedWindow.v;
+    }
+    return null;
+}
+function getDocument() {
+    (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
+    return _cachedDocument.v;
+}
+function hasWindow() {
+    return !!getWindow();
+}
+function getWindow() {
+    (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
+    return _cachedWindow.v;
+}
+function getNavigator() {
+    (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
+    return _cachedNavigator.v;
+}
+function isNode() {
+    !_isNode && (_isNode = safeGetLazy(function () { return !!(process && (process.versions || {}).node); }, false));
+    return _isNode.v;
+}
+
+var _symbol;
+var _symbolFor;
+var _symbolKeyFor;
+function _getSymbolValue(name) {
+    return safeGetLazy(function () {
+        return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+    }, UNDEF_VALUE);
+}
+function hasSymbol() {
+    return !!getSymbol();
+}
+function getSymbol() {
+    var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
+    resetCache && (_symbol = lazySafeGetInst(SYMBOL));
+    (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
+    (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
+    return _symbol.v;
+}
+function getKnownSymbol(name, noPoly) {
+    var knownName = _wellKnownSymbolMap[name];
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+}
+function newSymbol(description, noPoly) {
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+}
+function symbolFor(key) {
+    (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return (_symbolFor.v || polySymbolFor)(key);
+}
+
+function isIterator(value) {
+    return !!value && isFunction(value.next);
+}
+function isIterable(value) {
+    return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
+}
+
+function iterForOf(iter, callbackfn, thisArg) {
+    if (iter) {
+        if (!isIterator(iter)) {
+            var itSymbol = getKnownSymbol(3 );
+            iter = iter[itSymbol] ? iter[itSymbol]() : null;
+        }
+        if (isIterator(iter)) {
+            try {
+                var count = 0;
+                var value = iter.next();
+                while (!value[DONE]) {
+                    if (callbackfn.call(thisArg || iter, value[VALUE], count, iter) === -1) {
+                        break;
+                    }
+                    count++;
+                    value = iter.next();
+                }
+                iter.return && iter.return(value);
+            }
+            catch (e) {
+                iter.throw && iter.throw(e);
+            }
+        }
+    }
+}
+
+function arrAppend(target, elms) {
+    if (!isUndefined(elms) && target) {
+        if (isArray(elms)) {
+            target.push.apply(target, elms);
+        }
+        else if (isIterator(elms) || isIterable(elms)) {
+            iterForOf(elms, function (elm) {
+                target.push(elm);
+            });
+        }
+        else {
+            target.push(elms);
+        }
+    }
+    return target;
+}
+
+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 arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+
+var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+function objSetPrototypeOf(obj, proto) {
+    var fn = ObjClass["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            objForEachKey(b, function (key, value) { return d[key] = value; });
+        };
+    return fn(obj, proto);
+}
+
+function _createCustomError(name, d, baseClass) {
+    objSetPrototypeOf(d, baseClass);
+    function __() {
+        this.constructor = d;
+        this[NAME] = name;
+    }
+    __[PROTOTYPE] = baseClass[PROTOTYPE];
+    d[PROTOTYPE] = new __();
+    return d;
+}
+var _safeSetName = function (baseClass, name) {
+    try {
+        baseClass[PROTOTYPE][NAME] = name;
+    }
+    catch (e) {
+    }
+};
+function createCustomError(name, constructCb) {
+    var baseClass = Error;
+    var orgName = baseClass[PROTOTYPE][NAME];
+    var customError = _createCustomError(name, function () {
+        var _this = this;
+        try {
+            _safeSetName(baseClass, name);
+            _this = baseClass.apply(_this, arguments) || _this;
+            _this[NAME] = name;
+            constructCb && constructCb(_this, arguments);
+        }
+        finally {
+            _safeSetName(baseClass, orgName);
+        }
+        return _this;
+    }, baseClass);
+    return customError;
+}
+
+function utcNow() {
+    return (Date.now || polyUtcNow)();
+}
+function polyUtcNow() {
+    return new Date().getTime();
+}
+
+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].toString;
+            _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;
+}
+
+var _objCreate = ObjClass["create"];
+var objCreate = _objCreate || polyObjCreate;
+function polyObjCreate(obj) {
+    if (!obj) {
+        return {};
+    }
+    var type = typeof obj;
+    if (type !== OBJECT && type !== FUNCTION) {
+        throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+    }
+    function tempFunc() { }
+    tempFunc[PROTOTYPE] = obj;
+    return new tempFunc();
+}
+
+var strIndexOf = _unwrapFunction(INDEX_OF, StrProto);
+
+var REF = "ref";
+var UNREF = "un" + REF;
+var HAS_REF = "hasRef";
+var ENABLED = "enabled";
+function _createTimerHandler(startTimer, refreshFn, cancelFn) {
+    var _a;
+    var ref = true;
+    var timerId = startTimer ? refreshFn(null) : null;
+    var theTimerHandler;
+    var _unref = function () {
+        ref = false;
+        timerId && timerId[UNREF] && timerId[UNREF]();
+        return theTimerHandler;
+    };
+    var _ref = function () {
+        ref = true;
+        timerId && timerId[REF] && timerId[REF]();
+        return theTimerHandler;
+    };
+    var _hasRef = function () {
+        if (timerId && timerId[HAS_REF]) {
+            return timerId[HAS_REF]();
+        }
+        return ref;
+    };
+    var _refresh = function () {
+        timerId = refreshFn(timerId);
+        if (!ref) {
+            _unref();
+        }
+        return theTimerHandler;
+    };
+    var _cancel = function () {
+        timerId && cancelFn(timerId);
+        timerId = null;
+    };
+    var _setEnabled = function (value) {
+        !value && timerId && _cancel();
+        value && !timerId && _refresh();
+    };
+    theTimerHandler = (_a = {
+            cancel: _cancel,
+            refresh: _refresh
+        },
+        _a[HAS_REF] = _hasRef,
+        _a[REF] = _ref,
+        _a[UNREF] = _unref,
+        _a[ENABLED] = false,
+        _a);
+    objDefineProp(theTimerHandler, ENABLED, {
+        get: function () { return !!timerId; },
+        set: _setEnabled
+    });
+    return {
+        h: theTimerHandler,
+        dn: function () {
+            timerId = null;
+        }
+    };
+}
+
+function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
+    var isArr = isArray(overrideFn);
+    var len = isArr ? overrideFn.length : 0;
+    var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
+    var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
+    var timerFn = theArgs[0];
+    theArgs[0] = function () {
+        handler.dn();
+        timerFn.apply(self, arguments);
+    };
+    var handler = _createTimerHandler(startTimer, function (timerId) {
+        if (timerId) {
+            if (timerId.refresh) {
+                timerId.refresh();
+                return timerId;
+            }
+            clearFn.call(self, timerId);
+        }
+        return setFn.apply(self, theArgs);
+    }, function (timerId) {
+        clearFn.call(self, timerId);
+    });
+    return handler.h;
+}
+function scheduleTimeout(callback, timeout) {
+    return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
+}
+
+(getGlobal() || {})["Symbol"];
+(getGlobal() || {})["Reflect"];
+var strHasOwnProperty = "hasOwnProperty";
+var extendStaticsFn = function (d, b) {
+    extendStaticsFn = ObjClass$1["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            for (var p in b) {
+                if (b[strHasOwnProperty](p)) {
+                    d[p] = b[p];
+                }
+            }
+        };
+    return extendStaticsFn(d, b);
+};
+function __extendsFn(d, b) {
+    if (typeof b !== strShimFunction && b !== null) {
+        throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
+    }
+    extendStaticsFn(d, b);
+    function __() {
+        this.constructor = d;
+    }
+    d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+}
+
+var _a$2;
+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$2 = {},
+        _a$2[strSetInstFuncs] = true,
+        _a$2[strUseBaseInst] = true,
+        _a$2),
+    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)));
+}
+function _throwTypeError(message) {
+    throwTypeError("DynamicProto: " + message);
+}
+function _getInstanceFuncs(thisTarget) {
+    var instFuncs = {};
+    _forEachProp(thisTarget, function (name) {
+        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+            instFuncs[name] = thisTarget[name];
+        }
+    });
+    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 = {};
+    _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] || {};
+        instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+        if (!instFunc) {
+            _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        }
+        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+            var canAddInst = !objHasOwnProperty(target, funcName);
+            var objProto = _getObjProto(target);
+            var visited = [];
+            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                var protoFunc = objProto[funcName];
+                if (protoFunc) {
+                    canAddInst = (protoFunc === currentDynProtoProxy);
+                    break;
+                }
+                visited.push(objProto);
+                objProto = _getObjProto(objProto);
+            }
+            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] || {};
+        var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+        if (instFuncTable[DynAllowInstChkTag] !== false) {
+            instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+        }
+        _forEachProp(target, function (name) {
+            if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                instFuncs_1[name] = target[name];
+                delete target[name];
+                if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                    proto[name] = _createDynamicPrototype(proto, name);
+                }
+            }
+        });
+    }
+}
+function _checkPrototype(classProto, thisTarget) {
+    if (_objGetPrototypeOf) {
+        var visited = [];
+        var thisProto = _getObjProto(thisTarget);
+        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+            if (thisProto === classProto) {
+                return true;
+            }
+            visited.push(thisProto);
+            thisProto = _getObjProto(thisProto);
+        }
+        return false;
+    }
+    return true;
+}
+function _getObjName(target, unknownValue) {
+    if (objHasOwnProperty(target, Prototype)) {
+        return target.name || unknownValue || UnknownValue;
+    }
+    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+}
+function dynamicProto(theClass, target, delegateFunc, options) {
+    if (!objHasOwnProperty(theClass, Prototype)) {
+        _throwTypeError("theClass is an invalid class definition.");
+    }
+    var classProto = theClass[Prototype];
+    if (!_checkPrototype(classProto, target)) {
+        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+    }
+    var className = null;
+    if (objHasOwnProperty(classProto, DynClassName)) {
+        className = classProto[DynClassName];
+    }
+    else {
+        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+        _gblInst.n++;
+        classProto[DynClassName] = className;
+    }
+    var perfOptions = dynamicProto[DynProtoDefaultOptions];
+    var useBaseInst = !!perfOptions[strUseBaseInst];
+    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+        useBaseInst = !!options[strUseBaseInst];
+    }
+    var instFuncs = _getInstanceFuncs(target);
+    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+    delegateFunc(target, baseFuncs);
+    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+    if (setInstanceFunc && options) {
+        setInstanceFunc = !!options[strSetInstFuncs];
+    }
+    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+}
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_LENGTH$1 = "length";
+var _DYN_RD_ONLY = "rdOnly";
+var _DYN_NOTIFY = "notify";
+var _DYN_THROW_INTERNAL = "throwInternal";
+var _DYN_SET_DF = "setDf";
+var _DYN_WATCH = "watch";
+var _DYN_LOGGER = "logger";
+var _DYN_APPLY = "apply";
+var _DYN_PUSH = "push";
+var _DYN_SPLICE = "splice";
+var _DYN_CANCEL = "cancel";
+var _DYN_INITIALIZE = "initialize";
+var _DYN_IDENTIFIER$1 = "identifier";
+var _DYN_IS_INITIALIZED = "isInitialized";
+var _DYN_GET_PLUGIN = "getPlugin";
+var _DYN_NAME = "name";
+var _DYN_TIME = "time";
+var _DYN_PROCESS_NEXT$1 = "processNext";
+var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+var _DYN_UNLOAD = "unload";
+var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+var _DYN_CREATE_NEW = "createNew";
+var _DYN_TEARDOWN$1 = "teardown";
+var _DYN_MESSAGE_ID = "messageId";
+var _DYN_MESSAGE = "message";
+var _DYN_IS_ASYNC = "isAsync";
+var _DYN_DIAG_LOG = "diagLog";
+var _DYN__DO_TEARDOWN = "_doTeardown";
+var _DYN_UPDATE = "update";
+var _DYN_GET_NEXT = "getNext";
+var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+var _DYN_USER_AGENT = "userAgent";
+var _DYN_NODE_TYPE = "nodeType";
+var _DYN_REPLACE = "replace";
+var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+var _DYN_IS_CHILD_EVT = "isChildEvt";
+var _DYN_GET_CTX = "getCtx";
+var _DYN_SET_CTX = "setCtx";
+var _DYN_COMPLETE = "complete";
+
+var aggregationErrorType;
+function throwAggregationError(message, sourceErrors) {
+    if (!aggregationErrorType) {
+        aggregationErrorType = createCustomError("AggregationError", function (self, args) {
+            if (args[_DYN_LENGTH$1 ] > 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 _theLogger = null;
+function _debugLog(id, message) {
+    if (_theLogger) {
+        _theLogger(id, message);
+    }
+}
+
+var STRING_STATES = [
+    "pending", "resolving", "resolved", "rejected"
+];
+
+var DISPATCH_EVENT = "dispatchEvent";
+var _hasInitEvent;
+function emitEvent(target, evtName, populateEvent, useNewEvent) {
+    var doc = getDocument();
+    !_hasInitEvent && (_hasInitEvent = safeGetLazy(function () {
+        var evt;
+        if (doc && doc.createEvent) {
+            evt = doc.createEvent("Event");
+        }
+        return (!!evt && evt.initEvent);
+    }, null));
+    var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : (useNewEvent ? new Event(evtName) : {});
+    populateEvent && populateEvent(theEvt);
+    if (_hasInitEvent.v) {
+        theEvt.initEvent(evtName, false, true);
+    }
+    if (theEvt && target[DISPATCH_EVENT]) {
+        target[DISPATCH_EVENT](theEvt);
+    }
+    else {
+        var handler = target["on" + evtName];
+        if (handler) {
+            handler(theEvt);
+        }
+        else {
+            var theConsole = getInst("console");
+            theConsole && (theConsole["error"] || theConsole["log"])(evtName, dumpObj(theEvt));
+        }
+    }
+}
+
+var STR_PROMISE = "Promise";
+
+var NODE_UNHANDLED_REJECTION = "unhandledRejection";
+var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
+var _unhandledRejectionTimeout = 10;
+var _hasPromiseRejectionEvent;
+function dumpFnObj(value) {
+    if (isFunction(value)) {
+        return value.toString();
+    }
+    return dumpObj(value);
+}
+function _createPromise(newPromise, processor, executor) {
+    var additionalArgs = arrSlice(arguments, 3);
+    var _state = 0 ;
+    var _hasResolved = false;
+    var _settledValue;
+    var _queue = [];
+    var _handled = false;
+    var _unHandledRejectionHandler = null;
+    var _thePromise;
+    !_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = lazySafeGetInst(STR_PROMISE + "RejectionEvent"));
+    var _then = function (onResolved, onRejected) {
+        try {
+            _handled = true;
+            _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+            _unHandledRejectionHandler = null;
+            _debugLog(_toString(), "then(" + dumpFnObj(onResolved) + ", " + dumpFnObj(onResolved) + ")");
+            var thenPromise = newPromise(function (resolve, reject) {
+                _queue.push(function () {
+                    try {
+                        _debugLog(_toString(), "Handling settled value " + dumpFnObj(_settledValue));
+                        var handler = _state === 2  ? onResolved : onRejected;
+                        var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);
+                        _debugLog(_toString(), "Handling Result " + dumpFnObj(value));
+                        if (isPromiseLike(value)) {
+                            value.then(resolve, reject);
+                        }
+                        else if (handler) {
+                            resolve(value);
+                        }
+                        else if (_state === 3 ) {
+                            reject(value);
+                        }
+                        else {
+                            resolve(value);
+                        }
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+                _debugLog(_toString(), "Added to Queue " + _queue.length);
+                if (_hasResolved) {
+                    _processQueue();
+                }
+            }, additionalArgs);
+            _debugLog(_toString(), "Created -> " + thenPromise.toString());
+            return thenPromise;
+        }
+        finally {
+        }
+    };
+    var _catch = function (onRejected) {
+        return _then(undefined, onRejected);
+    };
+    var _finally = function (onFinally) {
+        var thenFinally = onFinally;
+        var catchFinally = onFinally;
+        if (isFunction(onFinally)) {
+            thenFinally = function (value) {
+                onFinally && onFinally();
+                return value;
+            };
+            catchFinally = function (reason) {
+                onFinally && onFinally();
+                throw reason;
+            };
+        }
+        return _then(thenFinally, catchFinally);
+    };
+    var _strState = function () {
+        return STRING_STATES[_state];
+    };
+    var _processQueue = function () {
+        if (_queue.length > 0) {
+            var pending = _queue.slice();
+            _queue = [];
+            _debugLog(_toString(), "Processing queue " + pending.length);
+            _handled = true;
+            processor(pending);
+            _debugLog(_toString(), "Processing done");
+            _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+            _unHandledRejectionHandler = null;
+        }
+        else {
+            _debugLog(_toString(), "Empty Processing queue ");
+        }
+    };
+    var _createSettleIfFn = function (newState, allowState) {
+        return function (theValue) {
+            if (_state === allowState) {
+                if (newState === 2  && isPromiseLike(theValue)) {
+                    _state = 1 ;
+                    _debugLog(_toString(), "Resolving");
+                    theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));
+                    return;
+                }
+                _state = newState;
+                _hasResolved = true;
+                _settledValue = theValue;
+                _debugLog(_toString(), _strState());
+                _processQueue();
+                if (!_handled && newState === 3  && !_unHandledRejectionHandler) {
+                    _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
+                }
+            }
+            else {
+                _debugLog(_toString(), "Already " + _strState());
+            }
+        };
+    };
+    var _notifyUnhandledRejection = function () {
+        if (!_handled) {
+            if (isNode()) {
+                _debugLog(_toString(), "Emitting " + NODE_UNHANDLED_REJECTION);
+                process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
+            }
+            else {
+                var gbl = getWindow() || getGlobal();
+                _debugLog(_toString(), "Emitting " + UNHANDLED_REJECTION);
+                emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {
+                    objDefine(theEvt, "promise", { g: function () { return _thePromise; } });
+                    theEvt.reason = _settledValue;
+                    return theEvt;
+                }, !!_hasPromiseRejectionEvent.v);
+            }
+        }
+    };
+    _thePromise = {
+        then: _then,
+        "catch": _catch,
+        finally: _finally
+    };
+    objDefineProp(_thePromise, "state", {
+        get: _strState
+    });
+    if (hasSymbol()) {
+        _thePromise[getKnownSymbol(11 )] = "IPromise";
+    }
+    var _toString = function () {
+        return "IPromise" + ("") + " " + _strState() + (_hasResolved ? (" - " + dumpFnObj(_settledValue)) : "");
+    };
+    _thePromise.toString = _toString;
+    (function _initialize() {
+        if (!isFunction(executor)) {
+            throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
+        }
+        var _rejectFn = _createSettleIfFn(3 , 0 );
+        try {
+            _debugLog(_toString(), "Executing");
+            executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);
+        }
+        catch (e) {
+            _rejectFn(e);
+        }
+    })();
+    _debugLog(_toString(), "Returning");
+    return _thePromise;
+}
+
+var _processPendingItems = function (pending) {
+    arrForEach(pending, function (fn) {
+        try {
+            fn();
+        }
+        catch (e) {
+        }
+    });
+};
+function timeoutItemProcessor(timeout) {
+    var callbackTimeout = isNumber(timeout) ? timeout : 0;
+    return function (pending) {
+        scheduleTimeout(function () {
+            _processPendingItems(pending);
+        }, callbackTimeout);
+    };
+}
+
+function createAsyncPromise(executor, timeout) {
+    return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
+}
+
+var _isPromiseSupported;
+function createNativePromise(executor, timeout) {
+    !_isPromiseSupported && (_isPromiseSupported = lazySafeGetInst(STR_PROMISE));
+    var PrmCls = _isPromiseSupported.v;
+    if (!PrmCls) {
+        return createAsyncPromise(executor);
+    }
+    if (!isFunction(executor)) {
+        throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpObj(executor));
+    }
+    var _state = 0 ;
+    function _strState() {
+        return STRING_STATES[_state];
+    }
+    var thePromise = new PrmCls(function (resolve, reject) {
+        function _resolve(value) {
+            _state = 2 ;
+            resolve(value);
+        }
+        function _reject(reason) {
+            _state = 3 ;
+            reject(reason);
+        }
+        executor(_resolve, _reject);
+    });
+    objDefineProp(thePromise, "state", {
+        get: _strState
+    });
+    return thePromise;
+}
+
+var _promiseCreator;
+function createPromise(executor, timeout) {
+    !_promiseCreator && (_promiseCreator = getLazy(function () { return createNativePromise; }));
+    return _promiseCreator.v.call(this, executor, timeout);
+}
+
+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_ERROR_TO_CONSOLE = "errorToConsole";
+var STR_WARN_TO_CONSOLE = "warnToConsole";
+var STR_GET_PERF_MGR = "getPerfMgr";
+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 _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 strConsole = "console";
+var strJSON = "JSON";
+var strCrypto = "crypto";
+var strMsCrypto = "msCrypto";
+var strMsie = "msie";
+var strTrident = "trident/";
+var _isTrident = null;
+var _navUserAgentCheck = null;
+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 = Math.floor((UInt32Mask * Math.random()) | 0);
+    }
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function mwcRandom32(signed) {
+    _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
+    _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
+    var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function newId(maxLength) {
+    if (maxLength === void 0) { maxLength = 22; }
+    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var number = random32() >>> 0;
+    var chars = 0;
+    var result = STR_EMPTY;
+    while (result[_DYN_LENGTH$1 ] < maxLength) {
+        chars++;
+        result += base64chars.charAt(number & 0x3F);
+        number >>>= 6;
+        if (chars === 5) {
+            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+            chars = 0;
+        }
+    }
+    return result;
+}
+
+var version = "3.0.2-nightly3.2305-04";
+var instanceName = "." + newId(6);
+var _dataUid = 0;
+function _canAcceptData(target) {
+    return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
+}
+function _getCache(data, target) {
+    var theCache = target[data.id];
+    if (!theCache) {
+        theCache = {};
+        try {
+            if (_canAcceptData(target)) {
+                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) && (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$1 ]; 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$1 ] = theValue[_DYN_LENGTH$1 ];
+        }
+        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;
+    if (_isConfigDefaults(cfgDefaults)) {
+        isValid = cfgDefaults.isVal;
+        setFn = cfgDefaults.set;
+        readOnly = cfgDefaults[_DYN_RD_ONLY ];
+        mergeDf = cfgDefaults.mrg;
+        reference = cfgDefaults.ref;
+        if (!reference && isUndefined(reference)) {
+            reference = !!mergeDf;
+        }
+        defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    else {
+        defValue = defaultValue;
+    }
+    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[_DYN_RD_ONLY ](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$1 ] = source[_DYN_LENGTH$1 ];
+        }
+        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 _canMakeDynamic(value) {
+    var result = false;
+    if (value) {
+        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"
+];
+function _patchArray(state, target) {
+    if (isArray(target)) {
+        arrForEach(arrayMethodsToPatch, function (method) {
+            var orgMethod = target[method];
+            target[method] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var result = orgMethod[_DYN_APPLY ](this, args);
+                _makeDynamicObject(state, target);
+                return result;
+            };
+        });
+    }
+}
+function _getOwnPropGetter(target, name) {
+    var propDesc = objGetOwnPropertyDescriptor(target, name);
+    return propDesc && propDesc.get;
+}
+function _makeDynamicProperty(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(value);
+            if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
+                value = _makeDynamicObject(state, value);
+            }
+            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(value);
+                checkDynamic = false;
+            }
+            var isReferenced = isObjectOrArray && _getProperty[state.rf];
+            if (isObjectOrArray) {
+                if (isReferenced) {
+                    objForEachKey(value, function (key) {
+                        value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
+                    });
+                    objForEachKey(newValue, function (key, theValue) {
+                        _setDynamicProperty(state, value, key, theValue);
+                    });
+                    newValue = value;
+                }
+                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(newValue);
+                if (!isReferenced && newIsObjectOrArray) {
+                    _makeDynamicObject(state, newValue);
+                }
+                value = newValue;
+                isObjectOrArray = newIsObjectOrArray;
+            }
+            state.add(detail);
+        }
+    }
+    objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
+}
+function _setDynamicProperty(state, target, name, value, inPlace, rdOnly) {
+    if (target) {
+        var getter = _getOwnPropGetter(target, name);
+        var isDynamic = getter && !!getter[state.prop];
+        if (!isDynamic) {
+            _makeDynamicProperty(state, target, name, value);
+            if (inPlace || rdOnly) {
+                getter = _getOwnPropGetter(target, name);
+            }
+        }
+        else {
+            target[name] = value;
+        }
+        if (inPlace) {
+            getter[state.rf] = inPlace;
+        }
+        if (rdOnly) {
+            getter[state.ro] = rdOnly;
+        }
+    }
+    return target;
+}
+function _makeDynamicObject(state, target) {
+    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);
+    }
+    return target;
+}
+
+var symPrefix = "[[ai_";
+var symPostfix = "]]";
+function _createState(cfgHandler) {
+    var _a;
+    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 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[_DYN_SET_DF ].bind(cfgHandler),
+                ref: cfgHandler.ref.bind(cfgHandler),
+                rdOnly: cfgHandler[_DYN_RD_ONLY ].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$1 ] > 0) {
+                throwAggregationError("Watcher error(s): ", watcherFailures_1);
+            }
+        }
+    }
+    function _addWatcher(detail) {
+        if (detail && detail.h[_DYN_LENGTH$1 ] > 0) {
+            if (!_waitingHandlers) {
+                _waitingHandlers = [];
+            }
+            if (!_watcherTimer) {
+                _watcherTimer = scheduleTimeout(function () {
+                    _watcherTimer = null;
+                    _notifyWatchers();
+                }, 0);
+            }
+            for (var idx = 0; idx < detail.h[_DYN_LENGTH$1 ]; 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 = (_a = {
+            prop: dynamicPropertySymbol,
+            ro: dynamicPropertyReadOnly,
+            rf: dynamicPropertyReferenced,
+            hdlr: cfgHandler,
+            add: _addWatcher
+        },
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.use = _useHandler,
+        _a.trk = _trackHandler,
+        _a);
+    return theState;
+}
+
+function _createAndUseHandler(state, configHandler) {
+    var handler = {
+        fn: configHandler,
+        rm: function () {
+            handler.fn = null;
+            state = null;
+            configHandler = null;
+        }
+    };
+    state.use(handler, configHandler);
+    return handler;
+}
+function _createDynamicHandler(logger, target, inPlace) {
+    var _a;
+    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[_DYN_NOTIFY ]();
+    }
+    function _setValue(target, name, value) {
+        return _setDynamicProperty(theState, target, name, value)[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) {
+        return _setDynamicProperty(theState, target, name, target[name], true)[name];
+    }
+    function _rdOnly(target, name) {
+        return _setDynamicProperty(theState, target, name, target[name], false, true)[name];
+    }
+    function _applyDefaults(theConfig, defaultValues) {
+        if (defaultValues) {
+            objForEachKey(defaultValues, function (name, value) {
+                _applyDefaultValue(cfgHandler, theConfig, name, value);
+            });
+        }
+        return theConfig;
+    }
+    var cfgHandler = (_a = {
+            uid: null,
+            cfg: newTarget
+        },
+        _a[_DYN_LOGGER ] = logger,
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.set = _setValue,
+        _a[_DYN_SET_DF ] = _applyDefaults,
+        _a[_DYN_WATCH ] = _watch,
+        _a.ref = _ref,
+        _a[_DYN_RD_ONLY ] = _rdOnly,
+        _a._block = _block,
+        _a);
+    objDefine(cfgHandler, "uid", {
+        c: false,
+        e: false,
+        w: false,
+        v: uid
+    });
+    theState = _createState(cfgHandler);
+    _makeDynamicObject(theState, newTarget);
+    return cfgHandler;
+}
+function _logInvalidAccess(logger, message) {
+    if (logger) {
+        logger[STR_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[_DYN_SET_DF ](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 _stringToBoolOrDefault(theValue, defaultValue, theConfig) {
+    if (!theValue && isNullOrUndefined(theValue)) {
+        return defaultValue;
+    }
+    if (isBoolean(theValue)) {
+        return theValue;
+    }
+    return asString(theValue)[_DYN_TO_LOWER_CASE ]() === "true";
+}
+function cfgDfBoolean(defaultValue, fallBackName) {
+    return {
+        fb: fallBackName,
+        set: _stringToBoolOrDefault,
+        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 AiNonUserActionablePrefix = "AI (Internal): ";
+var AiUserActionablePrefix = "AI: ";
+var AIInternalMessagePrefix = "AITR_";
+var defaultValues$1 = {
+    loggingLevelConsole: 0,
+    loggingLevelTelemetry: 1,
+    maxMessageLimit: 25,
+    enableDebug: false
+};
+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 = severity === 1  ? STR_ERROR_TO_CONSOLE : 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[STR_WARN_TO_CONSOLE ] = function (message) {
+                _logToConsole("warn", message);
+                _debugExtMsg("warning", message);
+            };
+            _self[STR_ERROR_TO_CONSOLE ] = function (message) {
+                _logToConsole("error", message);
+                _debugExtMsg("error", message);
+            };
+            _self.resetInternalMessageCount = function () {
+                _messageCount = 0;
+                _messageLogged = {};
+            };
+            _self[_DYN_LOG_INTERNAL_MESSAGE ] = _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[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
+                        }
+                        else {
+                            _self[STR_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 strExecutionContextKey = "ctx";
+var strParentContextKey = "ParentContextKey";
+var strChildrenContextKey = "ChildrenContextKey";
+var PerfEvent = /** @class */ (function () {
+    function PerfEvent(name, payloadDetails, isAsync) {
+        var _self = this;
+        _self.start = utcNow();
+        _self[_DYN_NAME ] = name;
+        _self[_DYN_IS_ASYNC ] = isAsync;
+        _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
+        if (isFunction(payloadDetails)) {
+            var theDetails_1;
+            objDefine(_self, "payload", {
+                g: function () {
+                    if (!theDetails_1 && isFunction(payloadDetails)) {
+                        theDetails_1 = payloadDetails();
+                        payloadDetails = null;
+                    }
+                    return theDetails_1;
+                }
+            });
+        }
+        _self[_DYN_GET_CTX ] = function (key) {
+            if (key) {
+                if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
+                    return _self[key];
+                }
+                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[_DYN_COMPLETE ] = function () {
+            var childTime = 0;
+            var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+            if (isArray(childEvts)) {
+                for (var lp = 0; lp < childEvts[_DYN_LENGTH$1 ]; lp++) {
+                    var childEvt = childEvts[lp];
+                    if (childEvt) {
+                        childTime += childEvt[_DYN_TIME ];
+                    }
+                }
+            }
+            _self[_DYN_TIME ] = utcNow() - _self.start;
+            _self.exTime = _self[_DYN_TIME ] - childTime;
+            _self[_DYN_COMPLETE ] = function () { };
+        };
+    }
+    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);
+}
+function initializePlugins(processContext, extensions) {
+    var initPlugins = [];
+    var lastPlugin = null;
+    var proxy = processContext[_DYN_GET_NEXT ]();
+    var pluginState;
+    while (proxy) {
+        var thePlugin = proxy[_DYN_GET_PLUGIN ]();
+        if (thePlugin) {
+            if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN ] && thePlugin[STR_PROCESS_TELEMETRY ]) {
+                lastPlugin[_DYN_SET_NEXT_PLUGIN ](thePlugin);
+            }
+            pluginState = _getPluginState(thePlugin);
+            var isInitialized = !!pluginState[_DYN_IS_INITIALIZED ];
+            if (thePlugin[_DYN_IS_INITIALIZED ]) {
+                isInitialized = thePlugin[_DYN_IS_INITIALIZED ]();
+            }
+            if (!isInitialized) {
+                initPlugins[_DYN_PUSH ](thePlugin);
+            }
+            lastPlugin = thePlugin;
+            proxy = proxy[_DYN_GET_NEXT ]();
+        }
+    }
+    arrForEach(initPlugins, function (thePlugin) {
+        var core = processContext[STR_CORE ]();
+        thePlugin[_DYN_INITIALIZE ](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT ]());
+        pluginState = _getPluginState(thePlugin);
+        if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {
+            pluginState[STR_CORE] = core;
+        }
+        pluginState[_DYN_IS_INITIALIZED ] = true;
+        delete pluginState[_DYN_TEARDOWN$1 ];
+    });
+}
+
+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$1 ] > 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[_DYN_SET_DF ](newConfig, defaultValues);
+    }
+    function _getConfig(identifier, field, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = false; }
+        var theValue;
+        var extConfig = _getExtCfg(identifier, false);
+        var rootConfig = 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$1 ] = _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$1 ] = _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$1 ] = _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$1 ] > 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$1 ] + "-" + 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$1 ] : 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$1 ] || 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$1 ](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$1 ]) {
+                    pluginState[STR_CORE ] = null;
+                    pluginState[_DYN_TEARDOWN$1 ] = true;
+                    pluginState[_DYN_IS_INITIALIZED ] = false;
+                    if (plugin[_DYN_TEARDOWN$1 ] && plugin[_DYN_TEARDOWN$1 ](unloadCtx, unloadState) === true) {
+                        hasRun = true;
+                    }
+                }
+            }
+            return hasRun;
+        }
+        if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState[_DYN_IS_ASYNC ])) {
+            unloadCtx[_DYN_PROCESS_NEXT$1 ](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$1 ]) {
+                    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$1 ](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$1;
+var strGetPlugin = "getPlugin";
+var defaultValues = (_a$1 = {},
+    _a$1[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} },
+    _a$1);
+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$1 ] = function (unloadCtx, unloadState) {
+                var _a;
+                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 || (_a = {
+                        reason: 0
+                    },
+                    _a[_DYN_IS_ASYNC ] = false,
+                    _a);
+                function _unloadCallback() {
+                    if (!unloadDone) {
+                        unloadDone = true;
+                        _unloadHandlerContainer.run(theUnloadCtx, unloadState);
+                        _hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG ]());
+                        if (result === true) {
+                            theUnloadCtx[_DYN_PROCESS_NEXT$1 ](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$1 ] = function (env, itemCtx) {
+            if (itemCtx) {
+                itemCtx[_DYN_PROCESS_NEXT$1 ](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_CONT0 ]()[_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 _DYN_LENGTH = "length";
+var _DYN_QUEUE = "queue";
+var _DYN_PROCESS_NEXT = "processNext";
+var _DYN_IDENTIFIER = "identifier";
+var _DYN_GET_QUEUES = "getQueues";
+var _DYN_TEARDOWN = "teardown";
+var _DYN_PRIORITY = "priority";
+var _DYN_IGNORE_CORE_CHANNELS = "ignoreCoreChannels";
+var _DYN_TEE_CHANNELS = "teeChannels";
+
+var ChannelControllerPriority = 500;
+function _getTelCtx(core) {
+    return createProcessTelemetryContext(null, core.config, core, null);
+}
+function _processChannelQueue(theChannels, itemCtx, processFn, onComplete) {
+    var waiting = theChannels ? (theChannels[_DYN_LENGTH ] + 1) : 1;
+    function _runChainOnComplete() {
+        waiting--;
+        if (waiting === 0) {
+            onComplete && onComplete();
+            onComplete = null;
+        }
+    }
+    if (waiting > 0) {
+        arrForEach(theChannels, function (channels) {
+            if (channels && channels.queue[_DYN_LENGTH ] > 0) {
+                var chainCtx = itemCtx.createNew(channels[_DYN_QUEUE ]);
+                chainCtx.onComplete(_runChainOnComplete);
+                processFn(chainCtx);
+            }
+            else {
+                waiting--;
+            }
+        });
+    }
+    _runChainOnComplete();
+}
+function createChannelControllerPlugin() {
+    var _channelQueue = [];
+    var _core = null;
+    function _doUpdate(updateCtx, updateState) {
+        var theUpdateState = updateState || {
+            reason: 0
+        };
+        _processChannelQueue(_channelQueue, updateCtx, function (chainCtx) {
+            chainCtx[_DYN_PROCESS_NEXT ](theUpdateState);
+        }, function () {
+            updateCtx[_DYN_PROCESS_NEXT ](theUpdateState);
+        });
+        return true;
+    }
+    function _getChannel(pluginIdentifier) {
+        var thePlugin = null;
+        if (_channelQueue && _channelQueue[_DYN_LENGTH ] > 0) {
+            arrForEach(_channelQueue, function (channels) {
+                if (channels && channels.queue[_DYN_LENGTH ] > 0) {
+                    arrForEach(channels[_DYN_QUEUE ], function (ext) {
+                        if (ext[_DYN_IDENTIFIER ] === pluginIdentifier) {
+                            thePlugin = ext;
+                            return -1;
+                        }
+                    });
+                    if (thePlugin) {
+                        return -1;
+                    }
+                }
+            });
+        }
+        return thePlugin;
+    }
+    var channelController = {
+        init: function (channelQueue, core) {
+            _channelQueue = channelQueue;
+            _core = core;
+        },
+        getQueues: function () {
+            return _channelQueue;
+        },
+        processTelemetry: function (item, itemCtx) {
+            _processChannelQueue(_channelQueue, itemCtx || _getTelCtx(_core), function (chainCtx) {
+                chainCtx[_DYN_PROCESS_NEXT ](item);
+            }, function () {
+                itemCtx[_DYN_PROCESS_NEXT ](item);
+            });
+        },
+        update: _doUpdate,
+        pause: function () {
+            _processChannelQueue(_channelQueue, _getTelCtx(_core), function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    plugin.pause && plugin.pause();
+                });
+            }, null);
+        },
+        resume: function () {
+            _processChannelQueue(_channelQueue, _getTelCtx(_core), function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    plugin.resume && plugin.resume();
+                });
+            }, null);
+        },
+        teardown: function (unloadCtx, unloadState, onComplete) {
+            var theUnloadState = unloadState || {
+                reason: 0 ,
+                isAsync: false
+            };
+            _processChannelQueue(_channelQueue, unloadCtx, function (chainCtx) {
+                chainCtx[_DYN_PROCESS_NEXT ](theUnloadState);
+            }, function () {
+                unloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
+                onComplete && onComplete();
+            });
+            return true;
+        },
+        getChannel: _getChannel,
+        flush: function (isAsync, callBack, sendReason, cbTimeout) {
+            var waiting = 1;
+            var doneIterating = false;
+            var cbTimer = null;
+            var result = true;
+            cbTimeout = cbTimeout || 5000;
+            if (isAsync && !callBack) {
+                result = createPromise(function (resolve) {
+                    callBack = resolve;
+                });
+            }
+            function doCallback() {
+                waiting--;
+                if (doneIterating && waiting === 0) {
+                    cbTimer && cbTimer.cancel();
+                    cbTimer = null;
+                    callBack && callBack(doneIterating);
+                    callBack = null;
+                }
+            }
+            _processChannelQueue(_channelQueue, _getTelCtx(_core), function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    if (plugin.flush) {
+                        waiting++;
+                        var handled_1 = false;
+                        if (!plugin.flush(isAsync, function () {
+                            handled_1 = true;
+                            doCallback();
+                        }, sendReason)) {
+                            if (!handled_1) {
+                                if (isAsync && cbTimer == null) {
+                                    cbTimer = scheduleTimeout(function () {
+                                        cbTimer = null;
+                                        doCallback();
+                                    }, cbTimeout);
+                                }
+                                else {
+                                    doCallback();
+                                }
+                            }
+                        }
+                    }
+                });
+            }, function () {
+                doneIterating = true;
+                doCallback();
+            });
+            return result;
+        }
+    };
+    return channelController;
+}
+
+var _a;
+var ChannelValidationMessage = "Channel has invalid priority - ";
+var defaultTeeChannelConfig = objDeepFreeze((_a = {},
+    _a[_DYN_TEE_CHANNELS ] = null,
+    _a[_DYN_IGNORE_CORE_CHANNELS ] = cfgDfBoolean(),
+    _a));
+function _addChannelQueue(channelQueue, queue, core, teeChannel) {
+    var _a;
+    if (queue && isArray(queue) && queue[_DYN_LENGTH ] > 0) {
+        queue = queue.sort(function (a, b) {
+            return a[_DYN_PRIORITY ] - b[_DYN_PRIORITY ];
+        });
+        var _queue_1 = [];
+        arrForEach(queue, function (queueItem) {
+            if (queueItem[_DYN_PRIORITY ] < ChannelControllerPriority) {
+                throwError(ChannelValidationMessage + queueItem[_DYN_IDENTIFIER ]);
+            }
+            if (queueItem !== teeChannel) {
+                _queue_1.push(queueItem);
+            }
+        });
+        channelQueue.push((_a = {},
+            _a[_DYN_QUEUE ] = objFreeze(_queue_1),
+            _a));
+    }
+}
+function _createChannelQueues(config, core, teeChannel) {
+    var channelQueue = [];
+    if (config) {
+        if (!config[_DYN_IGNORE_CORE_CHANNELS ] && core.config.channels) {
+            arrForEach(core.config.channels, function (queue, idx) {
+                if (idx > 0) {
+                    _addChannelQueue(channelQueue, queue, core, teeChannel);
+                }
+            });
+        }
+        if (config[_DYN_TEE_CHANNELS ]) {
+            arrForEach(config[_DYN_TEE_CHANNELS ], function (queue) { return _addChannelQueue(channelQueue, queue, core, teeChannel); });
+        }
+    }
+    return channelQueue;
+}
+var TeeChannel = /** @class */ (function (_super) {
+    __extendsFn(TeeChannel, _super);
+    function TeeChannel() {
+        var _this = _super.call(this) || this;
+        _this.identifier = "TeeChannelController";
+        _this.priority = 999;
+        var _channelController;
+        var _isInitialized;
+        dynamicProto(TeeChannel, _this, function (_self, base) {
+            _initDefaults();
+            _self.initialize = function (config, core, extensions, pluginChain) {
+                if (!_isInitialized) {
+                    _isInitialized = true;
+                    _initChannels(_self, core);
+                }
+            };
+            _self.getTeeChannels = function () {
+                var controls = [];
+                var channelQueues = _channelController[_DYN_GET_QUEUES ]();
+                if (channelQueues) {
+                    arrForEach(channelQueues, function (channels) {
+                        controls.push(channels[_DYN_QUEUE ]);
+                    });
+                }
+                return objFreeze(controls);
+            };
+            _self.isInitialized = function () {
+                return _isInitialized;
+            };
+            _self[_DYN_TEARDOWN ] = function (unloadCtx, unloadState) {
+                return _channelController[_DYN_TEARDOWN ](unloadCtx, unloadState, function () {
+                    _isInitialized = false;
+                });
+            };
+            proxyFunctions(_self, _channelController, [
+                "processTelemetry",
+                "update",
+                "pause",
+                "resume",
+                "getChannel",
+                "flush"
+            ]);
+        });
+        function _initDefaults() {
+            _channelController = createChannelControllerPlugin();
+            _isInitialized = false;
+        }
+        function _initChannels(self, core) {
+            self._addHook(onConfigChange(core.config, function (details) {
+                var ctx = createProcessTelemetryContext(null, details.cfg, core);
+                var theConfig = ctx.getExtCfg(self[_DYN_IDENTIFIER ], defaultTeeChannelConfig);
+                var channelQueue = _createChannelQueues(theConfig, core, self);
+                arrForEach(channelQueue, function (channels) {
+                    if (channels && channels.queue[_DYN_LENGTH ] > 0) {
+                        initializePlugins(ctx.createNew(channels[_DYN_QUEUE ]), details.cfg.extensions);
+                    }
+                });
+                _channelController.init(channelQueue, core);
+            }));
+        }
+        return _this;
+    }
+    TeeChannel.__ieDyn=1;
+    return TeeChannel;
+}(BaseTelemetryPlugin));
+
+exports.TeeChannel = TeeChannel;
+
+}));
+//# sourceMappingURL=applicationinsights-teechannel-js.3.0.2-nightly3.2305-04.gbl.js.map