@microsoft/power-apps-cli 0.5.3 → 0.5.4

package/node_modules/@microsoft/1ds-properties-js/bundle/es5/ms.properties.js

@@ -0,0 +1,4848 @@
+/*!
+ * 1DS JS SDK Properties plugin, 4.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ * (Microsoft Internal Only)
+ */
+(function (global, factory) {
+    var undef = "undefined";
+    typeof exports === "object" && typeof module !== undef ? factory(exports) :
+    typeof define === "function" && define.amd ? define(["exports"], factory) :
+    (function(global){
+        var nsKey, key, nm, theExports = {}, modName = "es5_ms_properties_4_3_9", msMod="__ms$mod__";
+        var mods={}, modDetail=mods[modName]={}, ver="4.3.9";
+        // Versioned namespace "oneDS4"
+        var exportNs=global, nsKey="oneDS4", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
+        // Global namespace "oneDS"
+        var destNs=global, nsKey="oneDS", 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);
+        }
+    })(typeof globalThis !== undef ? globalThis : global || self);
+})(this, (function (exports) {
+'use strict';
+
+
+/*! https://github.com/nevware21/ts-utils v0.12.5 */
+/*#__NO_SIDE_EFFECTS__*/
+function _pureAssign(func1, func2) {
+    return func1 || func2;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _pureRef(value, name) {
+    return value[name];
+}
+var UNDEF_VALUE = undefined;
+var NULL_VALUE = null;
+var EMPTY = "";
+var FUNCTION = "function";
+var OBJECT = "object";
+var PROTOTYPE = "prototype";
+var __PROTO__ = "__proto__";
+var UNDEFINED = "undefined";
+var CONSTRUCTOR = "constructor";
+var SYMBOL = "Symbol";
+var LENGTH = "length";
+var NAME = "name";
+var CALL = "call";
+var TO_STRING = "toString";
+var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
+var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
+var ObjClass$1 = ( /*#__PURE__*/_pureAssign(Object));
+var ObjProto = ( /*#__PURE__*/_pureRef(ObjClass$1, PROTOTYPE));
+var StrCls = ( /*#__PURE__*/_pureAssign(String));
+var StrProto = ( /*#__PURE__*/_pureRef(StrCls, PROTOTYPE));
+var MathCls = ( /*#__PURE__*/_pureAssign(Math));
+var ArrCls = ( /*#__PURE__*/_pureAssign(Array));
+var ArrProto = ( /*#__PURE__*/_pureRef(ArrCls, PROTOTYPE));
+var ArrSlice = ( /*#__PURE__*/_pureRef(ArrProto, "slice"));
+var POLYFILL_TAG = "_polyfill";
+var POLYFILL_TYPE_NAME = "__nw21$polytype__";
+function safe(func, argArray) {
+    try {
+        return {
+            v: func.apply(this, argArray)
+        };
+    }
+    catch (e) {
+        return { e: e };
+    }
+}
+/*#__NO_SIDE_EFFECTS__*/
+function safeGet(cb, defValue, argArray) {
+    var result = safe(cb, argArray);
+    return result.e ? defValue : result.v;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _createIs(theType) {
+    return function (value) {
+        return typeof value === theType;
+    };
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _createObjIs(theName) {
+    var theType = "[object " + theName + "]";
+    return function (value) {
+        return !!(value && objToString(value) === theType);
+    };
+}
+/*#__NO_SIDE_EFFECTS__*/
+function objToString(value) {
+    return ObjProto[TO_STRING].call(value);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isUndefined(value) {
+    return typeof value === UNDEFINED || value === UNDEFINED;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isStrictUndefined(arg) {
+    return arg === UNDEF_VALUE;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isNullOrUndefined(value) {
+    return value === NULL_VALUE || isUndefined(value);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isStrictNullOrUndefined(value) {
+    return value === NULL_VALUE || value === UNDEF_VALUE;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isDefined(arg) {
+    return !!arg || arg !== UNDEF_VALUE;
+}
+var isString = ( /*#__PURE__*/_createIs("string"));
+var isFunction = ( /*#__PURE__*/_createIs(FUNCTION));
+/*#__NO_SIDE_EFFECTS__*/
+function isObject(value) {
+    if (!value && isNullOrUndefined(value)) {
+        return false;
+    }
+    return !!value && typeof value === OBJECT;
+}
+var isArray = ( /* #__PURE__*/_pureRef(ArrCls, "isArray"));
+var isNumber = ( /*#__PURE__*/_createIs("number"));
+var isBoolean = ( /*#__PURE__*/_createIs("boolean"));
+var isError = ( /*#__PURE__*/_createObjIs("Error"));
+/*#__NO_SIDE_EFFECTS__*/
+function isTruthy(value) {
+    return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));
+}
+function _returnNothing() {
+    return;
+}
+function _returnEmptyArray() {
+    return [];
+}
+function _returnFalse() {
+    return false;
+}
+var asString = ( /*#__PURE__*/_pureAssign(StrCls));
+var ERROR_TYPE = "[object Error]";
+/*#__NO_SIDE_EFFECTS__*/
+function dumpObj(object, format) {
+    var propertyValueDump = EMPTY;
+    var objType = ObjProto[TO_STRING][CALL](object);
+    if (objType === ERROR_TYPE) {
+        object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
+    }
+    try {
+        propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
+        propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
+    }
+    catch (e) {
+        propertyValueDump = " - " + dumpObj(e, format);
+    }
+    return objType + ": " + propertyValueDump;
+}
+function throwTypeError(message) {
+    throw new TypeError(message);
+}
+function _throwIfNullOrUndefined(obj) {
+    if (isStrictNullOrUndefined(obj)) {
+        throwTypeError("Cannot convert undefined or null to object");
+    }
+}
+function _throwIfNotString(value) {
+    if (!isString(value)) {
+        throwTypeError("'" + dumpObj(value) + "' is not a string");
+    }
+}
+/*#__NO_SIDE_EFFECTS__*/
+function objHasOwnProperty(obj, prop) {
+    return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
+}
+var _objGetOwnPropertyDescriptor$2 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+var objHasOwn = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, "hasOwn")), polyObjHasOwn));
+/*#__NO_SIDE_EFFECTS__*/
+function polyObjHasOwn(obj, prop) {
+    _throwIfNullOrUndefined(obj);
+    return objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
+}
+function objForEachKey(theObject, callbackfn, thisArg) {
+    if (theObject && (isObject(theObject) || isFunction(theObject))) {
+        for (var prop in theObject) {
+            if (objHasOwn(theObject, prop)) {
+                if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
+                    break;
+                }
+            }
+        }
+    }
+}
+function arrForEach(theArray, callbackfn, thisArg) {
+    if (theArray) {
+        var len = theArray[LENGTH] >>> 0;
+        for (var idx = 0; idx < len; idx++) {
+            if (idx in theArray) {
+                if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+                    break;
+                }
+            }
+        }
+    }
+}
+var _unwrapFunction = ( _unwrapFunctionWithPoly);
+/*#__NO_SIDE_EFFECTS__*/
+function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
+    var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
+    return function (thisArg) {
+        var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
+        if (theFunc || polyFunc) {
+            var theArgs = arguments;
+            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
+        }
+        throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
+    };
+}
+function _objPropertyIsEnum(obj, propKey) {
+    var desc;
+    var fn = ObjClass$1.getOwnPropertyDescriptor;
+    if (!isStrictNullOrUndefined(obj) && fn) {
+        desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
+    }
+    if (!desc) {
+        desc = safe(function () {
+            for (var key in obj) {
+                if (key === propKey) {
+                    return { enumerable: true };
+                }
+            }
+        }).v;
+    }
+    return (desc && desc.enumerable) || false;
+}
+var objPropertyIsEnumerable = ( /*#__PURE__*/_unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
+var _objGetOwnPropertyDescriptor$1 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+var _objGetOwnPropertySymbols = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
+var propMap = {
+    e: "enumerable",
+    c: "configurable",
+    v: "value",
+    w: "writable",
+    g: "get",
+    s: "set"
+};
+/*#__NO_SIDE_EFFECTS__*/
+function _createProp(value) {
+    var prop = {};
+    prop[propMap["c"]] = true;
+    prop[propMap["e"]] = true;
+    if (value.l) {
+        prop.get = function () { return value.l.v; };
+        var desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
+        if (desc && desc.set) {
+            prop.set = function (newValue) {
+                value.l.v = newValue;
+            };
+        }
+    }
+    objForEachKey(value, function (key, value) {
+        prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;
+    });
+    return prop;
+}
+var objDefineProp = ( /*#__PURE__*/_pureRef(ObjClass$1, "defineProperty"));
+var objDefineProperties = ( /*#__PURE__*/_pureRef(ObjClass$1, "defineProperties"));
+function objDefine(target, key, propDesc) {
+    return objDefineProp(target, key, _createProp(propDesc));
+}
+function objDefineProps(target, propDescMap) {
+    var props = {};
+    objForEachKey(propDescMap, function (key, value) {
+        props[key] = _createProp(value);
+    });
+    arrForEach(_objGetOwnPropertySymbols(propDescMap), function (sym) {
+        if (objPropertyIsEnumerable(propDescMap, sym)) {
+            props[sym] = _createProp(propDescMap[sym]);
+        }
+    });
+    return objDefineProperties(target, props);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
+    var theMap = {};
+    objForEachKey(values, function (key, value) {
+        _assignMapValue(theMap, key, keyType ? value : key);
+        _assignMapValue(theMap, value, valueType ? value : key);
+    });
+    return completeFn ? completeFn(theMap) : theMap;
+}
+function _assignMapValue(theMap, key, value, writable) {
+    objDefineProp(theMap, key, {
+        value: value,
+        enumerable: true,
+        writable: false
+    });
+}
+var objIsFrozen = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, "isFrozen")), _returnFalse));
+var _objFreeze = ( /*#__PURE__*/_pureRef(ObjClass$1, "freeze"));
+function _doNothing(value) {
+    return value;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _getProto(value) {
+    _throwIfNullOrUndefined(value);
+    return value[__PROTO__] || NULL_VALUE;
+}
+var objKeys = ( /*#__PURE__*/_pureRef(ObjClass$1, "keys"));
+function _deepFreeze(val, visited) {
+    if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
+        for (var lp = 0; lp < visited.length; lp++) {
+            if (visited[lp] === val) {
+                return val;
+            }
+        }
+        visited.push(val);
+        objForEachKey(val, function (_key, propValue) {
+            _deepFreeze(propValue, visited);
+        });
+        objFreeze(val);
+    }
+    return val;
+}
+function objDeepFreeze(value) {
+    return _objFreeze ? _deepFreeze(value, []) : value;
+}
+var objFreeze = ( /*#__PURE__*/_pureAssign(_objFreeze, _doNothing));
+var objGetPrototypeOf = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, "getPrototypeOf")), _getProto));
+/*#__NO_SIDE_EFFECTS__*/
+function createEnumKeyMap(values) {
+    return _createKeyValueMap(values, 0 , 0 , objFreeze);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function createSimpleMap(values) {
+    var mapClass = {};
+    objForEachKey(values, function (key, value) {
+        _assignMapValue(mapClass, key, value[1]);
+        _assignMapValue(mapClass, value[0], value[1]);
+    });
+    return objFreeze(mapClass);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function createTypeMap(values) {
+    return createSimpleMap(values);
+}
+var _wellKnownSymbolMap = ( /*#__PURE__*/createEnumKeyMap({
+    asyncIterator: 0 ,
+    hasInstance: 1 ,
+    isConcatSpreadable: 2 ,
+    iterator: 3 ,
+    match: 4 ,
+    matchAll: 5 ,
+    replace: 6 ,
+    search: 7 ,
+    species: 8 ,
+    split: 9 ,
+    toPrimitive: 10 ,
+    toStringTag: 11 ,
+    unscopables: 12
+}));
+var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+var _globalCfg;
+/*#__NO_SIDE_EFFECTS__*/
+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;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _getGlobalConfig() {
+    if (!_globalCfg) {
+        var gbl = safe(_getGlobalValue).v || {};
+        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+    }
+    return _globalCfg;
+}
+var mathMax = ( /*#__PURE__*/_pureRef(MathCls, "max"));
+var strSlice = ( /*#__PURE__*/_unwrapFunction("slice", StrProto));
+var strSubstring = ( /*#__PURE__*/_unwrapFunction("substring", StrProto));
+var strSubstr = ( /*#__PURE__*/_unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
+/*#__NO_SIDE_EFFECTS__*/
+function polyStrSubstr(value, start, length) {
+    _throwIfNullOrUndefined(value);
+    if (length < 0) {
+        return EMPTY;
+    }
+    start = start || 0;
+    if (start < 0) {
+        start = mathMax(start + value[LENGTH], 0);
+    }
+    if (isUndefined(length)) {
+        return strSlice(value, start);
+    }
+    return strSlice(value, start, start + length);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function strLeft(value, count) {
+    return strSubstring(value, 0, count);
+}
+function _tagAsPolyfill(target, polyfillTypeName) {
+    if (target) {
+        safe(function () {
+            target[POLYFILL_TAG] = true;
+            target[POLYFILL_TYPE_NAME] = polyfillTypeName;
+        });
+        safe(objDefine, [target, POLYFILL_TAG, {
+                v: true,
+                w: false,
+                e: false
+            }]);
+        safe(objDefine, [target, POLYFILL_TYPE_NAME, {
+                v: polyfillTypeName,
+                w: false,
+                e: false
+            }]);
+    }
+    return target;
+}
+var objCreate = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass$1, "create")), polyObjCreate));
+/*#__NO_SIDE_EFFECTS__*/
+function polyObjCreate(obj, properties) {
+    var newObj = null;
+    function tempFunc() { }
+    if (!isStrictNullOrUndefined(obj)) {
+        var type = typeof obj;
+        if (type !== OBJECT && type !== FUNCTION) {
+            throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
+        }
+        tempFunc[PROTOTYPE] = obj;
+        safe(function () {
+            tempFunc[__PROTO__] = obj;
+        });
+        newObj = new tempFunc();
+    }
+    else {
+        newObj = {};
+    }
+    if (properties) {
+        safe(objDefineProperties, [newObj, properties]);
+    }
+    return newObj;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function utcNow() {
+    return (Date.now || polyUtcNow)();
+}
+/*#__NO_SIDE_EFFECTS__*/
+function polyUtcNow() {
+    return new Date().getTime();
+}
+function fnApply(fn, thisArg, argArray) {
+    return fn.apply(thisArg, argArray);
+}
+var _globalLazyTestHooks;
+function _initTestHooks() {
+    _globalLazyTestHooks = _getGlobalConfig();
+}
+/*#__NO_SIDE_EFFECTS__*/
+function getLazy(cb, argArray) {
+    var lazyValue = {};
+    !_globalLazyTestHooks && _initTestHooks();
+    lazyValue.b = _globalLazyTestHooks.lzy;
+    objDefineProp(lazyValue, "v", {
+        configurable: true,
+        get: function () {
+            var result = fnApply(cb, null, argArray);
+            if (!_globalLazyTestHooks.lzy) {
+                objDefineProp(lazyValue, "v", {
+                    value: result
+                });
+            }
+            lazyValue.b = _globalLazyTestHooks.lzy;
+            return result;
+        }
+    });
+    return lazyValue;
+}
+var mathRandom = ( /*#__PURE__*/_pureRef(MathCls, "random"));
+var _uniqueInstanceId = ( /*#__PURE__*/getLazy(function () {
+    var value = (utcNow().toString(36).slice(2));
+    while (value.length < 16) {
+        value += mathRandom().toString(36).slice(2);
+    }
+    value = value.substring(0, 16);
+    return value;
+}));
+var UNIQUE_REGISTRY_ID = "_urid";
+var POLY_SYM = "$nw21sym";
+var _polySymbols;
+var _polyId = 0;
+/*#__NO_SIDE_EFFECTS__*/
+function _globalSymbolRegistry() {
+    if (!_polySymbols) {
+        var gblCfg = _getGlobalConfig();
+        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
+    }
+    return _polySymbols;
+}
+var _wellKnownSymbolCache;
+/*#__NO_SIDE_EFFECTS__*/
+function polyNewSymbol(description) {
+    var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
+    var symString = SYMBOL + "(" + description + ")";
+    function _setProp(name, value) {
+        objDefine(theSymbol, name, {
+            v: value,
+            e: false,
+            w: false
+        });
+    }
+    var theSymbol = objCreate(null);
+    _setProp("description", asString(description));
+    _setProp(TO_STRING, function () { return symString + POLY_SYM + uniqueId; });
+    _setProp("valueOf", function () { return theSymbol; });
+    _setProp("v", symString);
+    _setProp("_uid", uniqueId);
+    return _tagAsPolyfill(theSymbol, "symbol");
+}
+/*#__NO_SIDE_EFFECTS__*/
+function polySymbolFor(key) {
+    var registry = _globalSymbolRegistry();
+    if (!objHasOwn(registry.k, key)) {
+        var newSymbol_1 = polyNewSymbol(key);
+        var regId_1 = objKeys(registry.s).length;
+        newSymbol_1[UNIQUE_REGISTRY_ID] = function () { return regId_1 + "_" + newSymbol_1[TO_STRING](); };
+        registry.k[key] = newSymbol_1;
+        registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
+    }
+    return registry.k[key];
+}
+/*#__NO_SIDE_EFFECTS__*/
+function polyGetKnownSymbol(name) {
+    !_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
+    var result;
+    var knownName = _wellKnownSymbolMap[name];
+    if (knownName) {
+        result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+    }
+    return result;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function createCachedValue(value) {
+    return objDefineProp({
+        toJSON: function () { return value; }
+    }, "v", { value: value });
+}
+var WINDOW = "window";
+var _cachedGlobal;
+function _getGlobalInstFn(getFn, theArgs) {
+    var cachedValue;
+    return function () {
+        !_globalLazyTestHooks && _initTestHooks();
+        if (!cachedValue || _globalLazyTestHooks.lzy) {
+            cachedValue = createCachedValue(safe(getFn, theArgs).v);
+        }
+        return cachedValue.v;
+    };
+}
+function getGlobal(useCached) {
+    !_globalLazyTestHooks && _initTestHooks();
+    if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
+        _cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
+    }
+    return _cachedGlobal.v;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function getInst(name, useCached) {
+    var gbl;
+    if (!_cachedGlobal || useCached === false) {
+        gbl = getGlobal(useCached);
+    }
+    else {
+        gbl = _cachedGlobal.v;
+    }
+    if (gbl && gbl[name]) {
+        return gbl[name];
+    }
+    if (name === WINDOW) {
+        try {
+            return window;
+        }
+        catch (e) {
+        }
+    }
+    return NULL_VALUE;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function hasDocument() {
+    return !!( /*#__PURE__*/getDocument());
+}
+var getDocument = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["document"]));
+/*#__NO_SIDE_EFFECTS__*/
+function hasWindow() {
+    return !!( /*#__PURE__*/getWindow());
+}
+var getWindow = ( /*#__PURE__*/_getGlobalInstFn(getInst, [WINDOW]));
+var getNavigator = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["navigator"]));
+var _symbol;
+var _symbolFor;
+/*#__NO_SIDE_EFFECTS__*/
+function _initSymbol() {
+    _symbol = ( /*#__PURE__*/createCachedValue(safe((getInst), [SYMBOL]).v));
+    return _symbol;
+}
+function _getSymbolKey(key) {
+    var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+    return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function getKnownSymbol(name, noPoly) {
+    var knownName = _wellKnownSymbolMap[name];
+    !_globalLazyTestHooks && _initTestHooks();
+    var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+    return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function newSymbol(description, noPoly) {
+    !_globalLazyTestHooks && _initTestHooks();
+    var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+    return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function symbolFor(key) {
+    !_globalLazyTestHooks && _initTestHooks();
+    _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( /*#__PURE__*/createCachedValue(safe((_getSymbolKey), ["for"]).v)));
+    return (_symbolFor.v || polySymbolFor)(key);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isIterator(value) {
+    return !!value && isFunction(value.next);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function isIterable(value) {
+    return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
+}
+var _iterSymbol$1;
+function iterForOf(iter, callbackfn, thisArg) {
+    if (iter) {
+        if (!isIterator(iter)) {
+            !_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));
+            iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
+        }
+        if (isIterator(iter)) {
+            var err = UNDEF_VALUE;
+            var iterResult = UNDEF_VALUE;
+            try {
+                var count = 0;
+                while (!(iterResult = iter.next()).done) {
+                    if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
+                        break;
+                    }
+                    count++;
+                }
+            }
+            catch (failed) {
+                err = { e: failed };
+                if (iter.throw) {
+                    iterResult = NULL_VALUE;
+                    iter.throw(err);
+                }
+            }
+            finally {
+                try {
+                    if (iterResult && !iterResult.done) {
+                        iter.return && iter.return(iterResult);
+                    }
+                }
+                finally {
+                    if (err) {
+                        throw err.e;
+                    }
+                }
+            }
+        }
+    }
+}
+function arrAppend(target, elms) {
+    if (!isUndefined(elms) && target) {
+        if (isArray(elms)) {
+            fnApply(target.push, target, elms);
+        }
+        else if (isIterator(elms) || isIterable(elms)) {
+            iterForOf(elms, function (elm) {
+                target.push(elm);
+            });
+        }
+        else {
+            target.push(elms);
+        }
+    }
+    return target;
+}
+var arrIndexOf = ( /*#__PURE__*/_unwrapFunction("indexOf", ArrProto));
+var _isProtoArray;
+var objSetPrototypeOf = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, "setPrototypeOf")), _polyObjSetPrototypeOf));
+function _polyObjSetPrototypeOf(obj, proto) {
+    var _a;
+    !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
+    _isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function (key, value) { return obj[key] = value; });
+    return obj;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _createCustomError(name, d, b) {
+    safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
+    d = objSetPrototypeOf(d, b);
+    function __() {
+        this[CONSTRUCTOR] = d;
+        safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
+    }
+    d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
+    return d;
+}
+function _setName(baseClass, name) {
+    name && (baseClass[NAME] = name);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function createCustomError(name, constructCb, errorBase) {
+    var theBaseClass = errorBase || Error;
+    var orgName = theBaseClass[PROTOTYPE][NAME];
+    var captureFn = Error.captureStackTrace;
+    return _createCustomError(name, function () {
+        var _this = this;
+        var theArgs = arguments;
+        try {
+            safe(_setName, [theBaseClass, name]);
+            var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
+            if (_self !== _this) {
+                var orgProto = objGetPrototypeOf(_this);
+                if (orgProto !== objGetPrototypeOf(_self)) {
+                    objSetPrototypeOf(_self, orgProto);
+                }
+            }
+            captureFn && captureFn(_self, _this[CONSTRUCTOR]);
+            constructCb && constructCb(_self, theArgs);
+            return _self;
+        }
+        finally {
+            safe(_setName, [theBaseClass, orgName]);
+        }
+    }, theBaseClass);
+}
+/*#__NO_SIDE_EFFECTS__*/
+function _createTrimFn(exp) {
+    return function _doTrim(value) {
+        _throwIfNullOrUndefined(value);
+        if (value && value.replace) {
+            value = value.replace(exp, EMPTY);
+        }
+        return value;
+    };
+}
+var polyStrTrim = ( /*#__PURE__*/_createTrimFn(/^\s+|(?=\s)\s+$/g));
+var strTrim = ( /*#__PURE__*/_unwrapFunctionWithPoly("trim", StrProto, polyStrTrim));
+var mathFloor = ( /*#__PURE__*/_pureRef(MathCls, "floor"));
+var _fnToString;
+var _objCtrFnString;
+var _gblWindow;
+/*#__NO_SIDE_EFFECTS__*/
+function isPlainObject(value) {
+    if (!value || typeof value !== OBJECT) {
+        return false;
+    }
+    if (!_gblWindow) {
+        _gblWindow = hasWindow() ? getWindow() : true;
+    }
+    var result = false;
+    if (value !== _gblWindow) {
+        if (!_objCtrFnString) {
+            _fnToString = Function[PROTOTYPE][TO_STRING];
+            _objCtrFnString = _fnToString[CALL](ObjClass$1);
+        }
+        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;
+}
+/*#__NO_SIDE_EFFECTS__*/
+function perfNow() {
+    return utcNow();
+}
+var objGetOwnPropertyDescriptor = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass$1, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+var strEndsWith = ( /*#__PURE__*/_unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
+/*#__NO_SIDE_EFFECTS__*/
+function polyStrEndsWith(value, searchString, length) {
+    _throwIfNotString(value);
+    var searchValue = isString(searchString) ? searchString : asString(searchString);
+    var end = (!isUndefined(length) && length < value[LENGTH]) ? length : value[LENGTH];
+    return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
+}
+var strIndexOf = ( /*#__PURE__*/_unwrapFunction("indexOf", StrProto));
+var REF = "ref";
+var UNREF = "unref";
+var HAS_REF = "hasRef";
+var ENABLED = "enabled";
+/*#__NO_SIDE_EFFECTS__*/
+function _createTimerHandler(startTimer, refreshFn, cancelFn) {
+    var ref = true;
+    var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
+    var theTimerHandler;
+    function _unref() {
+        ref = false;
+        timerId && timerId[UNREF] && timerId[UNREF]();
+        return theTimerHandler;
+    }
+    function _cancel() {
+        timerId && cancelFn(timerId);
+        timerId = NULL_VALUE;
+    }
+    function _refresh() {
+        timerId = refreshFn(timerId);
+        if (!ref) {
+            _unref();
+        }
+        return theTimerHandler;
+    }
+    function _setEnabled(value) {
+        !value && timerId && _cancel();
+        value && !timerId && _refresh();
+    }
+    theTimerHandler = {
+        cancel: _cancel,
+        refresh: _refresh
+    };
+    theTimerHandler[HAS_REF] = function () {
+        if (timerId && timerId[HAS_REF]) {
+            return timerId[HAS_REF]();
+        }
+        return ref;
+    };
+    theTimerHandler[REF] = function () {
+        ref = true;
+        timerId && timerId[REF] && timerId[REF]();
+        return theTimerHandler;
+    };
+    theTimerHandler[UNREF] = _unref;
+    theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {
+        get: function () { return !!timerId; },
+        set: _setEnabled
+    });
+    return {
+        h: theTimerHandler,
+        dn: function () {
+            timerId = NULL_VALUE;
+        }
+    };
+}
+var _setTimeoutFn;
+var _clearTimeoutFn;
+function _resolveTimeoutFn(timeoutFn) {
+    var result = isFunction(timeoutFn) ? timeoutFn : _setTimeoutFn;
+    if (!result) {
+        var globalOverrides = _getGlobalConfig().tmOut || [];
+        if (isArray(globalOverrides) && globalOverrides.length > 0 && isFunction(globalOverrides[0])) {
+            result = globalOverrides[0];
+        }
+    }
+    return result || setTimeout;
+}
+function _resolveClearTimeoutFn(timeoutFn) {
+    var result = isFunction(timeoutFn) ? timeoutFn : _clearTimeoutFn;
+    if (!result) {
+        var globalOverrides = _getGlobalConfig().tmOut || [];
+        if (isArray(globalOverrides) && globalOverrides.length > 1 && isFunction(globalOverrides[1])) {
+            result = globalOverrides[1];
+        }
+    }
+    return result || clearTimeout;
+}
+function _createTimeoutWith(startTimer, overrideFn, theArgs) {
+    var isArr = isArray(overrideFn);
+    var len = isArr ? overrideFn.length : 0;
+    var setFn = _resolveTimeoutFn(len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE));
+    var clearFn = _resolveClearTimeoutFn(len > 1 ? overrideFn[1] : UNDEF_VALUE);
+    var timerFn = theArgs[0];
+    theArgs[0] = function () {
+        handler.dn();
+        fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));
+    };
+    var handler = _createTimerHandler(startTimer, function (timerId) {
+        if (timerId) {
+            if (timerId.refresh) {
+                timerId.refresh();
+                return timerId;
+            }
+            fnApply(clearFn, UNDEF_VALUE, [timerId]);
+        }
+        return fnApply(setFn, UNDEF_VALUE, theArgs);
+    }, function (timerId) {
+        fnApply(clearFn, UNDEF_VALUE, [timerId]);
+    });
+    return handler.h;
+}
+function scheduleTimeout(callback, timeout) {
+    return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));
+}
+
+var createValueMap = createTypeMap;
+
+var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_LENGTH = "length";
+var _DYN_WARN_TO_CONSOLE = "warnToConsole";
+var _DYN_THROW_INTERNAL = "throwInternal";
+var _DYN_WATCH = "watch";
+var _DYN_APPLY = "apply";
+var _DYN_PUSH = "push";
+var _DYN_SPLICE = "splice";
+var _DYN_LOGGER = "logger";
+var _DYN_CANCEL = "cancel";
+var _DYN_INITIALIZE = "initialize";
+var _DYN_IDENTIFIER = "identifier";
+var _DYN_IS_INITIALIZED = "isInitialized";
+var _DYN_GET_PLUGIN = "getPlugin";
+var _DYN_NAME = "name";
+var _DYN_PROCESS_NEXT = "processNext";
+var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
+var _DYN_ENABLED = "enabled";
+var _DYN_UNLOAD = "unload";
+var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+var _DYN_CREATE_NEW = "createNew";
+var _DYN_TEARDOWN = "teardown";
+var _DYN_MESSAGE_ID = "messageId";
+var _DYN_MESSAGE = "message";
+var _DYN_DIAG_LOG = "diagLog";
+var _DYN__DO_TEARDOWN = "_doTeardown";
+var _DYN_UPDATE = "update";
+var _DYN_GET_NEXT = "getNext";
+var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+var _DYN_USER_AGENT = "userAgent";
+var _DYN_SPLIT = "split";
+var _DYN_REPLACE = "replace";
+var _DYN_IS_CHILD_EVT = "isChildEvt";
+var _DYN_GET_CTX = "getCtx";
+var _DYN_SET_CTX = "setCtx";
+
+var aggregationErrorType;
+function throwAggregationError(message, sourceErrors) {
+    if (!aggregationErrorType) {
+        aggregationErrorType = createCustomError("AggregationError", function (self, args) {
+            if (args[_DYN_LENGTH ] > 1) {
+                self.errors = args[1];
+            }
+        });
+    }
+    var theMessage = message || "One or more errors occurred.";
+    arrForEach(sourceErrors, function (srcError, idx) {
+        theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
+    });
+    throw new aggregationErrorType(theMessage, sourceErrors || []);
+}
+
+var strShimFunction = "function";
+var strShimObject = "object";
+var strShimUndefined = "undefined";
+var strShimPrototype = "prototype";
+var ObjClass = Object;
+
+(getGlobal() || {})["Symbol"];
+(getGlobal() || {})["Reflect"];
+var strHasOwnProperty = "hasOwnProperty";
+var extendStaticsFn = function (d, b) {
+    extendStaticsFn = ObjClass["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$4;
+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$4 = {},
+        _a$4[strSetInstFuncs] = true,
+        _a$4[strUseBaseInst] = true,
+        _a$4),
+    n: 1000
+});
+function _isObjectOrArrayPrototype(target) {
+    return target && (target === Obj[Prototype] || target === Array[Prototype]);
+}
+function _isObjectArrayOrFunctionPrototype(target) {
+    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+}
+function _getObjProto(target) {
+    var newProto;
+    if (target) {
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
+        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+        newProto = target[DynProtoBaseProto] || curProto;
+        if (!objHasOwnProperty(target, DynProtoBaseProto)) {
+            delete target[DynProtoCurrent];
+            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+            target[DynProtoCurrent] = curProto;
+        }
+    }
+    return newProto;
+}
+function _forEachProp(target, func) {
+    var props = [];
+    if (_objGetOwnProps) {
+        props = _objGetOwnProps(target);
+    }
+    else {
+        for (var name_1 in target) {
+            if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                props.push(name_1);
+            }
+        }
+    }
+    if (props && props.length > 0) {
+        for (var lp = 0; lp < props.length; lp++) {
+            func(props[lp]);
+        }
+    }
+}
+function _isDynamicCandidate(target, funcName, skipOwn) {
+    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype);
+}
+function _throwTypeError(message) {
+    throwTypeError("DynamicProto: " + message);
+}
+function _getInstanceFuncs(thisTarget) {
+    var instFuncs = objCreate(null);
+    _forEachProp(thisTarget, function (name) {
+        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+            instFuncs[name] = thisTarget[name];
+        }
+    });
+    return instFuncs;
+}
+function _hasVisited(values, value) {
+    for (var lp = values.length - 1; lp >= 0; lp--) {
+        if (values[lp] === value) {
+            return true;
+        }
+    }
+    return false;
+}
+function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+    function _instFuncProxy(target, funcHost, funcName) {
+        var theFunc = funcHost[funcName];
+        if (theFunc[DynProxyTag] && useBaseInst) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
+            }
+        }
+        return function () {
+            return theFunc.apply(target, arguments);
+        };
+    }
+    var baseFuncs = objCreate(null);
+    _forEachProp(instFuncs, function (name) {
+        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+    });
+    var baseProto = _getObjProto(classProto);
+    var visited = [];
+    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+        _forEachProp(baseProto, function (name) {
+            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+            }
+        });
+        visited.push(baseProto);
+        baseProto = _getObjProto(baseProto);
+    }
+    return baseFuncs;
+}
+function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+    var instFunc = null;
+    if (target && objHasOwnProperty(proto, DynClassName)) {
+        var instFuncTable = target[DynInstFuncTable] || objCreate(null);
+        instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];
+        if (!instFunc) {
+            _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        }
+        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+            var canAddInst = !objHasOwnProperty(target, funcName);
+            var objProto = _getObjProto(target);
+            var visited = [];
+            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                var protoFunc = objProto[funcName];
+                if (protoFunc) {
+                    canAddInst = (protoFunc === currentDynProtoProxy);
+                    break;
+                }
+                visited.push(objProto);
+                objProto = _getObjProto(objProto);
+            }
+            try {
+                if (canAddInst) {
+                    target[funcName] = instFunc;
+                }
+                instFunc[DynInstChkTag] = 1;
+            }
+            catch (e) {
+                instFuncTable[DynAllowInstChkTag] = false;
+            }
+        }
+    }
+    return instFunc;
+}
+function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+    var protoFunc = proto[funcName];
+    if (protoFunc === currentDynProtoProxy) {
+        protoFunc = _getObjProto(proto)[funcName];
+    }
+    if (typeof protoFunc !== strFunction) {
+        _throwTypeError("[" + funcName + "] is not a " + strFunction);
+    }
+    return protoFunc;
+}
+function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+    function _createDynamicPrototype(proto, funcName) {
+        var dynProtoProxy = function () {
+            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+            return instFunc.apply(this, arguments);
+        };
+        dynProtoProxy[DynProxyTag] = 1;
+        return dynProtoProxy;
+    }
+    if (!_isObjectOrArrayPrototype(proto)) {
+        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
+        if (!_isObjectOrArrayPrototype(instFuncTable)) {
+            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || objCreate(null));
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            }
+            if (!_isObjectOrArrayPrototype(instFuncs_1)) {
+                _forEachProp(target, function (name) {
+                    if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                        instFuncs_1[name] = target[name];
+                        delete target[name];
+                        if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                            proto[name] = _createDynamicPrototype(proto, name);
+                        }
+                    }
+                });
+            }
+        }
+    }
+}
+function _checkPrototype(classProto, thisTarget) {
+    if (_objGetPrototypeOf) {
+        var visited = [];
+        var thisProto = _getObjProto(thisTarget);
+        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+            if (thisProto === classProto) {
+                return true;
+            }
+            visited.push(thisProto);
+            thisProto = _getObjProto(thisProto);
+        }
+        return false;
+    }
+    return true;
+}
+function _getObjName(target, unknownValue) {
+    if (objHasOwnProperty(target, Prototype)) {
+        return target.name || unknownValue || UnknownValue;
+    }
+    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+}
+function dynamicProto(theClass, target, delegateFunc, options) {
+    if (!objHasOwnProperty(theClass, Prototype)) {
+        _throwTypeError("theClass is an invalid class definition.");
+    }
+    var classProto = theClass[Prototype];
+    if (!_checkPrototype(classProto, target)) {
+        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+    }
+    var className = null;
+    if (objHasOwnProperty(classProto, DynClassName)) {
+        className = classProto[DynClassName];
+    }
+    else {
+        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+        _gblInst.n++;
+        classProto[DynClassName] = className;
+    }
+    var perfOptions = dynamicProto[DynProtoDefaultOptions];
+    var useBaseInst = !!perfOptions[strUseBaseInst];
+    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+        useBaseInst = !!options[strUseBaseInst];
+    }
+    var instFuncs = _getInstanceFuncs(target);
+    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+    delegateFunc(target, baseFuncs);
+    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+    if (setInstanceFunc && options) {
+        setInstanceFunc = !!options[strSetInstFuncs];
+    }
+    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+}
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+var UNDEFINED_VALUE = undefined;
+var STR_EMPTY$1 = "";
+var STR_CORE = "core";
+var STR_DISABLED = "disabled";
+var STR_EXTENSION_CONFIG = "extensionConfig";
+var STR_PROCESS_TELEMETRY = "processTelemetry";
+var STR_PRIORITY = "priority";
+var STR_GET_PERF_MGR = "getPerfMgr";
+var STR_DOMAIN = "domain";
+var STR_PATH = "path";
+var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+
+var rCamelCase = /-([a-z])/g;
+var rNormalizeInvalid = /([^\w\d_$])/g;
+var rLeadingNumeric = /^(\d+[\w\d_$])/;
+function isNotNullOrUndefined(value) {
+    return !isNullOrUndefined(value);
+}
+function normalizeJsName(name) {
+    var value = name;
+    if (value && isString(value)) {
+        value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
+            return letter.toUpperCase();
+        });
+        value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
+        value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
+            return "_" + match;
+        });
+    }
+    return value;
+}
+function strContains(value, search) {
+    if (value && search) {
+        return strIndexOf(value, search) !== -1;
+    }
+    return false;
+}
+function toISOString(date) {
+    return date && date.toISOString() || "";
+}
+function getExceptionName(object) {
+    if (isError(object)) {
+        return object[_DYN_NAME ];
+    }
+    return STR_EMPTY$1;
+}
+function setValue(target, field, value, valChk, srcChk) {
+    var theValue = value;
+    if (target) {
+        theValue = target[field];
+        if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
+            theValue = value;
+            target[field] = theValue;
+        }
+    }
+    return theValue;
+}
+function _createProxyFunction(source, funcName) {
+    var srcFunc = null;
+    var src = null;
+    if (isFunction(source)) {
+        srcFunc = source;
+    }
+    else {
+        src = source;
+    }
+    return function () {
+        var originalArguments = arguments;
+        if (srcFunc) {
+            src = srcFunc();
+        }
+        if (src) {
+            return src[funcName][_DYN_APPLY ](src, originalArguments);
+        }
+    };
+}
+function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
+    if (target && name && source) {
+        if (overwriteTarget !== false || isUndefined(target[name])) {
+            target[name] = _createProxyFunction(source, theFunc);
+        }
+    }
+}
+
+var strLocation = "location";
+var strConsole = "console";
+var strJSON = "JSON";
+var strCrypto = "crypto";
+var strMsCrypto = "msCrypto";
+var strMsie = "msie";
+var strTrident = "trident/";
+var _isTrident = null;
+var _navUserAgentCheck = null;
+var _enableMocks = false;
+function getLocation(checkForMock) {
+    if (checkForMock && _enableMocks) {
+        var mockLocation = getInst("__mockLocation");
+        if (mockLocation) {
+            return mockLocation;
+        }
+    }
+    if (typeof location === strShimObject && location) {
+        return location;
+    }
+    return getInst(strLocation);
+}
+function getConsole() {
+    if (typeof console !== strShimUndefined) {
+        return console;
+    }
+    return getInst(strConsole);
+}
+function hasJSON() {
+    return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
+}
+function getJSON() {
+    if (hasJSON()) {
+        return JSON || getInst(strJSON);
+    }
+    return null;
+}
+function getCrypto() {
+    return getInst(strCrypto);
+}
+function getMsCrypto() {
+    return getInst(strMsCrypto);
+}
+function isIE() {
+    var nav = getNavigator();
+    if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+        _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+        var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ]();
+        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    }
+    return _isTrident;
+}
+
+var UInt32Mask = 0x100000000;
+var MaxUInt32 = 0xffffffff;
+var SEED1 = 123456789;
+var SEED2 = 987654321;
+var _mwcSeeded = false;
+var _mwcW = SEED1;
+var _mwcZ = SEED2;
+function _mwcSeed(seedValue) {
+    if (seedValue < 0) {
+        seedValue >>>= 0;
+    }
+    _mwcW = (SEED1 + seedValue) & MaxUInt32;
+    _mwcZ = (SEED2 - seedValue) & MaxUInt32;
+    _mwcSeeded = true;
+}
+function _autoSeedMwc() {
+    try {
+        var now = utcNow() & 0x7fffffff;
+        _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+    }
+    catch (e) {
+    }
+}
+function random32(signed) {
+    var value = 0;
+    var c = getCrypto() || getMsCrypto();
+    if (c && c.getRandomValues) {
+        value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
+    }
+    if (value === 0 && isIE()) {
+        if (!_mwcSeeded) {
+            _autoSeedMwc();
+        }
+        value = mwcRandom32() & MaxUInt32;
+    }
+    if (value === 0) {
+        value = mathFloor((UInt32Mask * Math.random()) | 0);
+    }
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function mwcRandom32(signed) {
+    _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
+    _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
+    var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function newId(maxLength) {
+    if (maxLength === void 0) { maxLength = 22; }
+    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var number = random32() >>> 0;
+    var chars = 0;
+    var result = STR_EMPTY$1;
+    while (result[_DYN_LENGTH ] < maxLength) {
+        chars++;
+        result += base64chars.charAt(number & 0x3F);
+        number >>>= 6;
+        if (chars === 5) {
+            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+            chars = 0;
+        }
+    }
+    return result;
+}
+
+var version = '3.3.9';
+var instanceName = "." + newId(6);
+var _dataUid = 0;
+function _canAcceptData(target) {
+    return target.nodeType === 1 || target.nodeType === 9 || !(+target.nodeType);
+}
+function _getCache(data, target) {
+    var theCache = target[data.id];
+    if (!theCache) {
+        theCache = {};
+        try {
+            if (_canAcceptData(target)) {
+                objDefine(target, data.id, {
+                    e: false,
+                    v: theCache
+                });
+            }
+        }
+        catch (e) {
+        }
+    }
+    return theCache;
+}
+function createUniqueNamespace(name, includeVersion) {
+    if (includeVersion === void 0) { includeVersion = false; }
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
+}
+function createElmNodeData(name) {
+    var data = {
+        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
+        accept: function (target) {
+            return _canAcceptData(target);
+        },
+        get: function (target, name, defValue, addDefault) {
+            var theCache = target[data.id];
+            if (!theCache) {
+                if (addDefault) {
+                    theCache = _getCache(data, target);
+                    theCache[normalizeJsName(name)] = defValue;
+                }
+                return defValue;
+            }
+            return theCache[normalizeJsName(name)];
+        },
+        kill: function (target, name) {
+            if (target && target[name]) {
+                try {
+                    delete target[name];
+                }
+                catch (e) {
+                }
+            }
+        }
+    };
+    return data;
+}
+
+function _isConfigDefaults(value) {
+    return (value && isObject(value) && !isArray(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
+}
+function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+    var defValue;
+    var isDefaultValid = cfgDefaults.dfVal || isDefined;
+    if (theConfig && cfgDefaults.fb) {
+        var fallbacks = cfgDefaults.fb;
+        if (!isArray(fallbacks)) {
+            fallbacks = [fallbacks];
+        }
+        for (var lp = 0; lp < fallbacks[_DYN_LENGTH ]; lp++) {
+            var fallback = fallbacks[lp];
+            var fbValue = theConfig[fallback];
+            if (isDefaultValid(fbValue)) {
+                defValue = fbValue;
+            }
+            else if (dynamicHandler) {
+                fbValue = dynamicHandler.cfg[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+            }
+            if (isDefaultValid(defValue)) {
+                break;
+            }
+        }
+    }
+    if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+        defValue = cfgDefaults.v;
+    }
+    return defValue;
+}
+function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
+    var theValue = cfgDefaults;
+    if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
+        theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    if (theValue) {
+        if (_isConfigDefaults(theValue)) {
+            theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
+        }
+        var newValue_1;
+        if (isArray(theValue)) {
+            newValue_1 = [];
+            newValue_1[_DYN_LENGTH ] = theValue[_DYN_LENGTH ];
+        }
+        else if (isPlainObject(theValue)) {
+            newValue_1 = {};
+        }
+        if (newValue_1) {
+            objForEachKey(theValue, function (key, value) {
+                if (value && _isConfigDefaults(value)) {
+                    value = _resolveDefaultValue(dynamicHandler, theConfig, value);
+                }
+                newValue_1[key] = value;
+            });
+            theValue = newValue_1;
+        }
+    }
+    return theValue;
+}
+function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
+    var isValid;
+    var setFn;
+    var defValue;
+    var cfgDefaults = defaultValue;
+    var mergeDf;
+    var reference;
+    var readOnly;
+    var blkDynamicValue;
+    if (_isConfigDefaults(cfgDefaults)) {
+        isValid = cfgDefaults.isVal;
+        setFn = cfgDefaults.set;
+        readOnly = cfgDefaults.rdOnly;
+        blkDynamicValue = cfgDefaults.blkVal;
+        mergeDf = cfgDefaults.mrg;
+        reference = cfgDefaults.ref;
+        if (!reference && isUndefined(reference)) {
+            reference = !!mergeDf;
+        }
+        defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    else {
+        defValue = defaultValue;
+    }
+    if (blkDynamicValue) {
+        dynamicHandler.blkVal(theConfig, name);
+    }
+    var theValue;
+    var usingDefault = true;
+    var cfgValue = theConfig[name];
+    if (cfgValue || !isNullOrUndefined(cfgValue)) {
+        theValue = cfgValue;
+        usingDefault = false;
+        if (isValid && theValue !== defValue && !isValid(theValue)) {
+            theValue = defValue;
+            usingDefault = true;
+        }
+        if (setFn) {
+            theValue = setFn(theValue, defValue, theConfig);
+            usingDefault = theValue === defValue;
+        }
+    }
+    if (!usingDefault) {
+        if (isPlainObject(theValue) || isArray(defValue)) {
+            if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {
+                objForEachKey(defValue, function (dfName, dfValue) {
+                    _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
+                });
+            }
+        }
+    }
+    else if (defValue) {
+        theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
+    }
+    else {
+        theValue = defValue;
+    }
+    dynamicHandler.set(theConfig, name, theValue);
+    if (reference) {
+        dynamicHandler.ref(theConfig, name);
+    }
+    if (readOnly) {
+        dynamicHandler.rdOnly(theConfig, name);
+    }
+}
+
+var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+var BLOCK_DYNAMIC = symbolFor("[[ai_blkDynCfg_1]]");
+var FORCE_DYNAMIC = symbolFor("[[ai_frcDynCfg_1]]");
+function _cfgDeepCopy(source) {
+    if (source) {
+        var target_1;
+        if (isArray(source)) {
+            target_1 = [];
+            target_1[_DYN_LENGTH ] = source[_DYN_LENGTH ];
+        }
+        else if (isPlainObject(source)) {
+            target_1 = {};
+        }
+        if (target_1) {
+            objForEachKey(source, function (key, value) {
+                target_1[key] = _cfgDeepCopy(value);
+            });
+            return target_1;
+        }
+    }
+    return source;
+}
+function getDynamicConfigHandler(value) {
+    if (value) {
+        var handler = value[CFG_HANDLER_LINK] || value;
+        if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler;
+        }
+    }
+    return null;
+}
+function blockDynamicConversion(value) {
+    if (value && (isPlainObject(value) || isArray(value))) {
+        try {
+            value[BLOCK_DYNAMIC] = true;
+        }
+        catch (e) {
+        }
+    }
+    return value;
+}
+function _canMakeDynamic(getFunc, state, value) {
+    var result = false;
+    if (value && !getFunc[state.blkVal]) {
+        result = value[FORCE_DYNAMIC];
+        if (!result && !value[BLOCK_DYNAMIC]) {
+            result = isPlainObject(value) || isArray(value);
+        }
+    }
+    return result;
+}
+function throwInvalidAccess(message) {
+    throwTypeError("InvalidAccess:" + message);
+}
+
+var arrayMethodsToPatch = [
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice"
+];
+var _throwDynamicError = function (logger, name, desc, e) {
+    logger && logger[_DYN_THROW_INTERNAL ](3 , 108 , "".concat(desc, " [").concat(name, "] failed - ") + dumpObj(e));
+};
+function _patchArray(state, target, name) {
+    if (isArray(target)) {
+        arrForEach(arrayMethodsToPatch, function (method) {
+            var orgMethod = target[method];
+            target[method] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var result = orgMethod[_DYN_APPLY ](this, args);
+                _makeDynamicObject(state, target, name, "Patching");
+                return result;
+            };
+        });
+    }
+}
+function _getOwnPropGetter(target, name) {
+    var propDesc = objGetOwnPropertyDescriptor(target, name);
+    return propDesc && propDesc.get;
+}
+function _createDynamicProperty(state, theConfig, name, value) {
+    var detail = {
+        n: name,
+        h: [],
+        trk: function (handler) {
+            if (handler && handler.fn) {
+                if (arrIndexOf(detail.h, handler) === -1) {
+                    detail.h[_DYN_PUSH ](handler);
+                }
+                state.trk(handler, detail);
+            }
+        },
+        clr: function (handler) {
+            var idx = arrIndexOf(detail.h, handler);
+            if (idx !== -1) {
+                detail.h[_DYN_SPLICE ](idx, 1);
+            }
+        }
+    };
+    var checkDynamic = true;
+    var isObjectOrArray = false;
+    function _getProperty() {
+        if (checkDynamic) {
+            isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
+            if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
+                value = _makeDynamicObject(state, value, name, "Converting");
+            }
+            checkDynamic = false;
+        }
+        var activeHandler = state.act;
+        if (activeHandler) {
+            detail.trk(activeHandler);
+        }
+        return value;
+    }
+    _getProperty[state.prop] = {
+        chng: function () {
+            state.add(detail);
+        }
+    };
+    function _setProperty(newValue) {
+        if (value !== newValue) {
+            if (!!_getProperty[state.ro] && !state.upd) {
+                throwInvalidAccess("[" + name + "] is read-only:" + dumpObj(theConfig));
+            }
+            if (checkDynamic) {
+                isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);
+                checkDynamic = false;
+            }
+            var isReferenced = isObjectOrArray && _getProperty[state.rf];
+            if (isObjectOrArray) {
+                if (isReferenced) {
+                    objForEachKey(value, function (key) {
+                        value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
+                    });
+                    try {
+                        objForEachKey(newValue, function (key, theValue) {
+                            _setDynamicProperty(state, value, key, theValue);
+                        });
+                        newValue = value;
+                    }
+                    catch (e) {
+                        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Assigning", e);
+                        isObjectOrArray = false;
+                    }
+                }
+                else if (value && value[CFG_HANDLER_LINK]) {
+                    objForEachKey(value, function (key) {
+                        var getter = _getOwnPropGetter(value, key);
+                        if (getter) {
+                            var valueState = getter[state.prop];
+                            valueState && valueState.chng();
+                        }
+                    });
+                }
+            }
+            if (newValue !== value) {
+                var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);
+                if (!isReferenced && newIsObjectOrArray) {
+                    newValue = _makeDynamicObject(state, newValue, name, "Converting");
+                }
+                value = newValue;
+                isObjectOrArray = newIsObjectOrArray;
+            }
+            state.add(detail);
+        }
+    }
+    objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
+}
+function _setDynamicProperty(state, target, name, value) {
+    if (target) {
+        var getter = _getOwnPropGetter(target, name);
+        var isDynamic = getter && !!getter[state.prop];
+        if (!isDynamic) {
+            _createDynamicProperty(state, target, name, value);
+        }
+        else {
+            target[name] = value;
+        }
+    }
+    return target;
+}
+function _setDynamicPropertyState(state, target, name, flags) {
+    if (target) {
+        var getter = _getOwnPropGetter(target, name);
+        var isDynamic = getter && !!getter[state.prop];
+        var inPlace = flags && flags[0 ];
+        var rdOnly = flags && flags[1 ];
+        var blkProp = flags && flags[2 ];
+        if (!isDynamic) {
+            if (blkProp) {
+                try {
+                    blockDynamicConversion(target);
+                }
+                catch (e) {
+                    _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "Blocking", e);
+                }
+            }
+            try {
+                _setDynamicProperty(state, target, name, target[name]);
+                getter = _getOwnPropGetter(target, name);
+            }
+            catch (e) {
+                _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, "State", e);
+            }
+        }
+        if (inPlace) {
+            getter[state.rf] = inPlace;
+        }
+        if (rdOnly) {
+            getter[state.ro] = rdOnly;
+        }
+        if (blkProp) {
+            getter[state.blkVal] = true;
+        }
+    }
+    return target;
+}
+function _makeDynamicObject(state, target, name, desc) {
+    try {
+        objForEachKey(target, function (key, value) {
+            _setDynamicProperty(state, target, key, value);
+        });
+        if (!target[CFG_HANDLER_LINK]) {
+            objDefineProp(target, CFG_HANDLER_LINK, {
+                get: function () {
+                    return state.hdlr;
+                }
+            });
+            _patchArray(state, target, name);
+        }
+    }
+    catch (e) {
+        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER ], name, desc, e);
+    }
+    return target;
+}
+
+var symPrefix = "[[ai_";
+var symPostfix = "]]";
+function _createState(cfgHandler) {
+    var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyReferenced = newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyBlockValue = newSymbol(symPrefix + "blkVal" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyDetail = newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
+    var _waitingHandlers = null;
+    var _watcherTimer = null;
+    var theState;
+    function _useHandler(activeHandler, callback) {
+        var prevWatcher = theState.act;
+        try {
+            theState.act = activeHandler;
+            if (activeHandler && activeHandler[dynamicPropertyDetail]) {
+                arrForEach(activeHandler[dynamicPropertyDetail], function (detail) {
+                    detail.clr(activeHandler);
+                });
+                activeHandler[dynamicPropertyDetail] = [];
+            }
+            callback({
+                cfg: cfgHandler.cfg,
+                set: cfgHandler.set.bind(cfgHandler),
+                setDf: cfgHandler.setDf.bind(cfgHandler),
+                ref: cfgHandler.ref.bind(cfgHandler),
+                rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
+            });
+        }
+        catch (e) {
+            var logger = cfgHandler[_DYN_LOGGER ];
+            if (logger) {
+                logger[_DYN_THROW_INTERNAL ](1 , 107 , dumpObj(e));
+            }
+            throw e;
+        }
+        finally {
+            theState.act = prevWatcher || null;
+        }
+    }
+    function _notifyWatchers() {
+        if (_waitingHandlers) {
+            var notifyHandlers = _waitingHandlers;
+            _waitingHandlers = null;
+            _watcherTimer && _watcherTimer[_DYN_CANCEL ]();
+            _watcherTimer = null;
+            var watcherFailures_1 = [];
+            arrForEach(notifyHandlers, function (handler) {
+                if (handler) {
+                    if (handler[dynamicPropertyDetail]) {
+                        arrForEach(handler[dynamicPropertyDetail], function (detail) {
+                            detail.clr(handler);
+                        });
+                        handler[dynamicPropertyDetail] = null;
+                    }
+                    if (handler.fn) {
+                        try {
+                            _useHandler(handler, handler.fn);
+                        }
+                        catch (e) {
+                            watcherFailures_1[_DYN_PUSH ](e);
+                        }
+                    }
+                }
+            });
+            if (_waitingHandlers) {
+                try {
+                    _notifyWatchers();
+                }
+                catch (e) {
+                    watcherFailures_1[_DYN_PUSH ](e);
+                }
+            }
+            if (watcherFailures_1[_DYN_LENGTH ] > 0) {
+                throwAggregationError("Watcher error(s): ", watcherFailures_1);
+            }
+        }
+    }
+    function _addWatcher(detail) {
+        if (detail && detail.h[_DYN_LENGTH ] > 0) {
+            if (!_waitingHandlers) {
+                _waitingHandlers = [];
+            }
+            if (!_watcherTimer) {
+                _watcherTimer = scheduleTimeout(function () {
+                    _watcherTimer = null;
+                    _notifyWatchers();
+                }, 0);
+            }
+            for (var idx = 0; idx < detail.h[_DYN_LENGTH ]; idx++) {
+                var handler = detail.h[idx];
+                if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
+                    _waitingHandlers[_DYN_PUSH ](handler);
+                }
+            }
+        }
+    }
+    function _trackHandler(handler, detail) {
+        if (handler) {
+            var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
+            if (arrIndexOf(details, detail) === -1) {
+                details[_DYN_PUSH ](detail);
+            }
+        }
+    }
+    theState = {
+        prop: dynamicPropertySymbol,
+        ro: dynamicPropertyReadOnly,
+        rf: dynamicPropertyReferenced,
+        blkVal: dynamicPropertyBlockValue,
+        hdlr: cfgHandler,
+        add: _addWatcher,
+        notify: _notifyWatchers,
+        use: _useHandler,
+        trk: _trackHandler
+    };
+    return theState;
+}
+
+function _createAndUseHandler(state, configHandler) {
+    var handler = {
+        fn: configHandler,
+        rm: function () {
+            handler.fn = null;
+            state = null;
+            configHandler = null;
+        }
+    };
+    objDefine(handler, "toJSON", { v: function () { return "WatcherHandler" + (handler.fn ? "" : "[X]"); } });
+    state.use(handler, configHandler);
+    return handler;
+}
+function _createDynamicHandler(logger, target, inPlace) {
+    var dynamicHandler = getDynamicConfigHandler(target);
+    if (dynamicHandler) {
+        return dynamicHandler;
+    }
+    var uid = createUniqueNamespace("dyncfg", true);
+    var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+    var theState;
+    function _notifyWatchers() {
+        theState.notify();
+    }
+    function _setValue(target, name, value) {
+        try {
+            target = _setDynamicProperty(theState, target, name, value);
+        }
+        catch (e) {
+            _throwDynamicError(logger, name, "Setting value", e);
+        }
+        return target[name];
+    }
+    function _watch(configHandler) {
+        return _createAndUseHandler(theState, configHandler);
+    }
+    function _block(configHandler, allowUpdate) {
+        theState.use(null, function (details) {
+            var prevUpd = theState.upd;
+            try {
+                if (!isUndefined(allowUpdate)) {
+                    theState.upd = allowUpdate;
+                }
+                configHandler(details);
+            }
+            finally {
+                theState.upd = prevUpd;
+            }
+        });
+    }
+    function _ref(target, name) {
+        var _a;
+        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 ] = true, _a))[name];
+    }
+    function _rdOnly(target, name) {
+        var _a;
+        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 ] = true, _a))[name];
+    }
+    function _blkPropValue(target, name) {
+        var _a;
+        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 ] = true, _a))[name];
+    }
+    function _applyDefaults(theConfig, defaultValues) {
+        if (defaultValues) {
+            objForEachKey(defaultValues, function (name, value) {
+                _applyDefaultValue(cfgHandler, theConfig, name, value);
+            });
+        }
+        return theConfig;
+    }
+    var cfgHandler = {
+        uid: null,
+        cfg: newTarget,
+        logger: logger,
+        notify: _notifyWatchers,
+        set: _setValue,
+        setDf: _applyDefaults,
+        watch: _watch,
+        ref: _ref,
+        rdOnly: _rdOnly,
+        blkVal: _blkPropValue,
+        _block: _block
+    };
+    objDefine(cfgHandler, "uid", {
+        c: false,
+        e: false,
+        w: false,
+        v: uid
+    });
+    theState = _createState(cfgHandler);
+    _makeDynamicObject(theState, newTarget, "config", "Creating");
+    return cfgHandler;
+}
+function _logInvalidAccess(logger, message) {
+    if (logger) {
+        logger[_DYN_WARN_TO_CONSOLE ](message);
+        logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+    }
+    else {
+        throwInvalidAccess(message);
+    }
+}
+function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+    var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+    if (defaultConfig) {
+        dynamicHandler.setDf(dynamicHandler.cfg, defaultConfig);
+    }
+    return dynamicHandler;
+}
+function onConfigChange(config, configHandler, logger) {
+    var handler = config[CFG_HANDLER_LINK] || config;
+    if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+        return handler[_DYN_WATCH ](configHandler);
+    }
+    _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+    return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+}
+
+function cfgDfMerge(defaultValue) {
+    return {
+        mrg: true,
+        v: defaultValue
+    };
+}
+function cfgDfString(defaultValue) {
+    return {
+        isVal: isString,
+        v: asString(defaultValue || STR_EMPTY$1)
+    };
+}
+
+var _aiNamespace = null;
+function _getExtensionNamespace() {
+    var target = getInst("Microsoft");
+    if (target) {
+        _aiNamespace = target["ApplicationInsights"];
+    }
+    return _aiNamespace;
+}
+function getDebugExt(config) {
+    var ns = _aiNamespace;
+    if (!ns && config.disableDbgExt !== true) {
+        ns = _aiNamespace || _getExtensionNamespace();
+    }
+    return ns ? ns["ChromeDbgExt"] : null;
+}
+
+var _a$3;
+var STR_WARN_TO_CONSOLE = "warnToConsole";
+var AiNonUserActionablePrefix = "AI (Internal): ";
+var AiUserActionablePrefix = "AI: ";
+var AIInternalMessagePrefix = "AITR_";
+var defaultValues$1 = {
+    loggingLevelConsole: 0,
+    loggingLevelTelemetry: 1,
+    maxMessageLimit: 25,
+    enableDebug: false
+};
+var _logFuncs = (_a$3 = {},
+    _a$3[0 ] = null,
+    _a$3[1 ] = "errorToConsole",
+    _a$3[2 ] = STR_WARN_TO_CONSOLE,
+    _a$3[3 ] = "debugToConsole",
+    _a$3);
+function _sanitizeDiagnosticText(text) {
+    if (text) {
+        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
+    }
+    return STR_EMPTY$1;
+}
+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$1;
+        if (hasJSON()) {
+            strProps = getJSON().stringify(properties);
+        }
+        var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
+            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
+        _self[_DYN_MESSAGE ] += diagnosticText;
+    }
+    _InternalLogMessage.dataType = "MessageData";
+    return _InternalLogMessage;
+}());
+function safeGetLogger(core, config) {
+    return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
+}
+var DiagnosticLogger = /** @class */ (function () {
+    function DiagnosticLogger(config) {
+        this.identifier = "DiagnosticLogger";
+        this.queue = [];
+        var _messageCount = 0;
+        var _messageLogged = {};
+        var _loggingLevelConsole;
+        var _loggingLevelTelemetry;
+        var _maxInternalMessageLimit;
+        var _enableDebug;
+        var _unloadHandler;
+        dynamicProto(DiagnosticLogger, this, function (_self) {
+            _unloadHandler = _setDefaultsFromConfig(config || {});
+            _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+            _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
+                if (isUserAct === void 0) { isUserAct = false; }
+                var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
+                if (_enableDebug) {
+                    throw dumpObj(message);
+                }
+                else {
+                    var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
+                    if (!isUndefined(message[_DYN_MESSAGE ])) {
+                        if (isUserAct) {
+                            var messageKey = +message[_DYN_MESSAGE_ID ];
+                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE ]);
+                                _messageLogged[messageKey] = true;
+                            }
+                        }
+                        else {
+                            if (_loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE ]);
+                            }
+                        }
+                        _logInternalMessage(severity, message);
+                    }
+                    else {
+                        _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
+                    }
+                }
+            };
+            _self.debugToConsole = function (message) {
+                _logToConsole("debug", message);
+                _debugExtMsg("warning", message);
+            };
+            _self[_DYN_WARN_TO_CONSOLE ] = function (message) {
+                _logToConsole("warn", message);
+                _debugExtMsg("warning", message);
+            };
+            _self.errorToConsole = function (message) {
+                _logToConsole("error", message);
+                _debugExtMsg("error", message);
+            };
+            _self.resetInternalMessageCount = function () {
+                _messageCount = 0;
+                _messageLogged = {};
+            };
+            _self.logInternalMessage = _logInternalMessage;
+            _self[_DYN_UNLOAD ] = function (isAsync) {
+                _unloadHandler && _unloadHandler.rm();
+                _unloadHandler = null;
+            };
+            function _logInternalMessage(severity, message) {
+                if (_areInternalMessagesThrottled()) {
+                    return;
+                }
+                var logMessage = true;
+                var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
+                if (_messageLogged[messageKey]) {
+                    logMessage = false;
+                }
+                else {
+                    _messageLogged[messageKey] = true;
+                }
+                if (logMessage) {
+                    if (severity <= _loggingLevelTelemetry) {
+                        _self.queue[_DYN_PUSH ](message);
+                        _messageCount++;
+                        _debugExtMsg((severity === 1  ? "error" : "warn"), message);
+                    }
+                    if (_messageCount === _maxInternalMessageLimit) {
+                        var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
+                        var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
+                        _self.queue[_DYN_PUSH ](throttleMessage);
+                        if (severity === 1 ) {
+                            _self.errorToConsole(throttleLimitMessage);
+                        }
+                        else {
+                            _self[_DYN_WARN_TO_CONSOLE ](throttleLimitMessage);
+                        }
+                    }
+                }
+            }
+            function _setDefaultsFromConfig(config) {
+                return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
+                    var config = details.cfg;
+                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                    _maxInternalMessageLimit = config.maxMessageLimit;
+                    _enableDebug = config.enableDebug;
+                });
+            }
+            function _areInternalMessagesThrottled() {
+                return _messageCount >= _maxInternalMessageLimit;
+            }
+            function _debugExtMsg(name, data) {
+                var dbgExt = getDebugExt(config || {});
+                if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
+                    dbgExt[_DYN_DIAG_LOG ](name, data);
+                }
+            }
+        });
+    }
+    DiagnosticLogger.__ieDyn=1;
+    return DiagnosticLogger;
+}());
+function _getLogger(logger) {
+    return (logger || new DiagnosticLogger());
+}
+function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
+    if (isUserAct === void 0) { isUserAct = false; }
+    _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
+}
+
+var _a$2, _b;
+var strToGMTString = "toGMTString";
+var strToUTCString = "toUTCString";
+var strCookie = "cookie";
+var strExpires = "expires";
+var strIsCookieUseDisabled = "isCookieUseDisabled";
+var strDisableCookiesUsage = "disableCookiesUsage";
+var strConfigCookieMgr = "_ckMgr";
+var _supportsCookies = null;
+var _allowUaSameSite = null;
+var _parsedCookieValue = null;
+var _doc;
+var _cookieCache = {};
+var _globalCookieConfig = {};
+var rootDefaultConfig = (_a$2 = {
+        cookieCfg: cfgDfMerge((_b = {},
+            _b[STR_DOMAIN] = { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+            _b.path = { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+            _b.enabled = UNDEFINED_VALUE,
+            _b.ignoreCookies = UNDEFINED_VALUE,
+            _b.blockedCookies = UNDEFINED_VALUE,
+            _b)),
+        cookieDomain: UNDEFINED_VALUE,
+        cookiePath: UNDEFINED_VALUE
+    },
+    _a$2[strDisableCookiesUsage] = UNDEFINED_VALUE,
+    _a$2);
+function _getDoc() {
+    !_doc && (_doc = getLazy(function () { return getDocument(); }));
+}
+function _gblCookieMgr(config, logger) {
+    var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
+    if (!inst) {
+        inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);
+        _globalCookieConfig[strConfigCookieMgr] = inst;
+    }
+    return inst;
+}
+function _isMgrEnabled(cookieMgr) {
+    if (cookieMgr) {
+        return cookieMgr.isEnabled();
+    }
+    return true;
+}
+function _isIgnoredCookie(cookieMgrCfg, name) {
+    if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
+        return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;
+    }
+    return false;
+}
+function _isBlockedCookie(cookieMgrCfg, name) {
+    if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {
+        if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {
+            return true;
+        }
+    }
+    return _isIgnoredCookie(cookieMgrCfg, name);
+}
+function _isCfgEnabled(rootConfig, cookieMgrConfig) {
+    var isCfgEnabled = cookieMgrConfig[_DYN_ENABLED ];
+    if (isNullOrUndefined(isCfgEnabled)) {
+        var cookieEnabled = void 0;
+        if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
+            cookieEnabled = !rootConfig[strIsCookieUseDisabled];
+        }
+        if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+            cookieEnabled = !rootConfig[strDisableCookiesUsage];
+        }
+        isCfgEnabled = cookieEnabled;
+    }
+    return isCfgEnabled;
+}
+function safeGetCookieMgr(core, config) {
+    var cookieMgr;
+    if (core) {
+        cookieMgr = core.getCookieMgr();
+    }
+    else if (config) {
+        var cookieCfg = config.cookieCfg;
+        if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
+            cookieMgr = cookieCfg[strConfigCookieMgr];
+        }
+        else {
+            cookieMgr = createCookieMgr(config);
+        }
+    }
+    if (!cookieMgr) {
+        cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER ]);
+    }
+    return cookieMgr;
+}
+function createCookieMgr(rootConfig, logger) {
+    var cookieMgrConfig;
+    var _path;
+    var _domain;
+    var unloadHandler;
+    var _enabled;
+    var _getCookieFn;
+    var _setCookieFn;
+    var _delCookieFn;
+    rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
+    unloadHandler = onConfigChange(rootConfig, function (details) {
+        details.setDf(details.cfg, rootDefaultConfig);
+        cookieMgrConfig = details.ref(details.cfg, "cookieCfg");
+        _path = cookieMgrConfig[STR_PATH ] || "/";
+        _domain = cookieMgrConfig[STR_DOMAIN ];
+        _enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false;
+        _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
+        _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+        _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
+    }, logger);
+    var cookieMgr = {
+        isEnabled: function () {
+            var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger);
+            var gblManager = _globalCookieConfig[strConfigCookieMgr];
+            if (enabled && gblManager && cookieMgr !== gblManager) {
+                enabled = _isMgrEnabled(gblManager);
+            }
+            return enabled;
+        },
+        setEnabled: function (value) {
+            _enabled = value !== false;
+            cookieMgrConfig[_DYN_ENABLED ] = value;
+        },
+        set: function (name, value, maxAgeSec, domain, path) {
+            var result = false;
+            if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
+                var values = {};
+                var theValue = strTrim(value || STR_EMPTY$1);
+                var idx = strIndexOf(theValue, ";");
+                if (idx !== -1) {
+                    theValue = strTrim(strLeft(value, idx));
+                    values = _extractParts(strSubstring(value, idx + 1));
+                }
+                setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
+                if (!isNullOrUndefined(maxAgeSec)) {
+                    var _isIE = isIE();
+                    if (isUndefined(values[strExpires])) {
+                        var nowMs = utcNow();
+                        var expireMs = nowMs + (maxAgeSec * 1000);
+                        if (expireMs > 0) {
+                            var expiry = new Date();
+                            expiry.setTime(expireMs);
+                            setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY$1, isTruthy);
+                        }
+                    }
+                    if (!_isIE) {
+                        setValue(values, "max-age", STR_EMPTY$1 + maxAgeSec, null, isUndefined);
+                    }
+                }
+                var location_1 = getLocation();
+                if (location_1 && location_1.protocol === "https:") {
+                    setValue(values, "secure", null, null, isUndefined);
+                    if (_allowUaSameSite === null) {
+                        _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+                    }
+                    if (_allowUaSameSite) {
+                        setValue(values, "SameSite", "None", null, isUndefined);
+                    }
+                }
+                setValue(values, STR_PATH, path || _path, null, isUndefined);
+                _setCookieFn(name, _formatCookieValue(theValue, values));
+                result = true;
+            }
+            return result;
+        },
+        get: function (name) {
+            var value = STR_EMPTY$1;
+            if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
+                value = _getCookieFn(name);
+            }
+            return value;
+        },
+        del: function (name, path) {
+            var result = false;
+            if (_isMgrEnabled(cookieMgr)) {
+                result = cookieMgr.purge(name, path);
+            }
+            return result;
+        },
+        purge: function (name, path) {
+            var _a;
+            var result = false;
+            if (areCookiesSupported(logger)) {
+                var values = (_a = {},
+                    _a[STR_PATH] = path ? path : "/",
+                    _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
+                    _a);
+                if (!isIE()) {
+                    values["max-age"] = "0";
+                }
+                _delCookieFn(name, _formatCookieValue(STR_EMPTY$1, values));
+                result = true;
+            }
+            return result;
+        },
+        unload: function (isAsync) {
+            unloadHandler && unloadHandler.rm();
+            unloadHandler = null;
+        }
+    };
+    cookieMgr[strConfigCookieMgr] = cookieMgr;
+    return cookieMgr;
+}
+function areCookiesSupported(logger) {
+    if (_supportsCookies === null) {
+        _supportsCookies = false;
+        !_doc && _getDoc();
+        try {
+            var doc = _doc.v || {};
+            _supportsCookies = doc[strCookie] !== undefined;
+        }
+        catch (e) {
+            _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return _supportsCookies;
+}
+function _extractParts(theValue) {
+    var values = {};
+    if (theValue && theValue[_DYN_LENGTH ]) {
+        var parts = strTrim(theValue)[_DYN_SPLIT ](";");
+        arrForEach(parts, function (thePart) {
+            thePart = strTrim(thePart || STR_EMPTY$1);
+            if (thePart) {
+                var idx = strIndexOf(thePart, "=");
+                if (idx === -1) {
+                    values[thePart] = null;
+                }
+                else {
+                    values[strTrim(strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));
+                }
+            }
+        });
+    }
+    return values;
+}
+function _formatDate(theDate, func) {
+    if (isFunction(theDate[func])) {
+        return theDate[func]();
+    }
+    return null;
+}
+function _formatCookieValue(value, values) {
+    var cookieValue = value || STR_EMPTY$1;
+    objForEachKey(values, function (name, theValue) {
+        cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY$1);
+    });
+    return cookieValue;
+}
+function _getCookieValue(name) {
+    var cookieValue = STR_EMPTY$1;
+    !_doc && _getDoc();
+    if (_doc.v) {
+        var theCookie = _doc.v[strCookie] || STR_EMPTY$1;
+        if (_parsedCookieValue !== theCookie) {
+            _cookieCache = _extractParts(theCookie);
+            _parsedCookieValue = theCookie;
+        }
+        cookieValue = strTrim(_cookieCache[name] || STR_EMPTY$1);
+    }
+    return cookieValue;
+}
+function _setCookieValue(name, cookieValue) {
+    !_doc && _getDoc();
+    if (_doc.v) {
+        _doc.v[strCookie] = name + "=" + cookieValue;
+    }
+}
+function uaDisallowsSameSiteNone(userAgent) {
+    if (!isString(userAgent)) {
+        return false;
+    }
+    if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
+        return true;
+    }
+    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
+        return true;
+    }
+    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
+        return true;
+    }
+    if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
+        return true;
+    }
+    if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
+        return true;
+    }
+    if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
+        return true;
+    }
+    return false;
+}
+
+var strExecutionContextKey = "ctx";
+var strParentContextKey = "ParentContextKey";
+var strChildrenContextKey = "ChildrenContextKey";
+var PerfEvent = /** @class */ (function () {
+    function PerfEvent(name, payloadDetails, isAsync) {
+        var _self = this;
+        _self.start = utcNow();
+        _self[_DYN_NAME ] = name;
+        _self.isAsync = isAsync;
+        _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
+        if (isFunction(payloadDetails)) {
+            var theDetails_1;
+            objDefine(_self, "payload", {
+                g: function () {
+                    if (!theDetails_1 && isFunction(payloadDetails)) {
+                        theDetails_1 = payloadDetails();
+                        payloadDetails = null;
+                    }
+                    return theDetails_1;
+                }
+            });
+        }
+        _self[_DYN_GET_CTX ] = function (key) {
+            if (key) {
+                if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
+                    return _self[key];
+                }
+                return (_self[strExecutionContextKey] || {})[key];
+            }
+            return null;
+        };
+        _self[_DYN_SET_CTX ] = function (key, value) {
+            if (key) {
+                if (key === PerfEvent[strParentContextKey]) {
+                    if (!_self[key]) {
+                        _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
+                    }
+                    _self[key] = value;
+                }
+                else if (key === PerfEvent[strChildrenContextKey]) {
+                    _self[key] = value;
+                }
+                else {
+                    var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                    ctx[key] = value;
+                }
+            }
+        };
+        _self.complete = function () {
+            var childTime = 0;
+            var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+            if (isArray(childEvts)) {
+                for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
+                    var childEvt = childEvts[lp];
+                    if (childEvt) {
+                        childTime += childEvt.time;
+                    }
+                }
+            }
+            _self.time = utcNow() - _self.start;
+            _self.exTime = _self.time - childTime;
+            _self.complete = function () { };
+        };
+    }
+    PerfEvent.ParentContextKey = "parent";
+    PerfEvent.ChildrenContextKey = "childEvts";
+    return PerfEvent;
+}());
+var doPerfActiveKey = "CoreUtils.doPerf";
+function doPerf(mgrSource, getSource, func, details, isAsync) {
+    if (mgrSource) {
+        var perfMgr = mgrSource;
+        if (perfMgr[STR_GET_PERF_MGR]) {
+            perfMgr = perfMgr[STR_GET_PERF_MGR]();
+        }
+        if (perfMgr) {
+            var perfEvt = void 0;
+            var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
+            try {
+                perfEvt = perfMgr.create(getSource(), details, isAsync);
+                if (perfEvt) {
+                    if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                        if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                            var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                            if (!children) {
+                                children = [];
+                                currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
+                            }
+                            children[_DYN_PUSH ](perfEvt);
+                        }
+                    }
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
+                    return func(perfEvt);
+                }
+            }
+            catch (ex) {
+                if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                    perfEvt[_DYN_SET_CTX ]("exception", ex);
+                }
+            }
+            finally {
+                if (perfEvt) {
+                    perfMgr.fire(perfEvt);
+                }
+                perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
+            }
+        }
+    }
+    return func();
+}
+
+function newGuid() {
+    var uuid = generateW3CId();
+    return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
+}
+function generateW3CId() {
+    var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+    var oct = STR_EMPTY$1, tmp;
+    for (var a = 0; a < 4; a++) {
+        tmp = random32();
+        oct +=
+            hexValues[tmp & 0xF] +
+                hexValues[tmp >> 4 & 0xF] +
+                hexValues[tmp >> 8 & 0xF] +
+                hexValues[tmp >> 12 & 0xF] +
+                hexValues[tmp >> 16 & 0xF] +
+                hexValues[tmp >> 20 & 0xF] +
+                hexValues[tmp >> 24 & 0xF] +
+                hexValues[tmp >> 28 & 0xF];
+    }
+    var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
+    return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+}
+
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var INVALID_SPAN_ID = "0000000000000000";
+function _isValid(value, len, invalidValue) {
+    if (value && value[_DYN_LENGTH ] === len && value !== invalidValue) {
+        return !!value.match(/^[\da-f]*$/i);
+    }
+    return false;
+}
+function isValidTraceId(value) {
+    return _isValid(value, 32, INVALID_TRACE_ID);
+}
+function isValidSpanId(value) {
+    return _isValid(value, 16, INVALID_SPAN_ID);
+}
+
+var pluginStateData = createElmNodeData("plugin");
+function _getPluginState(plugin) {
+    return pluginStateData.get(plugin, "state", {}, true);
+}
+
+var strTelemetryPluginChain = "TelemetryPluginChain";
+var strHasRunFlags = "_hasRun";
+var strGetTelCtx = "_getTelCtx";
+var _chainId = 0;
+function _getNextProxyStart(proxy, core, startAt) {
+    while (proxy) {
+        if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
+            return proxy;
+        }
+        proxy = proxy[_DYN_GET_NEXT ]();
+    }
+    return createTelemetryProxyChain([startAt], core.config || {}, core);
+}
+function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
+    var _nextProxy = null;
+    var _onComplete = [];
+    if (!dynamicHandler) {
+        dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER ]);
+    }
+    if (startAt !== null) {
+        _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
+    }
+    var context = {
+        _next: _moveNext,
+        ctx: {
+            core: function () {
+                return core;
+            },
+            diagLog: function () {
+                return safeGetLogger(core, dynamicHandler.cfg);
+            },
+            getCfg: function () {
+                return dynamicHandler.cfg;
+            },
+            getExtCfg: _resolveExtCfg,
+            getConfig: _getConfig,
+            hasNext: function () {
+                return !!_nextProxy;
+            },
+            getNext: function () {
+                return _nextProxy;
+            },
+            setNext: function (nextPlugin) {
+                _nextProxy = nextPlugin;
+            },
+            iterate: _iterateChain,
+            onComplete: _addOnComplete
+        }
+    };
+    function _addOnComplete(onComplete, that) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        if (onComplete) {
+            _onComplete[_DYN_PUSH ]({
+                func: onComplete,
+                self: !isUndefined(that) ? that : context.ctx,
+                args: args
+            });
+        }
+    }
+    function _moveNext() {
+        var nextProxy = _nextProxy;
+        _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
+        if (!nextProxy) {
+            var onComplete = _onComplete;
+            if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
+                arrForEach(onComplete, function (completeDetails) {
+                    try {
+                        completeDetails.func.call(completeDetails.self, completeDetails.args);
+                    }
+                    catch (e) {
+                        _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
+                    }
+                });
+                _onComplete = [];
+            }
+        }
+        return nextProxy;
+    }
+    function _getExtCfg(identifier, createIfMissing) {
+        var idCfg = null;
+        var cfg = dynamicHandler.cfg;
+        if (cfg && identifier) {
+            var extCfg = cfg[STR_EXTENSION_CONFIG ];
+            if (!extCfg && createIfMissing) {
+                extCfg = {};
+            }
+            cfg[STR_EXTENSION_CONFIG] = extCfg;
+            extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);
+            if (extCfg) {
+                idCfg = extCfg[identifier];
+                if (!idCfg && createIfMissing) {
+                    idCfg = {};
+                }
+                extCfg[identifier] = idCfg;
+                idCfg = dynamicHandler.ref(extCfg, identifier);
+            }
+        }
+        return idCfg;
+    }
+    function _resolveExtCfg(identifier, defaultValues) {
+        var newConfig = _getExtCfg(identifier, true);
+        if (defaultValues) {
+            objForEachKey(defaultValues, function (field, defaultValue) {
+                if (isNullOrUndefined(newConfig[field])) {
+                    var cfgValue = dynamicHandler.cfg[field];
+                    if (cfgValue || !isNullOrUndefined(cfgValue)) {
+                        newConfig[field] = cfgValue;
+                    }
+                }
+                _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
+            });
+        }
+        return dynamicHandler.setDf(newConfig, defaultValues);
+    }
+    function _getConfig(identifier, field, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = false; }
+        var theValue;
+        var extConfig = _getExtCfg(identifier, false);
+        var rootConfig = dynamicHandler.cfg;
+        if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
+            theValue = extConfig[field];
+        }
+        else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {
+            theValue = rootConfig[field];
+        }
+        return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;
+    }
+    function _iterateChain(cb) {
+        var nextPlugin;
+        while (!!(nextPlugin = context._next())) {
+            var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
+            if (plugin) {
+                cb(plugin);
+            }
+        }
+    }
+    return context;
+}
+function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {
+    var config = createDynamicConfig(cfg);
+    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+    var context = internalContext.ctx;
+    function _processNext(env) {
+        var nextPlugin = internalContext._next();
+        if (nextPlugin) {
+            nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+        }
+        return !nextPlugin;
+    }
+    function _createNew(plugins, startAt) {
+        if (plugins === void 0) { plugins = null; }
+        if (isArray(plugins)) {
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
+        }
+        return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config.cfg, core, startAt);
+    }
+    context[_DYN_PROCESS_NEXT ] = _processNext;
+    context[_DYN_CREATE_NEW ] = _createNew;
+    return context;
+}
+function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
+    var config = createDynamicConfig(core.config);
+    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+    var context = internalContext.ctx;
+    function _processNext(unloadState) {
+        var nextPlugin = internalContext._next();
+        nextPlugin && nextPlugin[_DYN_UNLOAD ](context, unloadState);
+        return !nextPlugin;
+    }
+    function _createNew(plugins, startAt) {
+        if (plugins === void 0) { plugins = null; }
+        if (isArray(plugins)) {
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
+        }
+        return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
+    }
+    context[_DYN_PROCESS_NEXT ] = _processNext;
+    context[_DYN_CREATE_NEW ] = _createNew;
+    return context;
+}
+function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
+    var config = createDynamicConfig(core.config);
+    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+    var context = internalContext.ctx;
+    function _processNext(updateState) {
+        return context.iterate(function (plugin) {
+            if (isFunction(plugin[_DYN_UPDATE ])) {
+                plugin[_DYN_UPDATE ](context, updateState);
+            }
+        });
+    }
+    function _createNew(plugins, startAt) {
+        if (plugins === void 0) { plugins = null; }
+        if (isArray(plugins)) {
+            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);
+        }
+        return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
+    }
+    context[_DYN_PROCESS_NEXT ] = _processNext;
+    context[_DYN_CREATE_NEW ] = _createNew;
+    return context;
+}
+function createTelemetryProxyChain(plugins, config, core, startAt) {
+    var firstProxy = null;
+    var add = startAt ? false : true;
+    if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
+        var lastProxy_1 = null;
+        arrForEach(plugins, function (thePlugin) {
+            if (!add && startAt === thePlugin) {
+                add = true;
+            }
+            if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
+                var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
+                if (!firstProxy) {
+                    firstProxy = newProxy;
+                }
+                if (lastProxy_1) {
+                    lastProxy_1._setNext(newProxy);
+                }
+                lastProxy_1 = newProxy;
+            }
+        });
+    }
+    if (startAt && !firstProxy) {
+        return createTelemetryProxyChain([startAt], config, core);
+    }
+    return firstProxy;
+}
+function createTelemetryPluginProxy(plugin, config, core) {
+    var nextProxy = null;
+    var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
+    var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
+    var chainId;
+    if (plugin) {
+        chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
+    }
+    else {
+        chainId = "Unknown-0-" + _chainId++;
+    }
+    var proxyChain = {
+        getPlugin: function () {
+            return plugin;
+        },
+        getNext: function () {
+            return nextProxy;
+        },
+        processTelemetry: _processTelemetry,
+        unload: _unloadPlugin,
+        update: _updatePlugin,
+        _id: chainId,
+        _setNext: function (nextPlugin) {
+            nextProxy = nextPlugin;
+        }
+    };
+    function _getTelCtx() {
+        var itemCtx;
+        if (plugin && isFunction(plugin[strGetTelCtx])) {
+            itemCtx = plugin[strGetTelCtx]();
+        }
+        if (!itemCtx) {
+            itemCtx = createProcessTelemetryContext(proxyChain, config, core);
+        }
+        return itemCtx;
+    }
+    function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
+        var hasRun = false;
+        var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
+        var hasRunContext = itemCtx[strHasRunFlags];
+        if (!hasRunContext) {
+            hasRunContext = itemCtx[strHasRunFlags] = {};
+        }
+        itemCtx.setNext(nextProxy);
+        if (plugin) {
+            doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
+                hasRunContext[chainId] = true;
+                try {
+                    var nextId = nextProxy ? nextProxy._id : STR_EMPTY$1;
+                    if (nextId) {
+                        hasRunContext[nextId] = false;
+                    }
+                    hasRun = processPluginFn(itemCtx);
+                }
+                catch (error) {
+                    var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
+                    if (hasNextRun) {
+                        hasRun = true;
+                    }
+                    if (!nextProxy || !hasNextRun) {
+                        _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                    }
+                }
+            }, details, isAsync);
+        }
+        return hasRun;
+    }
+    function _processTelemetry(env, itemCtx) {
+        itemCtx = itemCtx || _getTelCtx();
+        function _callProcessTelemetry(itemCtx) {
+            if (!plugin || !hasProcessTelemetry) {
+                return false;
+            }
+            var pluginState = _getPluginState(plugin);
+            if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
+                return false;
+            }
+            if (hasSetNext) {
+                plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
+            }
+            plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
+            return true;
+        }
+        if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function () { return ({ item: env }); }, !(env.sync))) {
+            itemCtx[_DYN_PROCESS_NEXT ](env);
+        }
+    }
+    function _unloadPlugin(unloadCtx, unloadState) {
+        function _callTeardown() {
+            var hasRun = false;
+            if (plugin) {
+                var pluginState = _getPluginState(plugin);
+                var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                    pluginState[STR_CORE ] = null;
+                    pluginState[_DYN_TEARDOWN ] = true;
+                    pluginState[_DYN_IS_INITIALIZED ] = false;
+                    if (plugin[_DYN_TEARDOWN ] && plugin[_DYN_TEARDOWN ](unloadCtx, unloadState) === true) {
+                        hasRun = true;
+                    }
+                }
+            }
+            return hasRun;
+        }
+        if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState.isAsync)) {
+            unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
+        }
+    }
+    function _updatePlugin(updateCtx, updateState) {
+        function _callUpdate() {
+            var hasRun = false;
+            if (plugin) {
+                var pluginState = _getPluginState(plugin);
+                var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                    if (plugin[_DYN_UPDATE ] && plugin[_DYN_UPDATE ](updateCtx, updateState) === true) {
+                        hasRun = true;
+                    }
+                }
+            }
+            return hasRun;
+        }
+        if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
+            updateCtx[_DYN_PROCESS_NEXT ](updateState);
+        }
+    }
+    return objFreeze(proxyChain);
+}
+
+function createUnloadHandlerContainer() {
+    var handlers = [];
+    function _addHandler(handler) {
+        if (handler) {
+            handlers[_DYN_PUSH ](handler);
+        }
+    }
+    function _runHandlers(unloadCtx, unloadState) {
+        arrForEach(handlers, function (handler) {
+            try {
+                handler(unloadCtx, unloadState);
+            }
+            catch (e) {
+                _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
+            }
+        });
+        handlers = [];
+    }
+    return {
+        add: _addHandler,
+        run: _runHandlers
+    };
+}
+
+function createUnloadHookContainer() {
+    var _hooks = [];
+    function _doUnload(logger) {
+        var oldHooks = _hooks;
+        _hooks = [];
+        arrForEach(oldHooks, function (fn) {
+            try {
+                (fn.rm || fn.remove).call(fn);
+            }
+            catch (e) {
+                _throwInternal(logger, 2 , 73 , "Unloading:" + dumpObj(e));
+            }
+        });
+    }
+    function _addHook(hooks) {
+        if (hooks) {
+            arrAppend(_hooks, hooks);
+        }
+    }
+    return {
+        run: _doUnload,
+        add: _addHook
+    };
+}
+
+var _a$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 ] = function (unloadCtx, unloadState) {
+                var core = _self[STR_CORE ];
+                if (!core || (unloadCtx && core !== unloadCtx[STR_CORE ]())) {
+                    return;
+                }
+                var result;
+                var unloadDone = false;
+                var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
+                var theUnloadState = unloadState || {
+                    reason: 0 ,
+                    isAsync: false
+                };
+                function _unloadCallback() {
+                    if (!unloadDone) {
+                        unloadDone = true;
+                        _unloadHandlerContainer.run(theUnloadCtx, unloadState);
+                        _hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG ]());
+                        if (result === true) {
+                            theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
+                        }
+                        _initDefaults();
+                    }
+                }
+                if (!_self[_DYN__DO_TEARDOWN ] || _self[_DYN__DO_TEARDOWN ](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
+                    _unloadCallback();
+                }
+                else {
+                    result = true;
+                }
+                return result;
+            };
+            _self[_DYN_UPDATE ] = function (updateCtx, updateState) {
+                var core = _self[STR_CORE ];
+                if (!core || (updateCtx && core !== updateCtx[STR_CORE ]())) {
+                    return;
+                }
+                var result;
+                var updateDone = false;
+                var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
+                var theUpdateState = updateState || {
+                    reason: 0
+                };
+                function _updateCallback() {
+                    if (!updateDone) {
+                        updateDone = true;
+                        _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT ]());
+                    }
+                }
+                if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
+                    _updateCallback();
+                }
+                else {
+                    result = true;
+                }
+                return result;
+            };
+            proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
+            proxyFunctionAs(_self, "_addHook", function () { return _hookContainer; }, "add");
+            objDefine(_self, "_unloadHooks", { g: function () { return _hookContainer; } });
+        });
+        _self[_DYN_DIAG_LOG ] = function (itemCtx) {
+            return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
+        };
+        _self[_DYN_IS_INITIALIZED ] = function () {
+            return _isinitialized;
+        };
+        _self.setInitialized = function (isInitialized) {
+            _isinitialized = isInitialized;
+        };
+        _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
+            _nextPlugin = next;
+        };
+        _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
+            if (itemCtx) {
+                itemCtx[_DYN_PROCESS_NEXT ](env);
+            }
+            else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
+                _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
+            }
+        };
+        _self._getTelCtx = _getTelCtx;
+        function _getTelCtx(currentCtx) {
+            if (currentCtx === void 0) { currentCtx = null; }
+            var itemCtx = currentCtx;
+            if (!itemCtx) {
+                var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
+                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
+                }
+                else {
+                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
+                }
+            }
+            return itemCtx;
+        }
+        function _setDefaults(config, core, pluginChain) {
+            createDynamicConfig(config, defaultValues, safeGetLogger(core));
+            if (!pluginChain && core) {
+                pluginChain = core[_DYN_GET_PROCESS_TEL_CONT2 ]()[_DYN_GET_NEXT ]();
+            }
+            var nextPlugin = _nextPlugin;
+            if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                nextPlugin = _nextPlugin[strGetPlugin]();
+            }
+            _self[STR_CORE ] = core;
+            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
+        }
+        function _initDefaults() {
+            _isinitialized = false;
+            _self[STR_CORE ] = null;
+            _rootCtx = null;
+            _nextPlugin = null;
+            _hookContainer = createUnloadHookContainer();
+            _unloadHandlerContainer = createUnloadHandlerContainer();
+        }
+    }
+    BaseTelemetryPlugin.__ieDyn=1;
+    return BaseTelemetryPlugin;
+}());
+
+var STR_DEVICE = "device";
+var STR_LOCALE = "locale";
+var STR_VER = "ver";
+var STR_BROWSER = "browser";
+var STR_BROWSER_VER = "browserVer";
+var STR_POP_SAMPLE = "popSample";
+var STR_EVENT_FLAGS = "eventFlags";
+var STR_NAME = "name";
+var STR_SERVICE_NAME = "serviceName";
+
+var Extensions = createValueMap({
+    UserExt: [0 , "user"],
+    DeviceExt: [1 , STR_DEVICE],
+    TraceExt: [2 , "trace"],
+    WebExt: [3 , "web"],
+    AppExt: [4 , "app"],
+    OSExt: [5 , "os"],
+    SdkExt: [6 , "sdk"],
+    IntWebExt: [7 , "intweb"],
+    UtcExt: [8 , "utc"],
+    LocExt: [9 , "loc"],
+    CloudExt: [10 , "cloud"],
+    DtExt: [11 , "dt"]
+});
+var AppExtensionKeys = createValueMap({
+    id: [0 , "id"],
+    ver: [1 , STR_VER],
+    appName: [2 , STR_NAME],
+    locale: [3 , STR_LOCALE],
+    expId: [4 , "expId"],
+    env: [5 , "env"]
+});
+var WebExtensionKeys = createValueMap({
+    domain: [0 , "domain"],
+    browser: [1 , STR_BROWSER],
+    browserVer: [2 , STR_BROWSER_VER],
+    screenRes: [3 , "screenRes"],
+    userConsent: [4 , "userConsent"],
+    consentDetails: [5 , "consentDetails"]
+});
+var UserExtensionKeys = createValueMap({
+    locale: [0 , STR_LOCALE],
+    localId: [1 , "localId"],
+    id: [2 , "id"]
+});
+var OSExtKeys = createValueMap({
+    osName: [0 , STR_NAME],
+    ver: [1 , STR_VER]
+});
+var SDKExtKeys = createValueMap({
+    ver: [0 , STR_VER],
+    seq: [1 , "seq"],
+    installId: [2 , "installId"],
+    epoch: [3 , "epoch"]
+});
+var IntWebExtKeys = createValueMap({
+    msfpc: [0 , "msfpc"],
+    anid: [1 , "anid"],
+    serviceName: [2 , STR_SERVICE_NAME]
+});
+var UtcExtKeys = createValueMap({
+    popSample: [0 , STR_POP_SAMPLE],
+    eventFlags: [1 , STR_EVENT_FLAGS]
+});
+var LocExtKeys = createValueMap({
+    tz: [0 , "tz"]
+});
+var SessionExtKeys = createValueMap({
+    sessionId: [0 , "sesId"]
+});
+var DeviceExtKeys = createValueMap({
+    localId: [0 , "localId"],
+    deviceClass: [1 , "deviceClass"],
+    make: [2 , "make"],
+    model: [3 , "model"]
+});
+var CloudExtKeys = createValueMap({
+    role: [0 , "role"],
+    roleInstance: [1 , "roleInstance"],
+    roleVer: [2 , "roleVer"]
+});
+var TraceExtKeys = createValueMap({
+    traceId: [0 , "traceID"],
+    traceName: [1 , STR_NAME],
+    parentId: [2 , "parentID"]
+});
+var DistributedTraceExtKeys = createValueMap({
+    traceId: [0 , "traceId"],
+    spanId: [1 , "spanId"],
+    traceFlags: [2 , "traceFlags"]
+});
+
+var STR_EMPTY = "";
+
+var _DYN_TIMINGS = "timings";
+var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
+
+var _a;
+(_a = {},
+    _a[0 ] = 0 ,
+    _a[2 ] = 6 ,
+    _a[1 ] = 1 ,
+    _a[3 ] = 7 ,
+    _a[4096  | 2 ] = 6 ,
+    _a[4096  | 1 ] = 1 ,
+    _a[4096  | 3 ] = 7 ,
+    _a);
+function getCookieValue(cookieMgr, name, decode) {
+    if (decode === void 0) { decode = true; }
+    var cookieValue;
+    if (cookieMgr) {
+        cookieValue = cookieMgr.get(name);
+        if (decode && cookieValue && decodeURIComponent) {
+            cookieValue = decodeURIComponent(cookieValue);
+        }
+    }
+    return cookieValue || STR_EMPTY;
+}
+function createGuid(style) {
+    if (style === void 0) { style = "D" ; }
+    var theGuid = newGuid();
+    if (style === "B" ) {
+        theGuid = "{" + theGuid + "}";
+    }
+    else if (style === "P" ) {
+        theGuid = "(" + theGuid + ")";
+    }
+    else if (style === "N" ) {
+        theGuid = theGuid.replace(/-/g, STR_EMPTY);
+    }
+    return theGuid;
+}
+var getTime = perfNow;
+function setProcessTelemetryTimings(event, identifier) {
+    var evt = event;
+    evt[_DYN_TIMINGS ] = evt[_DYN_TIMINGS ] || {};
+    evt[_DYN_TIMINGS ][_DYN_PROCESS_TELEMETRY_ST0 ] = evt[_DYN_TIMINGS ][_DYN_PROCESS_TELEMETRY_ST0 ] || {};
+    evt[_DYN_TIMINGS ][_DYN_PROCESS_TELEMETRY_ST0 ][identifier] = getTime();
+}
+
+var _canUseLocalStorage;
+function canUseLocalStorage() {
+    if (_canUseLocalStorage === undefined) {
+        _canUseLocalStorage = !!_getVerifiedStorageObject(0 );
+    }
+    return _canUseLocalStorage;
+}
+function _getLocalStorageObject() {
+    if (canUseLocalStorage()) {
+        return _getVerifiedStorageObject(0 );
+    }
+    return null;
+}
+function _getVerifiedStorageObject(storageType) {
+    var storage = null;
+    var fail;
+    var uid;
+    try {
+        var global_1 = getGlobal();
+        if (!global_1) {
+            return null;
+        }
+        uid = new Date();
+        storage = storageType === 0  ? global_1.localStorage : global_1.sessionStorage;
+        if (storage && isFunction(storage.setItem)) {
+            storage.setItem(uid, uid);
+            fail = storage.getItem(uid) !== uid;
+            storage.removeItem(uid);
+            if (fail) {
+                storage = null;
+            }
+        }
+    }
+    catch (exception) {
+        storage = null;
+    }
+    return storage;
+}
+function setStorage(logger, name, data) {
+    var storage = _getLocalStorageObject();
+    if (storage !== null) {
+        try {
+            storage.setItem(name, data);
+            return true;
+        }
+        catch (e) {
+            _canUseLocalStorage = false;
+            _throwInternal(logger, 1 , 504 , "Browser failed write to local storage. " + e);
+        }
+    }
+    return false;
+}
+function getStorage(logger, name) {
+    var storage = _getLocalStorageObject();
+    if (storage !== null) {
+        try {
+            return storage.getItem(name);
+        }
+        catch (e) {
+            _canUseLocalStorage = false;
+            _throwInternal(logger, 1 , 503 , "Browser failed read of local storage. " + e);
+        }
+    }
+    return null;
+}
+
+function _getId() {
+    return this.getId();
+}
+function _setId(id) {
+    this.setId(id);
+}
+var Session = /** @class */ (function () {
+    function Session() {
+        dynamicProto(Session, this, function (_self) {
+            _self.setId = function (id) {
+                _self.customId = id;
+            };
+            _self.getId = function () {
+                if (isString(_self.customId)) {
+                    return _self.customId;
+                }
+                else {
+                    return _self.automaticId;
+                }
+            };
+        });
+    }
+    Session._staticInit = (function () {
+        objDefine(Session.prototype, "id", { g: _getId, s: _setId });
+    })();
+    return Session;
+}());
+
+var cookieNameConst = "ai_session";
+var SessionManager = /** @class */ (function () {
+    function SessionManager(core, propConfig, unloadHookContainer) {
+        var _cookieUpdatedTimestamp;
+        var _logger = safeGetLogger(core);
+        var cookieMgr = safeGetCookieMgr(core);
+        var _storageNamePrefix;
+        var _config;
+        dynamicProto(SessionManager, this, function (_self) {
+            var unloadHook = onConfigChange(propConfig, function () {
+                _config = propConfig;
+                _self.config = _config;
+            });
+            unloadHookContainer && unloadHookContainer.add(unloadHook);
+            _storageNamePrefix = function () { return _self.config.namePrefix ? cookieNameConst + _self.config.namePrefix : cookieNameConst; };
+            _self.automaticSession = new Session();
+            _self.update = function () {
+                if (!_self.automaticSession.getId()) {
+                    _initializeAutomaticSession();
+                }
+                var autoSession = _self.automaticSession;
+                var config = _self.config;
+                var now = new Date().getTime();
+                var acquisitionExpired = now - autoSession.acquisitionDate > config.sessionExpirationMs;
+                var renewalExpired = now - autoSession.renewalDate > config.sessionRenewalMs;
+                if (acquisitionExpired || renewalExpired) {
+                    _renew();
+                }
+                else {
+                    var cookieUpdatedTimestamp = _cookieUpdatedTimestamp;
+                    if (!cookieUpdatedTimestamp || now - cookieUpdatedTimestamp > SessionManager.cookieUpdateInterval) {
+                        autoSession.renewalDate = now;
+                        _setCookie(autoSession.getId(), autoSession.acquisitionDate, autoSession.renewalDate);
+                    }
+                }
+            };
+            _self.backup = function () {
+                var automaticSession = _self.automaticSession;
+                _setStorage(automaticSession.getId(), automaticSession.acquisitionDate, automaticSession.renewalDate);
+            };
+            function _initializeAutomaticSession() {
+                var cookie = cookieMgr.get(_storageNamePrefix());
+                if (cookie && isFunction(cookie.split)) {
+                    _initializeAutomaticSessionWithData(cookie);
+                }
+                else {
+                    var storage = getStorage(_logger, _storageNamePrefix());
+                    if (storage) {
+                        _initializeAutomaticSessionWithData(storage);
+                    }
+                }
+                if (!_self.automaticSession.getId()) {
+                    _renew();
+                }
+            }
+            function _initializeAutomaticSessionWithData(sessionData) {
+                var automaticSession = _self.automaticSession;
+                var params = sessionData.split("|");
+                if (params.length > 0) {
+                    automaticSession.setId(params[0]);
+                }
+                try {
+                    if (params.length > 1) {
+                        var acq = +params[1];
+                        automaticSession.acquisitionDate = +new Date(acq);
+                        automaticSession.acquisitionDate = automaticSession.acquisitionDate > 0 ? automaticSession.acquisitionDate : 0;
+                    }
+                    if (params.length > 2) {
+                        var renewal = +params[2];
+                        automaticSession.renewalDate = +new Date(renewal);
+                        automaticSession.renewalDate = automaticSession.renewalDate > 0 ? automaticSession.renewalDate : 0;
+                    }
+                }
+                catch (e) {
+                    _throwInternal(_logger, 1 , 510 , "Error parsing ai_session cookie, session will be reset: " + e);
+                }
+                if (automaticSession.renewalDate === 0) {
+                    _throwInternal(_logger, 2 , 517 , "AI session renewal date is 0, session will be reset.");
+                }
+            }
+            function _renew() {
+                var automaticSession = _self.automaticSession;
+                var now = new Date().getTime();
+                var sessionAsGuid = _self.config.sessionAsGuid;
+                if (!isUndefined(sessionAsGuid) && sessionAsGuid) {
+                    if (!isBoolean(sessionAsGuid)) {
+                        automaticSession.setId(createGuid(sessionAsGuid));
+                    }
+                    else {
+                        automaticSession.setId(createGuid());
+                    }
+                }
+                else {
+                    automaticSession.setId(newId(_config.idLength || 22));
+                }
+                automaticSession.acquisitionDate = now;
+                automaticSession.renewalDate = now;
+                _setCookie(automaticSession.getId(), automaticSession.acquisitionDate, automaticSession.renewalDate);
+                if (!canUseLocalStorage()) {
+                    _throwInternal(_logger, 2 , 505 , "Browser does not support local storage. Session durations will be inaccurate.");
+                }
+            }
+            function _setCookie(guid, acq, renewal) {
+                var acquisitionExpiry = acq + _self.config.sessionExpirationMs;
+                var renewalExpiry = renewal + _self.config.sessionRenewalMs;
+                var cookieExpiry = new Date();
+                var cookie = [guid, acq, renewal];
+                if (acquisitionExpiry < renewalExpiry) {
+                    cookieExpiry.setTime(acquisitionExpiry);
+                }
+                else {
+                    cookieExpiry.setTime(renewalExpiry);
+                }
+                var cookieDomain = _self.config.cookieDomain || null;
+                cookieMgr.set(_storageNamePrefix(), cookie.join("|") + ";expires=" + cookieExpiry.toUTCString(), null, cookieDomain);
+                _cookieUpdatedTimestamp = new Date().getTime();
+            }
+            function _setStorage(guid, acq, renewal) {
+                setStorage(_logger, _storageNamePrefix(), [guid, acq, renewal].join("|"));
+            }
+        });
+    }
+    SessionManager.cookieUpdateInterval = 60000;
+    return SessionManager;
+}());
+
+var defaultFlightIdNameSpaces = [
+    "AX",
+    "EX",
+    "SF",
+    "CS",
+    "CF",
+    "CT",
+    "CU",
+    "DC",
+    "DF",
+    "H5",
+    "HL",
+    "WS",
+    "WP"
+];
+function _validateAppExpId(appExpIdNew, flightIdNameSpaces) {
+    if (flightIdNameSpaces === void 0) { flightIdNameSpaces = defaultFlightIdNameSpaces; }
+    var appExpId = null;
+    if (appExpIdNew) {
+        var expIdArray = appExpIdNew.split(",");
+        for (var i = 0; i < expIdArray.length; i++) {
+            if (_isValidAppFlightId(expIdArray[i], flightIdNameSpaces)) {
+                if (!appExpId) {
+                    appExpId = expIdArray[i];
+                }
+                else {
+                    appExpId += "," + expIdArray[i];
+                }
+            }
+        }
+    }
+    return appExpId;
+}
+function _isValidAppFlightId(appFlightId, flightIdNameSpaces) {
+    if (flightIdNameSpaces === void 0) { flightIdNameSpaces = defaultFlightIdNameSpaces; }
+    if (!appFlightId || appFlightId.length < 4) {
+        return false;
+    }
+    var isValid = false;
+    var MAXFLIGHTIDLENGTH = 256;
+    var curNameSpace = (appFlightId.substring(0, 3)).toString().toUpperCase();
+    for (var i = 0; i < flightIdNameSpaces.length; i++) {
+        if (flightIdNameSpaces[i] + ":" === curNameSpace && appFlightId.length <= MAXFLIGHTIDLENGTH) {
+            isValid = true;
+            break;
+        }
+    }
+    return isValid;
+}
+function _getExpId() {
+    return this.getExpId();
+}
+var Application = /** @class */ (function () {
+    function Application(propertiesConfig, core, unloadHookContainer) {
+        var _appExpId = null;
+        var flightIdNameSpaces = defaultFlightIdNameSpaces.slice(0);
+        var expIdCookieName = "Treatments";
+        var _cookieMgr;
+        var _propertiesConfig = null;
+        dynamicProto(Application, this, function (_self) {
+            _populateDefaults(propertiesConfig);
+            if (hasDocument()) {
+                var documentElement = getDocument().documentElement;
+                if (documentElement) {
+                    _self.locale = documentElement.lang;
+                }
+            }
+            _self.getExpId = function () {
+                return _propertiesConfig.expId ? _readExpIdFromCoreData(_propertiesConfig.expId) : _readExpIdFromCookie();
+            };
+            function _getMetaDataFromDOM(prefix) {
+                var metaElements;
+                var metaData = {};
+                var doc = getDocument();
+                if (doc) {
+                    metaElements = doc && doc.querySelectorAll("meta");
+                    for (var i = 0; i < metaElements.length; i++) {
+                        var meta = metaElements[i];
+                        if (meta.name) {
+                            var mt = meta.name.toLowerCase();
+                            if (mt.indexOf(prefix) === 0) {
+                                var name = meta.name.replace(prefix, "");
+                                metaData[name] = meta.content;
+                            }
+                        }
+                    }
+                }
+                return metaData;
+            }
+            function _setAppExpId(appExpIdNew) {
+                if (appExpIdNew === _appExpId) {
+                    return;
+                }
+                _appExpId = _validateAppExpId(appExpIdNew, flightIdNameSpaces);
+            }
+            function _readExpIdFromCookie() {
+                var cookieValue = getCookieValue(_cookieMgr, expIdCookieName);
+                _setAppExpId(cookieValue);
+                return _appExpId;
+            }
+            function _readExpIdFromCoreData(expId) {
+                _setAppExpId(expId);
+                return _appExpId;
+            }
+            function _populateDefaults(config) {
+                var unloadHook = onConfigChange(config, function () {
+                    _cookieMgr = core && core.getCookieMgr();
+                    _propertiesConfig = config || {};
+                    _self.env = _propertiesConfig.env || _getMetaDataFromDOM("awa-")["env"];
+                });
+                unloadHookContainer && unloadHookContainer.add(unloadHook);
+            }
+        });
+    }
+    Application.validateAppExpId = _validateAppExpId;
+    Application._staticInit = (function () {
+        objDefine(Application.prototype, "expId", { g: _getExpId });
+    })();
+    return Application;
+}());
+
+var Cloud = /** @class */ (function () {
+    function Cloud() {
+    }
+    return Cloud;
+}());
+
+var Device = /** @class */ (function () {
+    function Device() {
+    }
+    return Device;
+}());
+
+function _getMsfpc() {
+    return this.getMsfpc();
+}
+function _getAnid() {
+    return this.getAnid();
+}
+var IntWeb = /** @class */ (function () {
+    function IntWeb(propertiesConfig, core, unloadHookContainer) {
+        var _cookieMgr;
+        dynamicProto(IntWeb, this, function (_self) {
+            _populateDefaults(propertiesConfig);
+            _self.getMsfpc = function () {
+                return getCookieValue(_cookieMgr, "MSFPC");
+            };
+            _self.getAnid = function () {
+                return getCookieValue(_cookieMgr, "ANON").slice(0, 34);
+            };
+            function _populateDefaults(config) {
+                var unloadHook = onConfigChange(config, function () {
+                    _cookieMgr = core && core.getCookieMgr();
+                    var _config = config || {};
+                    if (_config.serviceName) {
+                        _self.serviceName = _config.serviceName;
+                    }
+                });
+                unloadHookContainer && unloadHookContainer.add(unloadHook);
+            }
+        });
+    }
+    IntWeb._staticInit = (function () {
+        var proto = IntWeb.prototype;
+        objDefine(proto, "msfpc", { g: _getMsfpc });
+        objDefine(proto, "anid", { g: _getAnid });
+    })();
+    return IntWeb;
+}());
+
+var Loc = /** @class */ (function () {
+    function Loc() {
+        var timeZone = new Date().getTimezoneOffset();
+        var minutes = timeZone % 60;
+        var hours = (timeZone - minutes) / 60;
+        var timeZonePrefix = "+";
+        if (hours > 0) {
+            timeZonePrefix = "-";
+        }
+        hours = Math.abs(hours);
+        minutes = Math.abs(minutes);
+        this.tz = timeZonePrefix + (hours < 10 ? "0" + hours : hours.toString()) + ":"
+            + (minutes < 10 ? "0" + minutes : minutes.toString());
+    }
+    return Loc;
+}());
+
+var OSNAMEREGEX = {
+    WIN: /(windows|win32)/i,
+    WINRT: / arm;/i,
+    WINPHONE: /windows\sphone\s\d+\.\d+/i,
+    OSX: /(macintosh|mac os x)/i,
+    IOS: /(ipad|iphone|ipod)(?=.*like mac os x)/i,
+    LINUX: /(linux|joli|[kxln]?ubuntu|debian|[open]*suse|gentoo|arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk)/i,
+    ANDROID: /android/i,
+    CROS: /CrOS/i
+};
+var VERSION_MAPPINGS = {
+    "5.1": "XP",
+    "6.0": "Vista",
+    "6.1": "7",
+    "6.2": "8",
+    "6.3": "8.1",
+    "10.0": "10"
+};
+var REGEX_VERSION$1 = "([\\d,.]+)";
+var REGEX_VERSION_MAC = "([\\d,_,.]+)";
+var UNKNOWN$1 = "Unknown";
+var OSNAMES = [
+    { r: OSNAMEREGEX.WINPHONE, os: "Windows Phone" },
+    { r: OSNAMEREGEX.WINRT, os: "Windows RT" },
+    { r: OSNAMEREGEX.WIN, os: "Windows"  },
+    { r: OSNAMEREGEX.IOS, os: "iOS"  },
+    { r: OSNAMEREGEX.ANDROID, os: "Android"  },
+    { r: OSNAMEREGEX.LINUX, os: "Linux" },
+    { r: OSNAMEREGEX.CROS, os: "Chrome OS" },
+    { s: "x11", os: "Unix" },
+    { s: "blackberry", os: "BlackBerry" },
+    { s: "symbian", os: "Symbian" },
+    { s: "nokia", os: "Nokia" },
+    { r: OSNAMEREGEX.OSX, os: "Mac OS X"  }
+];
+function _getOsName(lowerCaseUserAgent) {
+    for (var lp = 0; lp < OSNAMES.length; lp++) {
+        var match = OSNAMES[lp];
+        if (match.r && lowerCaseUserAgent.match(match.r)) {
+            return match.os;
+        }
+        else if (match.s && lowerCaseUserAgent.indexOf(match.s) !== -1) {
+            return match.os;
+        }
+    }
+    return UNKNOWN$1;
+}
+function _getOsVersion(userAgent, osName) {
+    if (osName === "Windows" ) {
+        return _getGenericOsVersion(userAgent, "Windows NT");
+    }
+    if (osName === "Android" ) {
+        return _getGenericOsVersion(userAgent, osName);
+    }
+    if (osName === "Mac OS X" ) {
+        return _getMacOsxVersion(userAgent);
+    }
+    if (osName === "iOS" ) {
+        return _getIosVersion(userAgent);
+    }
+    return UNKNOWN$1;
+}
+function _getGenericOsVersion(userAgent, osName) {
+    var ntVersionMatches = userAgent.match(new RegExp(osName + " " + REGEX_VERSION$1));
+    if (ntVersionMatches) {
+        if (VERSION_MAPPINGS[ntVersionMatches[1]]) {
+            return VERSION_MAPPINGS[ntVersionMatches[1]];
+        }
+        return ntVersionMatches[1];
+    }
+    return UNKNOWN$1;
+}
+function _getMacOsxVersion(userAgent) {
+    var macOsxVersionInUserAgentMatches = userAgent.match(new RegExp("Mac OS X"  + " " + REGEX_VERSION_MAC));
+    if (macOsxVersionInUserAgentMatches) {
+        var versionString = macOsxVersionInUserAgentMatches[1].replace(/_/g, ".");
+        if (versionString) {
+            var delimiter = _getDelimiter(versionString);
+            if (delimiter) {
+                var components = versionString.split(delimiter);
+                return components[0];
+            }
+            else {
+                return versionString;
+            }
+        }
+    }
+    return UNKNOWN$1;
+}
+function _getIosVersion(userAgent) {
+    var iosVersionInUserAgentMatches = userAgent.match(new RegExp("OS " + REGEX_VERSION_MAC));
+    if (iosVersionInUserAgentMatches) {
+        var versionString = iosVersionInUserAgentMatches[1].replace(/_/g, ".");
+        if (versionString) {
+            var delimiter = _getDelimiter(versionString);
+            if (delimiter) {
+                var components = versionString.split(delimiter);
+                return components[0];
+            }
+            else {
+                return versionString;
+            }
+        }
+    }
+    return UNKNOWN$1;
+}
+function _getDelimiter(versionString) {
+    if (versionString.indexOf(".") > -1) {
+        return ".";
+    }
+    if (versionString.indexOf("_") > -1) {
+        return "_";
+    }
+    return null;
+}
+var OperatingSystem = /** @class */ (function () {
+    function OperatingSystem(propertiesConfig, unloadHookContainer) {
+        var self = this;
+        var _config;
+        var _name = null;
+        var _ver = null;
+        var _userName = null;
+        var _userVer = null;
+        var _setSysName = function (value) {
+            _userName = value;
+        };
+        var _setSysVer = function (value) {
+            _userVer = value;
+        };
+        var _getSysName = function () {
+            return _userName || _name;
+        };
+        var _getSysVer = function () {
+            return _userVer || _ver;
+        };
+        var unloadHook = onConfigChange(propertiesConfig, function () {
+            _config = propertiesConfig || {};
+            if (_config.populateOperatingSystemInfo) {
+                var theNav = getNavigator() || {};
+                var userAgent = propertiesConfig.userAgent || theNav.userAgent || "";
+                var userAgentDataPlatform = (propertiesConfig.userAgentData || {}).platform || (theNav.userAgentData || {}).platform;
+                if (userAgent) {
+                    var osName = _getOsName(userAgent.toLowerCase());
+                    _name = osName;
+                    _ver = _getOsVersion(userAgent, osName);
+                }
+                if ((!_name || _name === UNKNOWN$1) && isString(userAgentDataPlatform)) {
+                    _name = userAgentDataPlatform;
+                }
+            }
+        });
+        unloadHookContainer && unloadHookContainer.add(unloadHook);
+        objDefine(self, "name", { s: _setSysName, g: _getSysName });
+        objDefine(self, "ver", { s: _setSysVer, g: _getSysVer });
+    }
+    return OperatingSystem;
+}());
+
+var DEVICE_ID_COOKIE = "MicrosoftApplicationsTelemetryDeviceId";
+function _saveData(mgr, propertyStorage, name, value) {
+    if (propertyStorage) {
+        propertyStorage.setProperty(name, value);
+    }
+    else {
+        mgr.set(name, value, 31536000);
+    }
+}
+function _getData(mgr, propertyStorage, name) {
+    if (propertyStorage) {
+        return propertyStorage.getProperty(name) || "";
+    }
+    return getCookieValue(mgr, name);
+}
+var Sdk = /** @class */ (function () {
+    function Sdk(coreConfig, core, unloadHookContainer) {
+        var _sequenceId = 0;
+        var _cookieMgr;
+        dynamicProto(Sdk, this, function (_self) {
+            _self.seq = _sequenceId;
+            _self.epoch = random32(false).toString();
+            _self.getSequenceId = function () {
+                return ++_sequenceId;
+            };
+            var unloadHook = onConfigChange(coreConfig, function (details) {
+                _cookieMgr = core && core.getCookieMgr();
+                var coreConfig = details.cfg;
+                var propertyStorage = coreConfig.propertyStorageOverride;
+                var cookieMgrEnabled = _cookieMgr.isEnabled();
+                if (cookieMgrEnabled || propertyStorage) {
+                    var deviceId = _getData(_cookieMgr, propertyStorage, DEVICE_ID_COOKIE);
+                    if (!deviceId) {
+                        deviceId = newGuid();
+                    }
+                    _saveData(_cookieMgr, propertyStorage, DEVICE_ID_COOKIE, deviceId);
+                    _self.installId = deviceId;
+                }
+                else {
+                    _cookieMgr.purge(DEVICE_ID_COOKIE);
+                }
+            });
+            unloadHookContainer && unloadHookContainer.add(unloadHook);
+        });
+    }
+    Sdk.__ieDyn=1;
+    return Sdk;
+}());
+
+var Trace = /** @class */ (function () {
+    function Trace(propertiesConfig, id, parentId, name, unloadHookContainer) {
+        var self = this;
+        self.traceId = id || generateW3CId();
+        var unloadHook = onConfigChange(propertiesConfig, function () {
+            var _config = propertiesConfig;
+            if (_config.enableDistributedTracing && !parentId) {
+                parentId = generateW3CId().substring(0, 16);
+            }
+            self.parentId = self.parentId || parentId;
+            if (_config.enableApplicationInsightsTrace && !name) {
+                var loc = getLocation();
+                if (loc && loc.pathname) {
+                    name = loc.pathname;
+                }
+            }
+            self.name = self.name || name;
+        });
+        unloadHookContainer && unloadHookContainer.add(unloadHook);
+    }
+    return Trace;
+}());
+
+var strSetLocalId = "setLocalId";
+function _getLocalId() {
+    return this.getLocalId();
+}
+function _setLocalId(value) {
+    this[strSetLocalId](value);
+}
+var User = /** @class */ (function () {
+    function User(coreConfig, propertiesConfig, core, unloadHookContainer) {
+        var _propertiesConfig;
+        var _customLocalId;
+        var _cookieMgr;
+        dynamicProto(User, this, function (_self) {
+            _populateDefaults(propertiesConfig);
+            if (typeof navigator !== "undefined") {
+                var nav = navigator;
+                _self.locale = nav.userLanguage || nav.language;
+            }
+            _self.getLocalId = function () {
+                if (_customLocalId) {
+                    return _customLocalId;
+                }
+                return _populateMuidFromCookie();
+            };
+            _self[strSetLocalId] = function (value) {
+                _customLocalId = value;
+            };
+            function _populateMuidFromCookie() {
+                if (!_propertiesConfig.hashIdentifiers && !_propertiesConfig.dropIdentifiers) {
+                    var muidValue = getCookieValue(_cookieMgr, "MUID");
+                    if (muidValue) {
+                        _customLocalId = "t:" + muidValue;
+                    }
+                }
+                return _customLocalId;
+            }
+            function _populateDefaults(config) {
+                var unloadHook = onConfigChange(config, function () {
+                    _cookieMgr = core && core.getCookieMgr();
+                    _propertiesConfig = config;
+                    _customLocalId = null;
+                    if (_cookieMgr && _cookieMgr.isEnabled()) {
+                        _populateMuidFromCookie();
+                        if (_propertiesConfig.enableApplicationInsightsUser) {
+                            var aiUser = getCookieValue(_cookieMgr, User.userCookieName);
+                            if (aiUser) {
+                                var params = aiUser.split(User.cookieSeparator);
+                                if (params.length > 0) {
+                                    _self.id = params[0];
+                                }
+                            }
+                            if (!_self.id) {
+                                _self.id = newId((coreConfig && !isUndefined(coreConfig.idLength)) ? coreConfig.idLength : 22);
+                                var acqStr = toISOString(new Date());
+                                _self.accountAcquisitionDate = acqStr;
+                                var newCookie = [_self.id, acqStr];
+                                var cookieDomain = _propertiesConfig.cookieDomain ? _propertiesConfig.cookieDomain : undefined;
+                                _cookieMgr.set(User.userCookieName, newCookie.join(User.cookieSeparator), 31536000, cookieDomain);
+                            }
+                        }
+                    }
+                });
+                unloadHookContainer && unloadHookContainer.add(unloadHook);
+            }
+        });
+    }
+    User.cookieSeparator = "|";
+    User.userCookieName = "ai_user";
+    User._staticInit = (function () {
+        objDefine(User.prototype, "localId", { g: _getLocalId, s: _setLocalId });
+    })();
+    return User;
+}());
+
+var HASH_IDENTIFIERS_FLAG = 0x100000;
+var DROP_IDENTIFIERS_FLAG = 0x200000;
+var SCRUB_IP_FLAG = 0x400000;
+var Utc = /** @class */ (function () {
+    function Utc(propertiesConfig, unloadHookContainer) {
+        var self = this;
+        self.popSample = 100;
+        var unloadHook = onConfigChange(propertiesConfig, function () {
+            self.eventFlags = 0;
+            if (propertiesConfig.hashIdentifiers) {
+                self.eventFlags = self.eventFlags | HASH_IDENTIFIERS_FLAG;
+            }
+            if (propertiesConfig.dropIdentifiers) {
+                self.eventFlags = self.eventFlags | DROP_IDENTIFIERS_FLAG;
+            }
+            if (propertiesConfig.scrubIpOnly) {
+                self.eventFlags = self.eventFlags | SCRUB_IP_FLAG;
+            }
+        });
+        unloadHookContainer && unloadHookContainer.add(unloadHook);
+    }
+    return Utc;
+}());
+
+var USER_CONSENT_DETAILS = [
+    "Required", "Analytics", "SocialMedia", "Advertising"
+];
+var REGEX_VERSION = "([\\d,.]+)";
+var UNKNOWN = "Unknown";
+var EDGE_CHROMIUM = "Edg/";
+var EDGE_IOS = "EdgiOS/";
+var USER_AGENTS = [
+    { ua: "OPR/", b: "Opera"  },
+    { ua: "PhantomJS" , b: "PhantomJS"  },
+    { ua: "Edge" , b: "Edge"  },
+    { ua: EDGE_CHROMIUM, b: "Edge"  },
+    { ua: EDGE_IOS, b: "Edge"  },
+    { ua: "Electron" , b: "Electron"  },
+    { ua: "Chrome" , b: "Chrome"  },
+    { ua: "Trident", b: "MSIE"  },
+    { ua: "MSIE ", b: "MSIE"  },
+    { ua: "Firefox" , b: "Firefox"  },
+    { ua: "Safari" , b: "Safari"  },
+    { ua: "SkypeShell" , b: "SkypeShell"  }
+];
+var BRANDS = [
+    { br: "Microsoft Edge", b: "Edge"  },
+    { br: "Google Chrome", b: "Chrome"  },
+    { br: "Opera", b: "Opera"  }
+];
+function _userAgentContainsString(searchString, userAgent) {
+    return userAgent.indexOf(searchString) > -1;
+}
+function _getBrandVersion(match, brands) {
+    for (var lp = 0; lp < brands.length; lp++) {
+        if (match == brands[lp].brand) {
+            return brands[lp].version;
+        }
+    }
+    return null;
+}
+function _getBrowserName(userAgent) {
+    if (userAgent) {
+        for (var lp = 0; lp < USER_AGENTS.length; lp++) {
+            var ua = USER_AGENTS[lp].ua;
+            if (_userAgentContainsString(ua, userAgent)) {
+                return USER_AGENTS[lp].b;
+            }
+        }
+    }
+    return UNKNOWN;
+}
+function _getBrowserVersion(userAgent, browserName) {
+    if (browserName === "MSIE" ) {
+        return _getIeVersion(userAgent);
+    }
+    return _getOtherVersion(browserName, userAgent);
+}
+function _getIeVersion(userAgent) {
+    var classicIeVersionMatches = userAgent.match(new RegExp("MSIE"  + " " + REGEX_VERSION));
+    if (classicIeVersionMatches) {
+        return classicIeVersionMatches[1];
+    }
+    var ieVersionMatches = userAgent.match(new RegExp("rv:" + REGEX_VERSION));
+    if (ieVersionMatches) {
+        return ieVersionMatches[1];
+    }
+}
+function _getOtherVersion(browserString, userAgent) {
+    if (browserString === "Safari" ) {
+        browserString = "Version";
+    }
+    else if (browserString === "Edge" ) {
+        if (_userAgentContainsString(EDGE_CHROMIUM, userAgent)) {
+            browserString = "Edg";
+        }
+        else if (_userAgentContainsString(EDGE_IOS, userAgent)) {
+            browserString = "EdgiOS";
+        }
+    }
+    var matches = userAgent.match(new RegExp(browserString + "/" + REGEX_VERSION));
+    if (matches) {
+        return matches[1];
+    }
+    if (browserString === "Opera" ) {
+        matches = userAgent.match(new RegExp("OPR/" + REGEX_VERSION));
+        if (matches) {
+            return matches[1];
+        }
+    }
+    return UNKNOWN;
+}
+function _getScreenResolution() {
+    var screenRes = { h: 0, w: 0 };
+    var win = getWindow();
+    if (win && win.screen) {
+        screenRes.h = screen.height;
+        screenRes.w = screen.width;
+    }
+    return screenRes;
+}
+function _getUserConsent() {
+    return this.getUserConsent();
+}
+var Web = /** @class */ (function () {
+    function Web(propertiesConfig, core, unloadHookContainer) {
+        safeGetCookieMgr(core);
+        var _propertiesConfig = propertiesConfig || {};
+        var _userAgent = null;
+        var _userAgentBrands = null;
+        var _userBrowser = null;
+        var _userBrowserVer = null;
+        var _browser = null;
+        var _browserVer = null;
+        var _gpcDataSharingOption = null;
+        dynamicProto(Web, this, function (_self) {
+            _populateDefaults(propertiesConfig);
+            var windowLocation = getLocation();
+            if (windowLocation) {
+                var domain = windowLocation.hostname;
+                if (domain) {
+                    _self.domain = windowLocation.protocol === "file:" ? "local" : domain;
+                }
+            }
+            var screenRes = _getScreenResolution();
+            _self.screenRes = screenRes.w + "X" + screenRes.h;
+            _self.getUserConsent = function () {
+                return false;
+            };
+            _self.getUserConsentDetails = function () {
+                var consentDetails = null;
+                try {
+                    var callback = _propertiesConfig.callback;
+                    if (callback && callback.userConsentDetails) {
+                        var result = callback.userConsentDetails();
+                        if (result) {
+                            if (_propertiesConfig.disableConsentDetailsSanitize) {
+                                consentDetails = result;
+                            }
+                            else {
+                                consentDetails = {};
+                            }
+                            for (var lp = 0; lp < USER_CONSENT_DETAILS.length; lp++) {
+                                var key = USER_CONSENT_DETAILS[lp];
+                                consentDetails[key] = result[key] || false;
+                            }
+                        }
+                    }
+                    if (_gpcDataSharingOption !== null) {
+                        consentDetails = consentDetails || {};
+                        consentDetails.GPC_DataSharingOptIn = !!_gpcDataSharingOption;
+                    }
+                    return consentDetails ? JSON.stringify(consentDetails) : null;
+                }
+                catch (e) {
+                }
+            };
+            function _parseUserAgent(userAgent, userAgentBrands) {
+                if (isArray(userAgentBrands)) {
+                    try {
+                        for (var lp = 0; lp < BRANDS.length; lp++) {
+                            var version = _getBrandVersion(BRANDS[lp].br, userAgentBrands);
+                            if (version) {
+                                _browser = BRANDS[lp].b;
+                                _browserVer = version;
+                                return;
+                            }
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+                if (userAgent) {
+                    var browserName = _getBrowserName(userAgent);
+                    _browser = browserName;
+                    _browserVer = _getBrowserVersion(userAgent, browserName);
+                }
+            }
+            function _setBrowser(value) {
+                _userBrowser = value;
+            }
+            function _setBrowserVer(value) {
+                _userBrowserVer = value;
+            }
+            function _getBrowser() {
+                return _userBrowser || _browser;
+            }
+            function _getBrowserVer() {
+                return _userBrowserVer || _browserVer;
+            }
+            var _getGpcDataSharing = function () {
+                return _gpcDataSharingOption;
+            };
+            var _setGpcDataSharing = function (value) {
+                _gpcDataSharingOption = isBoolean(value) ? value : null;
+                _propertiesConfig.gpcDataSharingOptIn = _gpcDataSharingOption;
+            };
+            function _populateDefaults(config) {
+                var unloadHook = onConfigChange(config, function () {
+                    _propertiesConfig = config;
+                    if (_propertiesConfig.populateBrowserInfo) {
+                        var userAgent = _propertiesConfig.userAgent;
+                        var userAgentBrands = (_propertiesConfig.userAgentData || {}).brands;
+                        if (userAgent !== _userAgent || userAgentBrands !== _userAgentBrands) {
+                            if (!userAgent || !userAgentBrands || userAgentBrands.length === 0) {
+                                var theNav = getNavigator();
+                                if (theNav) {
+                                    userAgent = userAgent || theNav.userAgent || "";
+                                    userAgentBrands = userAgentBrands || (theNav.userAgentData || {}).brands;
+                                }
+                            }
+                            _parseUserAgent(userAgent, userAgentBrands);
+                            _userAgent = userAgent;
+                            _userAgentBrands = userAgentBrands;
+                        }
+                    }
+                    _gpcDataSharingOption = isBoolean(_propertiesConfig.gpcDataSharingOptIn) ? _propertiesConfig.gpcDataSharingOptIn : null;
+                });
+                unloadHookContainer && unloadHookContainer.add(unloadHook);
+            }
+            objDefineProps(_self, {
+                "userConsent": { g: _self.getUserConsent },
+                "browser": { s: _setBrowser, g: _getBrowser },
+                "browserVer": { s: _setBrowserVer, g: _getBrowserVer },
+                "gpcDataSharingOptIn": { g: _getGpcDataSharing, s: _setGpcDataSharing }
+            });
+        });
+    }
+    Web._staticInit = (function () {
+        objDefine(Web.prototype, "userConsent", { g: _getUserConsent });
+    })();
+    return Web;
+}());
+
+function _applyExtValues(extension, event, names, map, overwriteTarget) {
+    var target = event.ext[Extensions[extension]];
+    if (target) {
+        try {
+            objForEachKey(map, function (field, value) {
+                if (isString(value) || isNumber(value) || isBoolean(value)) {
+                    var targetValue = target[names[field]];
+                    if (!overwriteTarget && (targetValue || isString(targetValue) || isNumber(targetValue) || isBoolean(targetValue))) {
+                        value = targetValue;
+                    }
+                    target[names[field]] = value;
+                }
+            });
+        }
+        catch (e) {
+        }
+    }
+    return target;
+}
+var TelemetryContext = /** @class */ (function () {
+    function TelemetryContext(coreConfig, propertiesConfig, core, unloadHookContainer) {
+        dynamicProto(TelemetryContext, this, function (_self) {
+            _self.app = new Application(propertiesConfig, core, unloadHookContainer);
+            _self.cloud = new Cloud();
+            _self.user = new User(coreConfig, propertiesConfig, core, unloadHookContainer);
+            _self.os = new OperatingSystem(propertiesConfig, unloadHookContainer);
+            _self.web = new Web(propertiesConfig, core, unloadHookContainer);
+            var _sdk = new Sdk(coreConfig, core, unloadHookContainer);
+            var _intWeb = new IntWeb(propertiesConfig, core, unloadHookContainer);
+            var _utc = new Utc(propertiesConfig, unloadHookContainer);
+            _self.loc = new Loc();
+            _self.device = new Device();
+            var _sessionManager = new SessionManager(core, propertiesConfig, unloadHookContainer);
+            _self.session = new Session();
+            var undefValue = undefined;
+            var _distributedTraceCtx = createDistributedTraceContextFromTraceCtx(new Trace(propertiesConfig, undefValue, undefValue, undefValue, unloadHookContainer), _getTraceCtx());
+            var _overwriteEventPartA = !(propertiesConfig || {}).eventContainExtFields;
+            function _getSessionId() {
+                var session = _self.session;
+                if (session && isString(session.customId)) {
+                    return session.customId;
+                }
+                _sessionManager.update();
+                var autoSession = _sessionManager.automaticSession;
+                if (autoSession) {
+                    var autoId = autoSession.getId();
+                    if (autoId && isString(autoId)) {
+                        session.automaticId = autoId;
+                    }
+                }
+                return session.automaticId;
+            }
+            _self.getTraceCtx = function () {
+                return _distributedTraceCtx;
+            };
+            _self.getSessionId = _getSessionId;
+            _self.applyApplicationContext = function (event) {
+                var _a;
+                var app = _self.app;
+                _applyExtValues(4 , event, AppExtensionKeys, (_a = {},
+                    _a[0 ] = app.id,
+                    _a[1 ] = app.ver,
+                    _a[2 ] = app.name,
+                    _a[3 ] = app.locale,
+                    _a[4 ] = app.getExpId(),
+                    _a[5 ] = app.env,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyUserContext = function (event) {
+                var _a;
+                var user = _self.user;
+                _applyExtValues(0 , event, UserExtensionKeys, (_a = {},
+                    _a[1 ] = user.getLocalId(),
+                    _a[0 ] = user.locale,
+                    _a[2 ] = user.id,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyWebContext = function (event) {
+                var _a;
+                var web = _self.web;
+                _applyExtValues(3 , event, WebExtensionKeys, (_a = {},
+                    _a[0 ] = web.domain,
+                    _a[1 ] = web.browser,
+                    _a[2 ] = web.browserVer,
+                    _a[3 ] = web.screenRes,
+                    _a[5 ] = web.getUserConsentDetails(),
+                    _a[4 ] = false,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyOsContext = function (event) {
+                var _a;
+                var os = _self.os;
+                _applyExtValues(5 , event, OSExtKeys, (_a = {},
+                    _a[0 ] = os.name,
+                    _a[1 ] = os.ver,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applySdkContext = function (event) {
+                var _a;
+                _applyExtValues(6 , event, SDKExtKeys, (_a = {},
+                    _a[2 ] = _sdk.installId,
+                    _a[1 ] = _sdk.getSequenceId(),
+                    _a[3 ] = _sdk.epoch,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyIntWebContext = function (event) {
+                var _a;
+                _applyExtValues(7 , event, IntWebExtKeys, (_a = {},
+                    _a[0 ] = _intWeb.getMsfpc(),
+                    _a[1 ] = _intWeb.getAnid(),
+                    _a[2 ] = _intWeb.serviceName,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyUtcContext = function (event) {
+                var _a;
+                var utcFields = (_a = {},
+                    _a[0 ] = _utc.popSample,
+                    _a);
+                if (_utc.eventFlags > 0) {
+                    utcFields[1 ] = _utc.eventFlags;
+                }
+                _applyExtValues(8 , event, UtcExtKeys, utcFields, _overwriteEventPartA);
+            };
+            _self.applyLocContext = function (event) {
+                var _a;
+                _applyExtValues(9 , event, LocExtKeys, (_a = {},
+                    _a[0 ] = _self.loc.tz,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applySessionContext = function (event) {
+                var _a;
+                _applyExtValues(4 , event, SessionExtKeys, (_a = {},
+                    _a[0 ] = _getSessionId(),
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyDeviceContext = function (event) {
+                var _a;
+                var device = _self.device;
+                _applyExtValues(1 , event, DeviceExtKeys, (_a = {},
+                    _a[0 ] = device.localId,
+                    _a[2 ] = device.make,
+                    _a[3 ] = device.model,
+                    _a[1 ] = device.deviceClass,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyCloudContext = function (event) {
+                var _a;
+                var cloud = _self.cloud;
+                _applyExtValues(10 , event, CloudExtKeys, (_a = {},
+                    _a[0 ] = cloud.role,
+                    _a[1 ] = cloud.roleInstance,
+                    _a[2 ] = cloud.roleVer,
+                    _a), _overwriteEventPartA);
+            };
+            _self.applyAITraceContext = function (event) {
+                var _a;
+                if (propertiesConfig.enableApplicationInsightsTrace) {
+                    var distributedTrace = _getTraceCtx();
+                    if (distributedTrace) {
+                        _applyExtValues(2 , event, TraceExtKeys, (_a = {},
+                            _a[0 ] = distributedTrace.getTraceId(),
+                            _a[1 ] = distributedTrace.getName(),
+                            _a[2 ] = distributedTrace.getSpanId(),
+                            _a), false);
+                    }
+                }
+            };
+            _self.applyDistributedTraceContext = function (event) {
+                var _a;
+                var distributedTrace = _getTraceCtx();
+                if (distributedTrace) {
+                    var traceFields = (_a = {},
+                        _a[0 ] = distributedTrace.getTraceId(),
+                        _a[1 ] = distributedTrace.getSpanId(),
+                        _a);
+                    var traceFlags = distributedTrace.getTraceFlags();
+                    if (!isNullOrUndefined(traceFlags)) {
+                        traceFields[2 ] = traceFlags;
+                    }
+                    _applyExtValues(11 , event, DistributedTraceExtKeys, traceFields, false);
+                }
+            };
+            function _getTraceCtx() {
+                var traceCtx = _distributedTraceCtx;
+                if (core && core.getTraceCtx) {
+                    traceCtx = core.getTraceCtx(false) || _distributedTraceCtx;
+                }
+                return traceCtx;
+            }
+        });
+    }
+    TelemetryContext.__ieDyn=1;
+    return TelemetryContext;
+}());
+function createDistributedTraceContextFromTraceCtx(traceContext, parentCtx) {
+    var trace = traceContext || {};
+    return {
+        getName: function () {
+            return trace.name;
+        },
+        setName: function (newValue) {
+            parentCtx && parentCtx.setName(newValue);
+            trace.name = newValue;
+        },
+        getTraceId: function () {
+            return trace.traceId;
+        },
+        setTraceId: function (newValue) {
+            parentCtx && parentCtx.setTraceId(newValue);
+            if (isValidTraceId(newValue)) {
+                trace.traceId = newValue;
+            }
+        },
+        getSpanId: function () {
+            return trace.parentId;
+        },
+        setSpanId: function (newValue) {
+            parentCtx && parentCtx.setSpanId(newValue);
+            if (isValidSpanId(newValue)) {
+                trace.parentId = newValue;
+            }
+        },
+        getTraceFlags: function () {
+            return trace.traceFlags;
+        },
+        setTraceFlags: function (newTraceFlags) {
+            parentCtx && parentCtx.setTraceFlags(newTraceFlags);
+            trace.traceFlags = newTraceFlags;
+        }
+    };
+}
+
+var undefValue;
+var extensions = [
+    Extensions[4 ],
+    Extensions[0 ],
+    Extensions[3 ],
+    Extensions[5 ],
+    Extensions[6 ],
+    Extensions[7 ],
+    Extensions[8 ],
+    Extensions[9 ],
+    Extensions[1 ],
+    Extensions[2 ],
+    Extensions[11 ],
+    Extensions[10 ]
+];
+var defaultPropertyConfig = objDeepFreeze({
+    populateBrowserInfo: false,
+    populateOperatingSystemInfo: false,
+    userAgent: cfgDfString(),
+    userAgentData: cfgDfMerge({
+        brands: undefValue,
+        mobile: undefValue,
+        platform: undefValue
+    }),
+    userConsentCookieName: cfgDfString(),
+    userConsented: false,
+    serviceName: cfgDfString(),
+    env: cfgDfString(),
+    expId: cfgDfString(),
+    sessionRenewalMs: 1800000,
+    sessionExpirationMs: 86400000,
+    sessionAsGuid: null,
+    cookieDomain: cfgDfString(),
+    namePrefix: cfgDfString(),
+    enableApplicationInsightsTrace: false,
+    enableApplicationInsightsUser: false,
+    hashIdentifiers: false,
+    dropIdentifiers: false,
+    scrubIpOnly: false,
+    callback: cfgDfMerge({
+        userConsentDetails: null
+    }),
+    gpcDataSharingOptIn: undefValue,
+    idLength: 22,
+    enableDistributedTracing: false,
+    eventContainExtFields: false
+});
+var PropertiesPlugin = /** @class */ (function (_super) {
+    __extendsFn(PropertiesPlugin, _super);
+    function PropertiesPlugin() {
+        var _this = _super.call(this) || this;
+        _this.identifier = "SystemPropertiesCollector";
+        _this.priority = 3;
+        _this.version = '4.3.9';
+        var _context;
+        var _properties;
+        var _config;
+        dynamicProto(PropertiesPlugin, _this, function (_self, _base) {
+            _initDefaults();
+            _self.initialize = function (coreConfig, core, extensions) {
+                _base.initialize(coreConfig, core, extensions);
+                _populateDefaults(coreConfig);
+            };
+            _self.processTelemetry = function (event, itemCtx) {
+                setProcessTelemetryTimings(event, _self.identifier);
+                itemCtx = _self._getTelCtx(itemCtx);
+                var evtExt = event.ext = event.ext ? event.ext : {};
+                event.data = event.data ? event.data : {};
+                arrForEach(extensions, function (value) {
+                    evtExt[value] = evtExt[value] || {};
+                });
+                if (_context) {
+                    _context.applyUtcContext(event);
+                    _context.applyApplicationContext(event);
+                    _context.applyUserContext(event);
+                    _context.applyWebContext(event);
+                    _context.applyOsContext(event);
+                    _context.applySdkContext(event);
+                    _context.applyIntWebContext(event);
+                    _context.applyLocContext(event);
+                    _context.applySessionContext(event);
+                    _context.applyDeviceContext(event);
+                    if (_config.enableApplicationInsightsTrace) {
+                        _context.applyAITraceContext(event);
+                    }
+                    if (_config.enableDistributedTracing) {
+                        _context.applyDistributedTraceContext(event);
+                    }
+                    _context.applyCloudContext(event);
+                }
+                arrForEach(objKeys(evtExt), function (key) {
+                    if (objKeys(evtExt[key]).length === 0) {
+                        delete evtExt[key];
+                    }
+                });
+                _addPropertiesIfAbsent(_properties, event.data);
+                _self.processNext(event, itemCtx);
+            };
+            _self.getPropertiesContext = function () {
+                return _context;
+            };
+            _self.setProperty = function (name, value) {
+                _properties[name] = value;
+            };
+            _self._doTeardown = function (unloadCtx, unloadState) {
+                var core = (unloadCtx || {}).core();
+                if (core && core.getTraceCtx && _context) {
+                    var traceCtx = core.getTraceCtx(false);
+                    if (traceCtx && traceCtx === _context.getTraceCtx()) {
+                        core.setTraceCtx(null);
+                    }
+                }
+                _initDefaults();
+            };
+            _self["_getDbgPlgTargets"] = function () {
+                return [_config];
+            };
+            function _initDefaults() {
+                _context = null;
+                _properties = {};
+            }
+            function _populateDefaults(config) {
+                var identifier = _self.identifier;
+                var core = _self.core;
+                _self._addHook(onConfigChange(config, function () {
+                    var ctx = createProcessTelemetryContext(null, config, core);
+                    _config = ctx.getExtCfg(identifier, defaultPropertyConfig);
+                }));
+                _context = new TelemetryContext(config, _config, core, _self._unloadHooks);
+                if (core && core.setTraceCtx) {
+                    core.setTraceCtx(_context.getTraceCtx());
+                }
+            }
+            function _addPropertiesIfAbsent(inputMap, outputMap) {
+                if (inputMap) {
+                    objForEachKey(inputMap, function (name, inputValue) {
+                        if (!outputMap[name]) {
+                            outputMap[name] = inputValue;
+                        }
+                    });
+                }
+            }
+        });
+        return _this;
+    }
+    PropertiesPlugin.__ieDyn=1;
+    return PropertiesPlugin;
+}(BaseTelemetryPlugin));
+
+exports.AppExtensionKeys = AppExtensionKeys;
+exports.Application = Application;
+exports.Cloud = Cloud;
+exports.CloudExtKeys = CloudExtKeys;
+exports.Device = Device;
+exports.DeviceExtKeys = DeviceExtKeys;
+exports.Extensions = Extensions;
+exports.Loc = Loc;
+exports.LocExtKeys = LocExtKeys;
+exports.OSExtKeys = OSExtKeys;
+exports.OperatingSystem = OperatingSystem;
+exports.PropertiesPlugin = PropertiesPlugin;
+exports.Session = Session;
+exports.TelemetryContext = TelemetryContext;
+exports.UserExtensionKeys = UserExtensionKeys;
+exports.WebExtensionKeys = WebExtensionKeys;
+exports.defaultFlightIdNameSpaces = defaultFlightIdNameSpaces;
+
+}));
+//# sourceMappingURL=ms.properties.js.map