@microsoft/applicationinsights-core-js 3.0.0-beta.2208-03 → 3.0.0-beta.2208-16

package/dist/applicationinsights-core-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.0.0-beta.2208-03
+ * Application Insights JavaScript SDK - Core, 3.0.0-beta.2208-16
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -10,6 +10,398 @@
 
     var MinChannelPriorty = 100;
 
+    var UNDEF_VALUE = undefined;
+    var EMPTY = "";
+    var BOOLEAN = "boolean";
+    var FUNCTION = "function";
+    var NUMBER = "number";
+    var OBJECT = "object";
+    var PROTOTYPE = "prototype";
+    var STRING = "string";
+    var UNDEFINED = "undefined";
+    var HAS_OWN_PROPERTY = "hasOwnProperty";
+    var SYMBOL = "Symbol";
+    var INDEX_OF = "indexOf";
+    var LENGTH = "length";
+    var ObjClass$1 = Object;
+    var ObjProto$1 = ObjClass$1[PROTOTYPE];
+    var StrCls = String;
+    var StrProto = StrCls[PROTOTYPE];
+    var ArrCls = Array;
+
+    function _safeCheck(cb, defValue) {
+        var result = defValue;
+        try {
+            result = cb();
+        }
+        catch (e) {
+        }
+        return result;
+    }
+
+    function _createIs(theType) {
+        return function (value) {
+            return typeof value === theType;
+        };
+    }
+    function _createObjIs(theType) {
+        return function (value) {
+            return !!(value && objToString(value) === theType);
+        };
+    }
+    function objToString(value) {
+        return ObjProto$1.toString.call(value);
+    }
+    function isTypeof(value, theType) {
+        return typeof value === theType;
+    }
+    function isUndefined(value) {
+        return typeof value === UNDEFINED || value === UNDEFINED;
+    }
+    function isNullOrUndefined(value) {
+        return value === null || isUndefined(value);
+    }
+    function isDefined(arg) {
+        return !!arg || arg !== UNDEF_VALUE;
+    }
+    var isString = _createIs(STRING);
+    var isFunction = _createIs(FUNCTION);
+    function isObject(value) {
+        if (isNullOrUndefined(value)) {
+            return false;
+        }
+        return !!value && typeof value === OBJECT;
+    }
+    var isArray = ArrCls.isArray;
+    var isDate = _createObjIs("[object Date]");
+    var isNumber = _createIs(NUMBER);
+    var isBoolean = _createIs(BOOLEAN);
+    var isError = _createObjIs("[object Error]");
+    function isNotTruthy(value) {
+        return !value || !_safeCheck(function () { return (value && (0 + value)); }, value);
+    }
+    function isTruthy(value) {
+        return !(!value || _safeCheck(function () { return !(value && (0 + value)); }, !value));
+    }
+
+    var DOCUMENT = "document";
+    var HISTORY = "history";
+    var NAVIGATOR = "navigator";
+    var WINDOW = "window";
+    var _cachedGlobal$1 = null;
+    var _hasWindow = _safeCheck(function () { return isDefined(window); }, false);
+    var _hasDocument = _safeCheck(function () { return isDefined(document); }, false);
+    var _hasNavigator = _safeCheck(function () { return isDefined(navigator); }, false);
+    var _hasHistory = _safeCheck(function () { return isDefined(history); }, false);
+    _safeCheck(function () { return !!(self && self instanceof WorkerGlobalScope); }, false);
+    _safeCheck(function () { return !!(process && (process.versions || {}).node); }, false);
+    function getGlobal$1(useCached) {
+        var result = useCached === false ? null : _cachedGlobal$1;
+        if (!result) {
+            if (!result && 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;
+            }
+            _cachedGlobal$1 = result;
+        }
+        return result;
+    }
+    function getInst(name, useCached) {
+        var gbl = getGlobal$1(useCached);
+        if (gbl && gbl[name]) {
+            return gbl[name];
+        }
+        if (name === WINDOW && _hasWindow) {
+            return window;
+        }
+        return null;
+    }
+    function hasDocument() {
+        return !!getDocument();
+    }
+    function getDocument() {
+        return _hasDocument ? document : getInst(DOCUMENT);
+    }
+    function hasWindow() {
+        return !!getWindow();
+    }
+    function getWindow() {
+        return _hasWindow ? window : getInst(WINDOW);
+    }
+    function hasNavigator() {
+        return !!getNavigator();
+    }
+    function getNavigator() {
+        return _hasNavigator ? navigator : getInst(NAVIGATOR);
+    }
+    function hasHistory() {
+        return !!getHistory();
+    }
+    function getHistory() {
+        return _hasHistory ? history : getInst(HISTORY);
+    }
+
+    function objHasOwnProperty(obj, prop) {
+        return obj && ObjProto$1[HAS_OWN_PROPERTY].call(obj, prop);
+    }
+
+    function objForEachKey(theObject, callbackfn, thisArg) {
+        if (theObject && isObject(theObject)) {
+            for (var prop in theObject) {
+                if (objHasOwnProperty(theObject, prop)) {
+                    if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    function arrForEach(arr, callbackfn, thisArg) {
+        if (arr) {
+            var len = arr[LENGTH];
+            for (var idx = 0; idx < len; idx++) {
+                if (idx in arr) {
+                    if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    function throwError(message) {
+        throw new Error(message);
+    }
+    function throwTypeError$1(message) {
+        throw new TypeError(message);
+    }
+
+    var _objFreeze = ObjClass$1["freeze"];
+    function _doNothing(value) {
+        return value;
+    }
+    function objKeys(value) {
+        if (!isObject(value) || value === null) {
+            throwTypeError$1("objKeys called on non-object");
+        }
+        return ObjClass$1.keys(value);
+    }
+    function objDeepFreeze(value) {
+        if (_objFreeze) {
+            objForEachKey(value, function (key, value) {
+                if (isArray(value) || isObject(value)) {
+                    _objFreeze(value);
+                }
+            });
+        }
+        return objFreeze(value);
+    }
+    var objFreeze = _objFreeze || _doNothing;
+    var objSeal = ObjClass$1["seal"] || _doNothing;
+
+    function createEnum(values) {
+        var theEnum = {};
+        objForEachKey(values, function (field, value) {
+            theEnum[field] = value;
+            theEnum[value] = field;
+        });
+        return objDeepFreeze(theEnum);
+    }
+    function createSimpleMap(values) {
+        var mapClass = {};
+        objForEachKey(values, function (field, value) {
+            mapClass[field] = value[1];
+            mapClass[value[0]] = value[1];
+        });
+        return objDeepFreeze(mapClass);
+    }
+    function createTypeMap(values) {
+        return createSimpleMap(values);
+    }
+
+    _safeCheck(function () { return isDefined(Symbol); }, false);
+    var _symbol = getInst(SYMBOL);
+    _symbol && _safeCheck(function () { return _symbol["for"]; }, null);
+    _symbol && _safeCheck(function () { return _symbol["keyFor"]; }, null);
+    var isSymbol = _createIs("symbol");
+
+    function dumpObj(object, format) {
+        var objectTypeDump = objToString(object);
+        var propertyValueDump = "";
+        if (objectTypeDump === "[object Error]") {
+            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+        }
+        else {
+            if (format) {
+                if (isNumber(format)) {
+                    propertyValueDump = JSON.stringify(object, null, format);
+                }
+                else {
+                    propertyValueDump = JSON.stringify(object, null, format ? 4 : 0);
+                }
+            }
+            else {
+                propertyValueDump = JSON.stringify(object);
+            }
+        }
+        return objectTypeDump + ": " + propertyValueDump;
+    }
+
+    function _unwrapFunction(funcName) {
+        return function (thisArg) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            if ((thisArg || thisArg === EMPTY) && thisArg[funcName]) {
+                return thisArg[funcName].apply(thisArg, args);
+            }
+            throwTypeError$1("'" + funcName + "' not defined for " + dumpObj(thisArg));
+        };
+    }
+
+    var arrIndexOf = _unwrapFunction(INDEX_OF);
+
+    var arrMap = _unwrapFunction("map");
+
+    var arrReduce = _unwrapFunction("reduce");
+
+    function objSetPrototypeOf(obj, proto) {
+        var fn = ObjClass$1["setPrototypeOf"] ||
+            ({ __proto__: [] } instanceof Array && function (d, b) {
+                d.__proto__ = b;
+            }) ||
+            function (d, b) {
+                objForEachKey(b, function (key, value) {
+                    d[key] = value;
+                });
+            };
+        return fn(obj, proto);
+    }
+
+    function _createCustomError(name, d, b) {
+        objSetPrototypeOf(d, b);
+        function __() {
+            this.constructor = d;
+        }
+        __[PROTOTYPE] = b[PROTOTYPE];
+        __[PROTOTYPE].name = name;
+        d[PROTOTYPE] = new __();
+        return d;
+    }
+    function createCustomError(name, constructCb) {
+        var baseClass = Error;
+        var customError = _createCustomError(name, function () {
+            var _this = this;
+            _this = baseClass.apply(_this, arguments) || _this;
+            constructCb && constructCb(_this, arguments);
+            return _this;
+        }, baseClass);
+        return customError;
+    }
+    var _unsupportedError;
+    function throwUnsupported(message) {
+        if (!_unsupportedError) {
+            _unsupportedError = createCustomError("UnsupportedError");
+        }
+        throw new _unsupportedError(message);
+    }
+
+    var _objDefineProperty$1 = ObjClass$1["defineProperty"];
+    function objDefineProp(target, key, descriptor) {
+        if (_objDefineProperty$1) {
+            _objDefineProperty$1(target, key, descriptor);
+            return target;
+        }
+        throwUnsupported("Unable to define property [" + objToString(key) + "] on " + dumpObj(target));
+    }
+    function objDefineAccessors(target, prop, getProp, setProp, configurable) {
+        if (_objDefineProperty$1) {
+            try {
+                var descriptor = {
+                    enumerable: true,
+                    configurable: isUndefined(configurable) ? true : configurable
+                };
+                if (getProp) {
+                    descriptor.get = getProp;
+                }
+                if (setProp) {
+                    descriptor.set = setProp;
+                }
+                return objDefineProp(target, prop, descriptor);
+            }
+            catch (e) {
+                throwUnsupported("Unable to define accessors for [" + objToString(prop) + "] on " + dumpObj(target));
+            }
+        }
+    }
+
+    var strSubstring = _unwrapFunction("substring");
+
+    var ENDS_WITH = "endsWith";
+    var strEndsWith = StrProto[ENDS_WITH] ? _unwrapFunction(ENDS_WITH) : polyStrEndsWith;
+    function polyStrEndsWith(value, searchString, length) {
+        if (!isString(value)) {
+            throwTypeError$1("'" + dumpObj(value) + "' is not a string");
+        }
+        var searchValue = isString(searchString) ? searchString : "" + searchString;
+        var chkLen = searchValue[LENGTH];
+        var len = value[LENGTH];
+        var end = !isUndefined(length) && length < len ? length : len;
+        return strSubstring(value, end - chkLen, end) === searchValue;
+    }
+
+    var strIndexOf = _unwrapFunction(INDEX_OF);
+
+    var STARTS_WITH = "startsWith";
+    var strStartsWith = StrProto[STARTS_WITH] ? _unwrapFunction(STARTS_WITH) : polyStrStartsWith;
+    function polyStrStartsWith(value, searchString, position) {
+        if (!isString(value)) {
+            throwTypeError$1("'" + dumpObj(value) + "' is not a string");
+        }
+        var searchValue = isString(searchString) ? searchString : "" + searchString;
+        var chkLen = searchValue[LENGTH];
+        var pos = position > 0 ? position : 0;
+        return strSubstring(value, pos, pos + chkLen) === searchValue;
+    }
+
+    function _createTrimFn(exp) {
+        return function _doTrim(value) {
+            if (isNullOrUndefined(value)) {
+                throwTypeError$1("strTrim called [" + dumpObj(value) + "]");
+            }
+            if (value && value.replace) {
+                value = value.replace(exp, "");
+            }
+            return value;
+        };
+    }
+    var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
+
+    var TRIM = "trim";
+    var strTrim = StrProto[TRIM] ? _unwrapFunction(TRIM) : polyStrTrim;
+
+    var createEnumStyle = createEnum;
+    var createValueMap = createTypeMap;
+
+    var EventsDiscardedReason = createEnumStyle({
+        Unknown: 0 ,
+        NonRetryableStatus: 1 ,
+        InvalidEvent: 2 ,
+        SizeLimitExceeded: 3 ,
+        KillSwitch: 4 ,
+        QueueFull: 5
+    });
+
     var strShimFunction = "function";
     var strShimObject = "object";
     var strShimUndefined = "undefined";
@@ -94,436 +486,428 @@
         return to;
     }
 
-    var _DYN_INITIALIZE = "initialize";
-    var _DYN_NAME = "name";
-    var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
-    var _DYN_IDENTIFIER = "identifier";
-    var _DYN_PUSH = "push";
-    var _DYN_IS_INITIALIZED = "isInitialized";
-    var _DYN_CONFIG = "config";
-    var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
-    var _DYN_LOGGER = "logger";
-    var _DYN_LENGTH = "length";
-    var _DYN_TIME = "time";
-    var _DYN_PROCESS_NEXT = "processNext";
-    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
-    var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
-    var _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
-    var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
-    var _DYN_ON_COMPLETE = "onComplete";
-    var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_FLUSH = "flush";
-    var _DYN__EXTENSIONS = "_extensions";
-    var _DYN_SPLICE = "splice";
-    var _DYN_TEARDOWN = "teardown";
-    var _DYN_MESSAGE_ID = "messageId";
-    var _DYN_MESSAGE = "message";
-    var _DYN_IS_ASYNC = "isAsync";
-    var _DYN__DO_TEARDOWN = "_doTeardown";
-    var _DYN_UPDATE = "update";
-    var _DYN_GET_NEXT = "getNext";
-    var _DYN_DIAG_LOG = "diagLog";
-    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-    var _DYN_CREATE_NEW = "createNew";
-    var _DYN_COOKIE_CFG = "cookieCfg";
-    var _DYN_INDEX_OF = "indexOf";
-    var _DYN_SUBSTRING = "substring";
-    var _DYN_USER_AGENT = "userAgent";
-    var _DYN_SPLIT = "split";
-    var _DYN_SET_ENABLED = "setEnabled";
-    var _DYN_REPLACE = "replace";
-    var _DYN_SUBSTR = "substr";
-    var _DYN_NODE_TYPE = "nodeType";
-    var _DYN_APPLY = "apply";
-    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
-    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
-    var _DYN_TO_LOWER_CASE = "toLowerCase";
-    var _DYN_CALL = "call";
-    var _DYN_TYPE = "type";
-    var _DYN_HANDLER = "handler";
-    var _DYN_LISTENERS = "listeners";
-    var _DYN_IS_CHILD_EVT = "isChildEvt";
-    var _DYN_GET_CTX = "getCtx";
-    var _DYN_SET_CTX = "setCtx";
-    var _DYN_COMPLETE = "complete";
-    var _DYN_TRACE_ID = "traceId";
-    var _DYN_SPAN_ID = "spanId";
-    var _DYN_TRACE_FLAGS = "traceFlags";
-    var _DYN_VERSION = "version";
-
-    var STR_EMPTY = "";
-    var STR_CHANNELS = "channels";
-    var STR_CORE = "core";
-    var STR_CREATE_PERF_MGR = "createPerfMgr";
-    var STR_DISABLED = "disabled";
-    var STR_EXTENSION_CONFIG = "extensionConfig";
-    var STR_EXTENSIONS = "extensions";
-    var STR_PROCESS_TELEMETRY = "processTelemetry";
-    var STR_PRIORITY = "priority";
-    var STR_EVENTS_SENT = "eventsSent";
-    var STR_EVENTS_DISCARDED = "eventsDiscarded";
-    var STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
-    var STR_PERF_EVENT = "perfEvent";
-    var STR_ERROR_TO_CONSOLE = "errorToConsole";
-    var STR_WARN_TO_CONSOLE = "warnToConsole";
-    var STR_GET_PERF_MGR = "getPerfMgr";
-
-    var strToISOString = "toISOString";
-    var cStrEndsWith = "endsWith";
-    var cStrStartsWith = "startsWith";
-    var strIndexOf = "indexOf";
-    var strMap = "map";
-    var strReduce = "reduce";
-    var cStrTrim = "trim";
-    var strToString = "toString";
-    var str__Proto$1 = "__proto__";
-    var strConstructor = "constructor";
-    var _objDefineProperty$1 = ObjDefineProperty;
-    var _objFreeze = ObjClass.freeze;
-    var _objSeal = ObjClass.seal;
-    var _objKeys = ObjClass.keys;
-    var StringProto = String[strShimPrototype];
-    var _strTrim = StringProto[cStrTrim];
-    var _strEndsWith = StringProto[cStrEndsWith];
-    var _strStartsWith = StringProto[cStrStartsWith];
-    var DateProto = Date[strShimPrototype];
-    var _dataToISOString = DateProto[strToISOString];
-    var _isArray = Array.isArray;
-    var _objToString = ObjProto[strToString];
-    var _fnToString = ObjHasOwnProperty[strToString];
-    var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass);
-    var rCamelCase = /-([a-z])/g;
-    var rNormalizeInvalid = /([^\w\d_$])/g;
-    var rLeadingNumeric = /^(\d+[\w\d_$])/;
-    var _objGetPrototypeOf$1 = Object["getPrototypeOf"];
-    function _getObjProto$1(target) {
-        if (target) {
-            if (_objGetPrototypeOf$1) {
-                return _objGetPrototypeOf$1(target);
-            }
-            var newProto = target[str__Proto$1] || target[strShimPrototype] || target[strConstructor];
-            if (newProto) {
-                return newProto;
-            }
-        }
-        return null;
-    }
-    function objToString(obj) {
-        return _objToString[_DYN_CALL ](obj);
-    }
-    function isTypeof(value, theType) {
-        return typeof value === theType;
-    }
-    function isUndefined(value) {
-        return value === undefined || typeof value === strShimUndefined;
-    }
-    function isNotUndefined(value) {
-        return !isUndefined(value);
-    }
-    function isNullOrUndefined(value) {
-        return (value === null || isUndefined(value));
-    }
-    function isNotNullOrUndefined(value) {
-        return !isNullOrUndefined(value);
-    }
-    function hasOwnProperty(obj, prop) {
-        return !!(obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop));
-    }
-    function isObject(value) {
-        return !!(value && typeof value === strShimObject);
+    /*!
+     * Microsoft Dynamic Proto Utility, 1.1.6
+     * Copyright (c) Microsoft and contributors. All rights reserved.
+     */
+    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 DynProtoCurrent = "_dynInstProto";
+    var strUseBaseInst = 'useBaseInst';
+    var strSetInstFuncs = 'setInstFuncs';
+    var Obj = Object;
+    var _objGetPrototypeOf = Obj["getPrototypeOf"];
+    var _objGetOwnProps = Obj["getOwnPropertyNames"];
+    var _dynamicNames = 0;
+    function _hasOwnProperty(obj, prop) {
+        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
     }
-    function isFunction(value) {
-        return !!(value && typeof value === strShimFunction);
+    function _isObjectOrArrayPrototype(target) {
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
     }
-    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 _isObjectArrayOrFunctionPrototype(target) {
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
     }
-    function objForEachKey(target, callbackfn) {
+    function _getObjProto$1(target) {
+        var newProto;
         if (target) {
-            for (var prop in target) {
-                if (ObjHasOwnProperty[_DYN_CALL ](target, prop)) {
-                    callbackfn[_DYN_CALL ](target, prop, target[prop]);
-                }
+            if (_objGetPrototypeOf) {
+                return _objGetPrototypeOf(target);
             }
-        }
-    }
-    function strEndsWith(value, search) {
-        var result = false;
-        if (value && search && !(result = value === search)) {
-            result = _strEndsWith ? value[cStrEndsWith](search) : _strEndsWithPoly(value, search);
-        }
-        return result;
-    }
-    function _strEndsWithPoly(value, search) {
-        var result = false;
-        var searchLen = search ? search[_DYN_LENGTH ] : 0;
-        var valLen = value ? value[_DYN_LENGTH ] : 0;
-        if (searchLen && valLen && valLen >= searchLen && !(result = value === search)) {
-            var pos = valLen - 1;
-            for (var lp = searchLen - 1; lp >= 0; lp--) {
-                if (value[pos] != search[lp]) {
-                    return false;
-                }
-                pos--;
+            var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+            newProto = target[DynProtoBaseProto] || curProto;
+            if (!_hasOwnProperty(target, DynProtoBaseProto)) {
+                delete target[DynProtoCurrent];
+                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+                target[DynProtoCurrent] = curProto;
             }
-            result = true;
         }
-        return result;
+        return newProto;
     }
-    function strStartsWith(value, checkValue) {
-        var result = false;
-        if (value && checkValue && !(result = value === checkValue)) {
-            result = _strStartsWith ? value[cStrStartsWith](checkValue) : _strStartsWithPoly(value, checkValue);
+    function _forEachProp(target, func) {
+        var props = [];
+        if (_objGetOwnProps) {
+            props = _objGetOwnProps(target);
         }
-        return result;
-    }
-    function _strStartsWithPoly(value, checkValue) {
-        var result = false;
-        var chkLen = checkValue ? checkValue[_DYN_LENGTH ] : 0;
-        if (value && chkLen && value[_DYN_LENGTH ] >= chkLen && !(result = value === checkValue)) {
-            for (var lp = 0; lp < chkLen; lp++) {
-                if (value[lp] !== checkValue[lp]) {
-                    return false;
+        else {
+            for (var name_1 in target) {
+                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
+                    props.push(name_1);
                 }
             }
-            result = true;
         }
-        return result;
-    }
-    function strContains(value, search) {
-        if (value && search) {
-            return value[_DYN_INDEX_OF ](search) !== -1;
+        if (props && props.length > 0) {
+            for (var lp = 0; lp < props.length; lp++) {
+                func(props[lp]);
+            }
         }
-        return false;
-    }
-    function isDate(obj) {
-        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Date]");
-    }
-    var isArray = _isArray || _isArrayPoly;
-    function _isArrayPoly(obj) {
-        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Array]");
-    }
-    function isError(obj) {
-        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Error]");
-    }
-    function isString(value) {
-        return typeof value === "string";
-    }
-    function isNumber(value) {
-        return typeof value === "number";
     }
-    function isBoolean(value) {
-        return typeof value === "boolean";
+    function _isDynamicCandidate(target, funcName, skipOwn) {
+        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
     }
-    function isSymbol(value) {
-        return typeof value === "symbol";
+    function _throwTypeError(message) {
+        throw new TypeError("DynamicProto: " + message);
     }
-    function isPlainObject(value) {
-        var result = false;
-        if (value && typeof value === "object") {
-            var proto = _objGetPrototypeOf$1 ? _objGetPrototypeOf$1(value) : _getObjProto$1(value);
-            if (!proto) {
-                result = true;
-            }
-            else {
-                if (proto[strConstructor] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor)) {
-                    proto = proto[strConstructor];
-                }
-                result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
+    function _getInstanceFuncs(thisTarget) {
+        var instFuncs = {};
+        _forEachProp(thisTarget, function (name) {
+            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+                instFuncs[name] = thisTarget[name];
             }
-        }
-        return result;
+        });
+        return instFuncs;
     }
-    function toISOString(date) {
-        if (date) {
-            return _dataToISOString ? date[strToISOString]() : _toISOStringPoly(date);
+    function _hasVisited(values, value) {
+        for (var lp = values.length - 1; lp >= 0; lp--) {
+            if (values[lp] === value) {
+                return true;
+            }
         }
+        return false;
     }
-    function _toISOStringPoly(date) {
-        if (date && date.getUTCFullYear) {
-            var pad = function (num) {
-                var r = String(num);
-                if (r[_DYN_LENGTH ] === 1) {
-                    r = "0" + r;
+    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 r;
+            }
+            return function () {
+                return theFunc.apply(target, arguments);
             };
-            return date.getUTCFullYear()
-                + "-" + pad(date.getUTCMonth() + 1)
-                + "-" + pad(date.getUTCDate())
-                + "T" + pad(date.getUTCHours())
-                + ":" + pad(date.getUTCMinutes())
-                + ":" + pad(date.getUTCSeconds())
-                + "." + String((date.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
-                + "Z";
         }
-    }
-    function arrForEach(arr, callbackfn, thisArg) {
-        var len = arr[_DYN_LENGTH ];
-        try {
-            for (var idx = 0; idx < len; idx++) {
-                if (idx in arr) {
-                    if (callbackfn[_DYN_CALL ](thisArg || arr, arr[idx], idx, arr) === -1) {
-                        break;
-                    }
+        var baseFuncs = {};
+        _forEachProp(instFuncs, function (name) {
+            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+        });
+        var baseProto = _getObjProto$1(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);
                 }
-            }
-        }
-        catch (e) {
+            });
+            visited.push(baseProto);
+            baseProto = _getObjProto$1(baseProto);
         }
+        return baseFuncs;
     }
-    function arrIndexOf(arr, searchElement, fromIndex) {
-        if (arr) {
-            if (arr[strIndexOf]) {
-                return arr[strIndexOf](searchElement, fromIndex);
+    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+        var instFunc = null;
+        if (target && _hasOwnProperty(proto, DynClassName)) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+            if (!instFunc) {
+                _throwTypeError("Missing [" + funcName + "] " + strFunction);
             }
-            var len = arr[_DYN_LENGTH ];
-            var from = fromIndex || 0;
-            try {
-                for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
-                    if (lp in arr && arr[lp] === searchElement) {
-                        return lp;
+            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+                var canAddInst = !_hasOwnProperty(target, funcName);
+                var objProto = _getObjProto$1(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$1(objProto);
                 }
-            }
-            catch (e) {
-            }
-        }
-        return -1;
-    }
-    function arrMap(arr, callbackfn, thisArg) {
-        var results;
-        if (arr) {
-            if (arr[strMap]) {
-                return arr[strMap](callbackfn, thisArg);
-            }
-            var len = arr[_DYN_LENGTH ];
-            var _this = thisArg || arr;
-            results = new Array(len);
-            try {
-                for (var lp = 0; lp < len; lp++) {
-                    if (lp in arr) {
-                        results[lp] = callbackfn[_DYN_CALL ](_this, arr[lp], arr);
+                try {
+                    if (canAddInst) {
+                        target[funcName] = instFunc;
                     }
+                    instFunc[DynInstChkTag] = 1;
                 }
-            }
-            catch (e) {
-            }
-        }
-        return results;
-    }
-    function arrReduce(arr, callbackfn, initialValue) {
-        var value;
-        if (arr) {
-            if (arr[strReduce]) {
-                return arr[strReduce](callbackfn, initialValue);
-            }
-            var len = arr[_DYN_LENGTH ];
-            var lp = 0;
-            if (arguments[_DYN_LENGTH ] >= 3) {
-                value = arguments[2];
-            }
-            else {
-                while (lp < len && !(lp in arr)) {
-                    lp++;
-                }
-                value = arr[lp++];
-            }
-            while (lp < len) {
-                if (lp in arr) {
-                    value = callbackfn(value, arr[lp], lp, arr);
+                catch (e) {
+                    instFuncTable[DynAllowInstChkTag] = false;
                 }
-                lp++;
             }
         }
-        return value;
+        return instFunc;
     }
-    function strTrim(str) {
-        if (str) {
-            str = (_strTrim && str[cStrTrim]) ? str[cStrTrim]() : (str[_DYN_REPLACE ] ? str[_DYN_REPLACE ](/^\s+|\s+$/g, STR_EMPTY) : str);
-        }
-        return str;
-    }
-    var _objKeysHasDontEnumBug = !({ toString: null }).propertyIsEnumerable("toString");
-    var _objKeysDontEnums = [
-        "toString",
-        "toLocaleString",
-        "valueOf",
-        "hasOwnProperty",
-        "isPrototypeOf",
-        "propertyIsEnumerable",
-        "constructor"
-    ];
-    function objKeys(obj) {
-        var objType = typeof obj;
-        if (objType !== strShimFunction && (objType !== strShimObject || obj === null)) {
-            throwTypeError("objKeys called on non-object");
-        }
-        if (!_objKeysHasDontEnumBug && _objKeys) {
-            return _objKeys(obj);
-        }
-        var result = [];
-        for (var prop in obj) {
-            if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop)) {
-                result[_DYN_PUSH ](prop);
-            }
+    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+        var protoFunc = proto[funcName];
+        if (protoFunc === currentDynProtoProxy) {
+            protoFunc = _getObjProto$1(proto)[funcName];
         }
-        if (_objKeysHasDontEnumBug) {
-            var dontEnumsLength = _objKeysDontEnums[_DYN_LENGTH ];
-            for (var lp = 0; lp < dontEnumsLength; lp++) {
-                if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, _objKeysDontEnums[lp])) {
-                    result[_DYN_PUSH ](_objKeysDontEnums[lp]);
-                }
-            }
+        if (typeof protoFunc !== strFunction) {
+            _throwTypeError("[" + funcName + "] is not a " + strFunction);
         }
-        return result;
+        return protoFunc;
     }
-    function objDefineAccessors(target, prop, getProp, setProp) {
-        if (_objDefineProperty$1) {
-            try {
-                var descriptor = {
-                    enumerable: true,
-                    configurable: true
-                };
-                if (getProp) {
-                    descriptor.get = getProp;
+    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+        function _createDynamicPrototype(proto, funcName) {
+            var dynProtoProxy = function () {
+                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+                return instFunc.apply(this, arguments);
+            };
+            dynProtoProxy[DynProxyTag] = 1;
+            return dynProtoProxy;
+        }
+        if (!_isObjectOrArrayPrototype(proto)) {
+            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            }
+            _forEachProp(target, function (name) {
+                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                    instFuncs_1[name] = target[name];
+                    delete target[name];
+                    if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                        proto[name] = _createDynamicPrototype(proto, name);
+                    }
                 }
-                if (setProp) {
-                    descriptor.set = setProp;
+            });
+        }
+    }
+    function _checkPrototype(classProto, thisTarget) {
+        if (_objGetPrototypeOf) {
+            var visited = [];
+            var thisProto = _getObjProto$1(thisTarget);
+            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+                if (thisProto === classProto) {
+                    return true;
                 }
-                _objDefineProperty$1(target, prop, descriptor);
-                return true;
+                visited.push(thisProto);
+                thisProto = _getObjProto$1(thisProto);
             }
-            catch (e) {
+            return false;
+        }
+        return true;
+    }
+    function _getObjName(target, unknownValue) {
+        if (_hasOwnProperty(target, Prototype)) {
+            return target.name || unknownValue || UnknownValue;
+        }
+        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+    }
+    function dynamicProto(theClass, target, delegateFunc, options) {
+        if (!_hasOwnProperty(theClass, Prototype)) {
+            _throwTypeError("theClass is an invalid class definition.");
+        }
+        var classProto = theClass[Prototype];
+        if (!_checkPrototype(classProto, target)) {
+            _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
+        }
+        var className = null;
+        if (_hasOwnProperty(classProto, DynClassName)) {
+            className = classProto[DynClassName];
+        }
+        else {
+            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _dynamicNames;
+            _dynamicNames++;
+            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);
+    }
+    var perfDefaults = {
+        setInstFuncs: true,
+        useBaseInst: true
+    };
+    dynamicProto[DynProtoDefaultOptions] = perfDefaults;
+
+    var _DYN_INITIALIZE = "initialize";
+    var _DYN_NAME = "name";
+    var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
+    var _DYN_IDENTIFIER = "identifier";
+    var _DYN_PUSH = "push";
+    var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_CONFIG = "config";
+    var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
+    var _DYN_LOGGER = "logger";
+    var _DYN_LENGTH = "length";
+    var _DYN_TIME = "time";
+    var _DYN_PROCESS_NEXT = "processNext";
+    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
+    var _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
+    var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
+    var _DYN_ON_COMPLETE = "onComplete";
+    var _DYN_GET_PLUGIN = "getPlugin";
+    var _DYN_FLUSH = "flush";
+    var _DYN__EXTENSIONS = "_extensions";
+    var _DYN_SPLICE = "splice";
+    var _DYN_TEARDOWN = "teardown";
+    var _DYN_MESSAGE_ID = "messageId";
+    var _DYN_MESSAGE = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+    var _DYN_CREATE_NEW = "createNew";
+    var _DYN_COOKIE_CFG = "cookieCfg";
+    var _DYN_SUBSTRING = "substring";
+    var _DYN_USER_AGENT = "userAgent";
+    var _DYN_SPLIT = "split";
+    var _DYN_SUBSTR = "substr";
+    var _DYN_NODE_TYPE = "nodeType";
+    var _DYN_APPLY = "apply";
+    var _DYN_REPLACE = "replace";
+    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_TYPE = "type";
+    var _DYN_HANDLER = "handler";
+    var _DYN_CALL = "call";
+    var _DYN_LISTENERS = "listeners";
+    var _DYN_IS_CHILD_EVT = "isChildEvt";
+    var _DYN_GET_CTX = "getCtx";
+    var _DYN_SET_CTX = "setCtx";
+    var _DYN_COMPLETE = "complete";
+    var _DYN_TRACE_ID = "traceId";
+    var _DYN_SPAN_ID = "spanId";
+    var _DYN_TRACE_FLAGS = "traceFlags";
+    var _DYN_VERSION = "version";
+
+    var STR_EMPTY = "";
+    var STR_CHANNELS = "channels";
+    var STR_CORE = "core";
+    var STR_CREATE_PERF_MGR = "createPerfMgr";
+    var STR_DISABLED = "disabled";
+    var STR_EXTENSION_CONFIG = "extensionConfig";
+    var STR_EXTENSIONS = "extensions";
+    var STR_PROCESS_TELEMETRY = "processTelemetry";
+    var STR_PRIORITY = "priority";
+    var STR_EVENTS_SENT = "eventsSent";
+    var STR_EVENTS_DISCARDED = "eventsDiscarded";
+    var STR_EVENTS_SEND_REQUEST = "eventsSendRequest";
+    var STR_PERF_EVENT = "perfEvent";
+    var STR_ERROR_TO_CONSOLE = "errorToConsole";
+    var STR_WARN_TO_CONSOLE = "warnToConsole";
+    var STR_GET_PERF_MGR = "getPerfMgr";
+
+    var listenerFuncs = ["eventsSent", "eventsDiscarded", "eventsSendRequest", "perfEvent"];
+    var _aiNamespace = null;
+    var _debugListener;
+    function _listenerProxyFunc(name, config) {
+        return function () {
+            var args = arguments;
+            var dbgExt = getDebugExt(config);
+            if (dbgExt) {
+                var listener = dbgExt.listener;
+                if (listener && listener[name]) {
+                    listener[name][_DYN_APPLY ](listener, args);
+                }
             }
+        };
+    }
+    function _getExtensionNamespace() {
+        var target = getInst("Microsoft");
+        if (target) {
+            _aiNamespace = target["ApplicationInsights"];
         }
-        return false;
+        return _aiNamespace;
     }
-    function _doNothing(value) {
+    function getDebugExt(config) {
+        var ns = _aiNamespace;
+        if (!ns && config.disableDbgExt !== true) {
+            ns = _aiNamespace || _getExtensionNamespace();
+        }
+        return ns ? ns["ChromeDbgExt"] : null;
+    }
+    function getDebugListener(config) {
+        if (!_debugListener) {
+            _debugListener = {};
+            for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH ]; lp++) {
+                _debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
+            }
+        }
+        return _debugListener;
+    }
+
+    var cString = "String";
+    var cObject = "Object";
+    var strToISOString = "toISOString";
+    var strToString = "toString";
+    var strGetPrototypeOf = "getPrototypeOf";
+    var strConstructor = "constructor";
+    var DateProto = Date[strShimPrototype];
+    var _dateToISOString = DateProto[strToISOString] || _polyfillRequired("Date", strToISOString);
+    var _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
+    var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass);
+    var rCamelCase = /-([a-z])/g;
+    var rNormalizeInvalid = /([^\w\d_$])/g;
+    var rLeadingNumeric = /^(\d+[\w\d_$])/;
+    function _polyfillRequired(object, name) {
+        return function () {
+            throwUnsupported("Polyfill required for [" + name + "]");
+        };
+    }
+    var _getObjProto = Object[strGetPrototypeOf] || _polyfillRequired(cObject, strGetPrototypeOf);
+    function isNotUndefined(value) {
+        return !isUndefined(value);
+    }
+    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 deepFreeze(obj) {
-        if (_objFreeze) {
-            objForEachKey(obj, function (name, value) {
-                if (isArray(value) || isObject(value)) {
-                    _objFreeze(value);
+    function strContains(value, search) {
+        if (value && search) {
+            return strIndexOf(value, search) !== -1;
+        }
+        return false;
+    }
+    function isPlainObject(value) {
+        var result = false;
+        if (value && typeof value === "object") {
+            var proto = _getObjProto(value);
+            if (!proto) {
+                result = true;
+            }
+            else {
+                if (proto[strConstructor] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor)) {
+                    proto = proto[strConstructor];
                 }
-            });
+                result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
+            }
         }
-        return objFreeze(obj);
+        return result;
+    }
+    function toISOString(date) {
+        return _dateToISOString[_DYN_CALL ](date);
     }
-    var objFreeze = _objFreeze || _doNothing;
-    var objSeal = _objSeal || _doNothing;
     function dateNow() {
         var dt = Date;
         return dt.now ? dt.now() : new dt().getTime();
@@ -562,15 +946,6 @@
     function getCfgValue(theValue, defaultValue) {
         return !isNullOrUndefined(theValue) ? theValue : defaultValue;
     }
-    function isNotTruthy(value) {
-        return !value;
-    }
-    function isTruthy(value) {
-        return !!value;
-    }
-    function throwError(message) {
-        throw new Error(message);
-    }
     function _createProxyFunction(source, funcName) {
         var srcFunc = null;
         var src = null;
@@ -601,7 +976,7 @@
                         }
                     }
                     else if (!chkSet || chkSet(field, false, source, target)) {
-                        if (hasOwnProperty(target, field)) {
+                        if (objHasOwnProperty(target, field)) {
                             delete target[field];
                         }
                         if (!objDefineAccessors(target, field, function () {
@@ -640,10 +1015,10 @@
     function createClassFromInterface(defaults) {
         return /** @class */ (function () {
             function class_1() {
-                var _this_1 = this;
+                var _this = this;
                 if (defaults) {
                     objForEachKey(defaults, function (field, value) {
-                        _this_1[field] = value;
+                        _this[field] = value;
                     });
                 }
             }
@@ -701,1738 +1076,704 @@
         return extended;
     }
 
-    function createEnumStyle(values) {
-        var enumClass = {};
-        objForEachKey(values, function (field, value) {
-            enumClass[field] = value;
-            enumClass[value] = field;
-        });
-        return deepFreeze(enumClass);
-    }
-    function createEnumMap(values) {
-        var mapClass = {};
-        objForEachKey(values, function (field, value) {
-            mapClass[field] = field;
-            mapClass[value] = field;
-        });
-        return deepFreeze(mapClass);
+    var strDocumentMode = "documentMode";
+    var strLocation = "location";
+    var strConsole = "console";
+    var strPerformance = "performance";
+    var strJSON = "JSON";
+    var strCrypto = "crypto";
+    var strMsCrypto = "msCrypto";
+    var strReactNative = "ReactNative";
+    var strMsie = "msie";
+    var strTrident = "trident/";
+    var strXMLHttpRequest = "XMLHttpRequest";
+    var _isTrident = null;
+    var _navUserAgentCheck = null;
+    var _enableMocks = false;
+    var _useXDomainRequest = null;
+    var _beaconsSupported = null;
+    function _hasProperty(theClass, property) {
+        var supported = false;
+        if (theClass) {
+            try {
+                supported = property in theClass;
+                if (!supported) {
+                    var proto = theClass[strShimPrototype];
+                    if (proto) {
+                        supported = property in proto;
+                    }
+                }
+            }
+            catch (e) {
+            }
+            if (!supported) {
+                try {
+                    var tmp = new theClass();
+                    supported = !isUndefined(tmp[property]);
+                }
+                catch (e) {
+                }
+            }
+        }
+        return supported;
     }
-    function createValueMap(values) {
-        var mapClass = {};
-        objForEachKey(values, function (field, value) {
-            mapClass[field] = value[1];
-            mapClass[value[0]] = value[1];
-        });
-        return deepFreeze(mapClass);
+    function setEnableEnvMocks(enabled) {
+        _enableMocks = enabled;
     }
-
-    var EventsDiscardedReason = createEnumStyle({
-        Unknown: 0 ,
-        NonRetryableStatus: 1 ,
-        InvalidEvent: 2 ,
-        SizeLimitExceeded: 3 ,
-        KillSwitch: 4 ,
-        QueueFull: 5
-    });
-
-    /*!
-     * Microsoft Dynamic Proto Utility, 1.1.6
-     * Copyright (c) Microsoft and contributors. All rights reserved.
-     */
-    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 DynProtoCurrent = "_dynInstProto";
-    var strUseBaseInst = 'useBaseInst';
-    var strSetInstFuncs = 'setInstFuncs';
-    var Obj = Object;
-    var _objGetPrototypeOf = Obj["getPrototypeOf"];
-    var _objGetOwnProps = Obj["getOwnPropertyNames"];
-    var _dynamicNames = 0;
-    function _hasOwnProperty(obj, prop) {
-        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
+    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 _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
+    function getConsole() {
+        if (typeof console !== strShimUndefined) {
+            return console;
+        }
+        return getInst(strConsole);
     }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    function getPerformance() {
+        return getInst(strPerformance);
     }
-    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 (!_hasOwnProperty(target, DynProtoBaseProto)) {
-                delete target[DynProtoCurrent];
-                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-                target[DynProtoCurrent] = curProto;
-            }
+    function hasJSON() {
+        return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
+    }
+    function getJSON() {
+        if (hasJSON()) {
+            return JSON || getInst(strJSON);
         }
-        return newProto;
+        return null;
     }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
+    function getCrypto() {
+        return getInst(strCrypto);
+    }
+    function getMsCrypto() {
+        return getInst(strMsCrypto);
+    }
+    function isReactNative() {
+        var nav = getNavigator();
+        if (nav && nav.product) {
+            return nav.product === strReactNative;
         }
-        else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
-                    props.push(name_1);
-                }
-            }
+        return false;
+    }
+    function isIE() {
+        var nav = getNavigator();
+        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
+            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
+        return _isTrident;
+    }
+    function getIEVersion(userAgentStr) {
+        if (userAgentStr === void 0) { userAgentStr = null; }
+        if (!userAgentStr) {
+            var navigator_1 = getNavigator() || {};
+            userAgentStr = navigator_1 ? (navigator_1[_DYN_USER_AGENT ] || STR_EMPTY)[_DYN_TO_LOWER_CASE ]() : STR_EMPTY;
+        }
+        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
+        if (strContains(ua, strMsie)) {
+            var doc = getDocument() || {};
+            return Math.max(parseInt(ua[_DYN_SPLIT ](strMsie)[1]), (doc[strDocumentMode] || 0));
+        }
+        else if (strContains(ua, strTrident)) {
+            var tridentVer = parseInt(ua[_DYN_SPLIT ](strTrident)[1]);
+            if (tridentVer) {
+                return tridentVer + 4;
             }
         }
+        return null;
     }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
+    function isSafari(userAgentStr) {
+        if (!userAgentStr || !isString(userAgentStr)) {
+            var navigator_2 = getNavigator() || {};
+            userAgentStr = navigator_2 ? (navigator_2[_DYN_USER_AGENT ] || STR_EMPTY)[_DYN_TO_LOWER_CASE ]() : STR_EMPTY;
+        }
+        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
+        return (ua.indexOf("safari") >= 0);
     }
-    function _throwTypeError(message) {
-        throw new TypeError("DynamicProto: " + message);
+    function isBeaconsSupported() {
+        if (_beaconsSupported === null) {
+            _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
+        }
+        return _beaconsSupported;
     }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
+    function isFetchSupported(withKeepAlive) {
+        var isSupported = false;
+        try {
+            isSupported = !!getInst("fetch");
+            var request = getInst("Request");
+            if (isSupported && withKeepAlive && request) {
+                isSupported = _hasProperty(request, "keepalive");
             }
-        });
-        return instFuncs;
+        }
+        catch (e) {
+        }
+        return isSupported;
     }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
+    function useXDomainRequest() {
+        if (_useXDomainRequest === null) {
+            _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
+            if (_useXDomainRequest && isXhrSupported()) {
+                _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
             }
         }
-        return false;
+        return _useXDomainRequest;
     }
-    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);
-            };
+    function isXhrSupported() {
+        var isSupported = false;
+        try {
+            var xmlHttpRequest = getInst(strXMLHttpRequest);
+            isSupported = !!xmlHttpRequest;
         }
-        var baseFuncs = {};
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
-        });
-        var baseProto = _getObjProto(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+        catch (e) {
+        }
+        return isSupported;
+    }
+    function _getNamedValue(values, name) {
+        if (values) {
+            for (var i = 0; i < values[_DYN_LENGTH ]; i++) {
+                var value = values[i];
+                if (value[_DYN_NAME ]) {
+                    if (value[_DYN_NAME ] === name) {
+                        return value;
+                    }
                 }
-            });
-            visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
+            }
         }
-        return baseFuncs;
+        return {};
     }
-    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-        var instFunc = null;
-        if (target && _hasOwnProperty(proto, DynClassName)) {
-            var instFuncTable = target[DynInstFuncTable] || {};
-            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
-            if (!instFunc) {
-                _throwTypeError("Missing [" + funcName + "] " + strFunction);
-            }
-            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-                var canAddInst = !_hasOwnProperty(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;
-                }
-            }
+    function findMetaTag(name) {
+        var doc = getDocument();
+        if (doc && name) {
+            return _getNamedValue(doc.querySelectorAll("meta"), name).content;
         }
-        return instFunc;
+        return null;
     }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
+    function findNamedServerTiming(name) {
+        var value;
+        var perf = getPerformance();
+        if (perf) {
+            var navPerf = perf.getEntriesByType("navigation") || [];
+            value = _getNamedValue((navPerf[_DYN_LENGTH ] > 0 ? navPerf[0] : {}).serverTiming, name).description;
         }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        return value;
+    }
+
+    var AiNonUserActionablePrefix = "AI (Internal): ";
+    var AiUserActionablePrefix = "AI: ";
+    var AIInternalMessagePrefix = "AITR_";
+    function _sanitizeDiagnosticText(text) {
+        if (text) {
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
         }
-        return protoFunc;
+        return STR_EMPTY;
     }
-    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;
+    function _logToConsole(func, message) {
+        var theConsole = getConsole();
+        if (!!theConsole) {
+            var logFunc = "log";
+            if (theConsole[func]) {
+                logFunc = func;
+            }
+            if (isFunction(theConsole[logFunc])) {
+                theConsole[logFunc](message);
+            }
         }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+    }
+    var _InternalLogMessage = /** @class */ (function () {
+        function _InternalLogMessage(msgId, msg, isUserAct, properties) {
+            if (isUserAct === void 0) { isUserAct = false; }
+            var _self = this;
+            _self[_DYN_MESSAGE_ID ] = msgId;
+            _self[_DYN_MESSAGE ] =
+                (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
+                    msgId;
+            var strProps = STR_EMPTY;
+            if (hasJSON()) {
+                strProps = getJSON().stringify(properties);
             }
-            _forEachProp(target, function (name) {
-                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                    instFuncs_1[name] = target[name];
-                    delete target[name];
-                    if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                        proto[name] = _createDynamicPrototype(proto, name);
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            _self[_DYN_MESSAGE ] += diagnosticText;
+        }
+        _InternalLogMessage.dataType = "MessageData";
+        return _InternalLogMessage;
+    }());
+    function safeGetLogger(core, config) {
+        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
+    }
+    var DiagnosticLogger = /** @class */ (function () {
+        function DiagnosticLogger(config) {
+            this.identifier = "DiagnosticLogger";
+            this.queue = [];
+            var _messageCount = 0;
+            var _messageLogged = {};
+            var _loggingLevelConsole;
+            var _loggingLevelTelemetry;
+            var _maxInternalMessageLimit;
+            var _enableDebugExceptions;
+            dynamicProto(DiagnosticLogger, this, function (_self) {
+                _setDefaultsFromConfig(config || {});
+                _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
+                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
+                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
+                _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
+                    if (isUserAct === void 0) { isUserAct = false; }
+                    var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
+                    if (_enableDebugExceptions) {
+                        throw dumpObj(message);
+                    }
+                    else {
+                        var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
+                        if (!isUndefined(message[_DYN_MESSAGE ])) {
+                            if (isUserAct) {
+                                var messageKey = +message[_DYN_MESSAGE_ID ];
+                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
+                                    _messageLogged[messageKey] = true;
+                                }
+                            }
+                            else {
+                                if (_loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
+                                }
+                            }
+                            _logInternalMessage(severity, message);
+                        }
+                        else {
+                            _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
+                        }
+                    }
+                };
+                _self[STR_WARN_TO_CONSOLE ] = function (message) {
+                    _logToConsole("warn", message);
+                    _debugExtMsg("warning", message);
+                };
+                _self[STR_ERROR_TO_CONSOLE ] = function (message) {
+                    _logToConsole("error", message);
+                    _debugExtMsg("error", message);
+                };
+                _self.resetInternalMessageCount = function () {
+                    _messageCount = 0;
+                    _messageLogged = {};
+                };
+                _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+                function _logInternalMessage(severity, message) {
+                    if (_areInternalMessagesThrottled()) {
+                        return;
+                    }
+                    var logMessage = true;
+                    var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
+                    if (_messageLogged[messageKey]) {
+                        logMessage = false;
+                    }
+                    else {
+                        _messageLogged[messageKey] = true;
+                    }
+                    if (logMessage) {
+                        if (severity <= _loggingLevelTelemetry) {
+                            _self.queue[_DYN_PUSH ](message);
+                            _messageCount++;
+                            _debugExtMsg((severity === 1  ? "error" : "warn"), message);
+                        }
+                        if (_messageCount === _maxInternalMessageLimit) {
+                            var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
+                            var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
+                            _self.queue[_DYN_PUSH ](throttleMessage);
+                            if (severity === 1 ) {
+                                _self[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
+                            }
+                            else {
+                                _self[STR_WARN_TO_CONSOLE ](throttleLimitMessage);
+                            }
+                        }
+                    }
+                }
+                function _setDefaultsFromConfig(config) {
+                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
+                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
+                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
+                    _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
+                }
+                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 _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 _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
+        if (isUserAct === void 0) { isUserAct = false; }
+        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
     }
-    function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
-        }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+    function _warnToConsole(logger, message) {
+        _getLogger(logger)[STR_WARN_TO_CONSOLE ](message);
     }
-    function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!_hasOwnProperty(theClass, Prototype)) {
-            _throwTypeError("theClass is an invalid class definition.");
-        }
-        var classProto = theClass[Prototype];
-        if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
-        }
-        var className = null;
-        if (_hasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
-        }
-        else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _dynamicNames;
-            _dynamicNames++;
-            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);
+    function _logInternalMessage(logger, severity, message) {
+        _getLogger(logger)[_DYN_LOG_INTERNAL_MESSAGE ](severity, message);
     }
-    var perfDefaults = {
-        setInstFuncs: true,
-        useBaseInst: true
-    };
-    dynamicProto[DynProtoDefaultOptions] = perfDefaults;
 
-    var strWindow = "window";
-    var strDocument = "document";
-    var strDocumentMode = "documentMode";
-    var strNavigator = "navigator";
-    var strHistory = "history";
-    var strLocation = "location";
-    var strConsole = "console";
-    var strPerformance = "performance";
-    var strJSON = "JSON";
-    var strCrypto = "crypto";
-    var strMsCrypto = "msCrypto";
-    var strReactNative = "ReactNative";
-    var strMsie = "msie";
-    var strTrident = "trident/";
-    var strXMLHttpRequest = "XMLHttpRequest";
-    var _isTrident = null;
-    var _navUserAgentCheck = null;
-    var _enableMocks = false;
-    var _useXDomainRequest = null;
-    var _beaconsSupported = null;
-    function _hasProperty(theClass, property) {
-        var supported = false;
-        if (theClass) {
-            try {
-                supported = property in theClass;
-                if (!supported) {
-                    var proto = theClass[strShimPrototype];
-                    if (proto) {
-                        supported = property in proto;
+    var strExecutionContextKey = "ctx";
+    var strParentContextKey = "ParentContextKey";
+    var strChildrenContextKey = "ChildrenContextKey";
+    var _defaultPerfManager = null;
+    var PerfEvent = /** @class */ (function () {
+        function PerfEvent(name, payloadDetails, isAsync) {
+            var _self = this;
+            _self.start = dateNow();
+            _self[_DYN_NAME ] = name;
+            _self[_DYN_IS_ASYNC ] = isAsync;
+            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
+            if (isFunction(payloadDetails)) {
+                var theDetails_1;
+                objDefineAccessors(_self, "payload", function () {
+                    if (!theDetails_1 && isFunction(payloadDetails)) {
+                        theDetails_1 = payloadDetails();
+                        payloadDetails = null;
                     }
-                }
+                    return theDetails_1;
+                });
             }
-            catch (e) {
+            _self[_DYN_GET_CTX ] = function (key) {
+                if (key) {
+                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
+                        return _self[key];
+                    }
+                    return (_self[strExecutionContextKey] || {})[key];
+                }
+                return null;
+            };
+            _self[_DYN_SET_CTX ] = function (key, value) {
+                if (key) {
+                    if (key === PerfEvent[strParentContextKey]) {
+                        if (!_self[key]) {
+                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
+                        }
+                        _self[key] = value;
+                    }
+                    else if (key === PerfEvent[strChildrenContextKey]) {
+                        _self[key] = value;
+                    }
+                    else {
+                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                        ctx[key] = value;
+                    }
+                }
+            };
+            _self[_DYN_COMPLETE ] = function () {
+                var childTime = 0;
+                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
+                if (isArray(childEvts)) {
+                    for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
+                        var childEvt = childEvts[lp];
+                        if (childEvt) {
+                            childTime += childEvt[_DYN_TIME ];
+                        }
+                    }
+                }
+                _self[_DYN_TIME ] = dateNow() - _self.start;
+                _self.exTime = _self[_DYN_TIME ] - childTime;
+                _self[_DYN_COMPLETE ] = function () { };
+            };
+        }
+        PerfEvent.ParentContextKey = "parent";
+        PerfEvent.ChildrenContextKey = "childEvts";
+        return PerfEvent;
+    }());
+    var PerfManager = /** @class */ (function () {
+        function PerfManager(manager) {
+            this.ctx = {};
+            dynamicProto(PerfManager, this, function (_self) {
+                _self.create = function (src, payloadDetails, isAsync) {
+                    return new PerfEvent(src, payloadDetails, isAsync);
+                };
+                _self.fire = function (perfEvent) {
+                    if (perfEvent) {
+                        perfEvent[_DYN_COMPLETE ]();
+                        if (manager && isFunction(manager[STR_PERF_EVENT ])) {
+                            manager[STR_PERF_EVENT ](perfEvent);
+                        }
+                    }
+                };
+                _self[_DYN_SET_CTX ] = function (key, value) {
+                    if (key) {
+                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
+                        ctx[key] = value;
+                    }
+                };
+                _self[_DYN_GET_CTX ] = function (key) {
+                    return (_self[strExecutionContextKey] || {})[key];
+                };
+            });
+        }
+        PerfManager.__ieDyn=1;
+        return PerfManager;
+    }());
+    var doPerfActiveKey = "CoreUtils.doPerf";
+    function doPerf(mgrSource, getSource, func, details, isAsync) {
+        if (mgrSource) {
+            var perfMgr = mgrSource;
+            if (perfMgr[STR_GET_PERF_MGR]) {
+                perfMgr = perfMgr[STR_GET_PERF_MGR]();
             }
-            if (!supported) {
+            if (perfMgr) {
+                var perfEvt = void 0;
+                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
                 try {
-                    var tmp = new theClass();
-                    supported = !isUndefined(tmp[property]);
+                    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 (e) {
+                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 supported;
-    }
-    function setEnableEnvMocks(enabled) {
-        _enableMocks = enabled;
+        return func();
     }
-    function getGlobalInst(name) {
-        var gbl = getGlobal();
-        if (gbl && gbl[name]) {
-            return gbl[name];
-        }
-        if (name === strWindow && hasWindow()) {
-            return window;
-        }
-        return null;
+    function setGblPerfMgr(perfManager) {
+        _defaultPerfManager = perfManager;
     }
-    function hasWindow() {
-        return Boolean(typeof window === strShimObject && window);
+    function getGblPerfMgr() {
+        return _defaultPerfManager;
     }
-    function getWindow() {
-        if (hasWindow()) {
-            return window;
+
+    var UInt32Mask = 0x100000000;
+    var MaxUInt32 = 0xffffffff;
+    var _mwcSeeded = false;
+    var _mwcW = 123456789;
+    var _mwcZ = 987654321;
+    function _mwcSeed(seedValue) {
+        if (seedValue < 0) {
+            seedValue >>>= 0;
         }
-        return getGlobalInst(strWindow);
-    }
-    function hasDocument() {
-        return Boolean(typeof document === strShimObject && document);
+        _mwcW = (123456789 + seedValue) & MaxUInt32;
+        _mwcZ = (987654321 - seedValue) & MaxUInt32;
+        _mwcSeeded = true;
     }
-    function getDocument() {
-        if (hasDocument()) {
-            return document;
+    function _autoSeedMwc() {
+        try {
+            var now = dateNow() & 0x7fffffff;
+            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
         }
-        return getGlobalInst(strDocument);
-    }
-    function hasNavigator() {
-        return Boolean(typeof navigator === strShimObject && navigator);
-    }
-    function getNavigator() {
-        if (hasNavigator()) {
-            return navigator;
+        catch (e) {
         }
-        return getGlobalInst(strNavigator);
-    }
-    function hasHistory() {
-        return Boolean(typeof history === strShimObject && history);
     }
-    function getHistory() {
-        if (hasHistory()) {
-            return history;
+    function randomValue(maxValue) {
+        if (maxValue > 0) {
+            return Math.floor((random32() / MaxUInt32) * (maxValue + 1)) >>> 0;
         }
-        return getGlobalInst(strHistory);
+        return 0;
     }
-    function getLocation(checkForMock) {
-        if (checkForMock && _enableMocks) {
-            var mockLocation = getGlobalInst("__mockLocation");
-            if (mockLocation) {
-                return mockLocation;
+    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 (typeof location === strShimObject && location) {
-            return location;
+        if (value === 0) {
+            value = Math.floor((UInt32Mask * Math.random()) | 0);
         }
-        return getGlobalInst(strLocation);
-    }
-    function getConsole() {
-        if (typeof console !== strShimUndefined) {
-            return console;
+        if (!signed) {
+            value >>>= 0;
         }
-        return getGlobalInst(strConsole);
-    }
-    function getPerformance() {
-        return getGlobalInst(strPerformance);
-    }
-    function hasJSON() {
-        return Boolean((typeof JSON === strShimObject && JSON) || getGlobalInst(strJSON) !== null);
+        return value;
     }
-    function getJSON() {
-        if (hasJSON()) {
-            return JSON || getGlobalInst(strJSON);
+    function mwcRandomSeed(value) {
+        if (!value) {
+            _autoSeedMwc();
         }
-        return null;
-    }
-    function getCrypto() {
-        return getGlobalInst(strCrypto);
-    }
-    function getMsCrypto() {
-        return getGlobalInst(strMsCrypto);
-    }
-    function isReactNative() {
-        var nav = getNavigator();
-        if (nav && nav.product) {
-            return nav.product === strReactNative;
+        else {
+            _mwcSeed(value);
         }
-        return false;
     }
-    function isIE() {
-        var nav = getNavigator();
-        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
-            _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    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 _isTrident;
+        return value;
     }
-    function getIEVersion(userAgentStr) {
-        if (userAgentStr === void 0) { userAgentStr = null; }
-        if (!userAgentStr) {
-            var navigator_1 = getNavigator() || {};
-            userAgentStr = navigator_1 ? (navigator_1[_DYN_USER_AGENT ] || STR_EMPTY)[_DYN_TO_LOWER_CASE ]() : STR_EMPTY;
-        }
-        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
-        if (strContains(ua, strMsie)) {
-            var doc = getDocument() || {};
-            return Math.max(parseInt(ua[_DYN_SPLIT ](strMsie)[1]), (doc[strDocumentMode] || 0));
-        }
-        else if (strContains(ua, strTrident)) {
-            var tridentVer = parseInt(ua[_DYN_SPLIT ](strTrident)[1]);
-            if (tridentVer) {
-                return tridentVer + 4;
+    function newId(maxLength) {
+        if (maxLength === void 0) { maxLength = 22; }
+        var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var number = random32() >>> 0;
+        var chars = 0;
+        var result = STR_EMPTY;
+        while (result[_DYN_LENGTH ] < maxLength) {
+            chars++;
+            result += base64chars.charAt(number & 0x3F);
+            number >>>= 6;
+            if (chars === 5) {
+                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+                chars = 0;
             }
         }
-        return null;
-    }
-    function dumpObj(object) {
-        var objectTypeDump = Object[strShimPrototype].toString[_DYN_CALL ](object);
-        var propertyValueDump = STR_EMPTY;
-        if (objectTypeDump === "[object Error]") {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object[_DYN_NAME ] + "'";
-        }
-        else if (hasJSON()) {
-            propertyValueDump = getJSON().stringify(object);
-        }
-        return objectTypeDump + propertyValueDump;
-    }
-    function isSafari(userAgentStr) {
-        if (!userAgentStr || !isString(userAgentStr)) {
-            var navigator_2 = getNavigator() || {};
-            userAgentStr = navigator_2 ? (navigator_2[_DYN_USER_AGENT ] || STR_EMPTY)[_DYN_TO_LOWER_CASE ]() : STR_EMPTY;
-        }
-        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
-        return (ua[_DYN_INDEX_OF ]("safari") >= 0);
-    }
-    function isBeaconsSupported() {
-        if (_beaconsSupported === null) {
-            _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
-        }
-        return _beaconsSupported;
+        return result;
     }
-    function isFetchSupported(withKeepAlive) {
-        var isSupported = false;
-        try {
-            isSupported = !!getGlobalInst("fetch");
-            var request = getGlobalInst("Request");
-            if (isSupported && withKeepAlive && request) {
-                isSupported = _hasProperty(request, "keepalive");
+
+    var _objDefineProperty = ObjDefineProperty;
+    var version = "3.0.0-beta.2208-16";
+    var instanceName = "." + newId(6);
+    var _dataUid = 0;
+    function _createAccessor(target, prop, value) {
+        if (_objDefineProperty) {
+            try {
+                _objDefineProperty(target, prop, {
+                    value: value,
+                    enumerable: false,
+                    configurable: true
+                });
+                return true;
             }
-        }
-        catch (e) {
-        }
-        return isSupported;
-    }
-    function useXDomainRequest() {
-        if (_useXDomainRequest === null) {
-            _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
-            if (_useXDomainRequest && isXhrSupported()) {
-                _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst(strXMLHttpRequest), "withCredentials");
+            catch (e) {
             }
         }
-        return _useXDomainRequest;
+        return false;
     }
-    function isXhrSupported() {
-        var isSupported = false;
-        try {
-            var xmlHttpRequest = getGlobalInst(strXMLHttpRequest);
-            isSupported = !!xmlHttpRequest;
-        }
-        catch (e) {
-        }
-        return isSupported;
+    function _canAcceptData(target) {
+        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
     }
-    function _getNamedValue(values, name) {
-        if (values) {
-            for (var i = 0; i < values[_DYN_LENGTH ]; i++) {
-                var value = values[i];
-                if (value[_DYN_NAME ]) {
-                    if (value[_DYN_NAME ] === name) {
-                        return value;
+    function _getCache(data, target) {
+        var theCache = target[data.id];
+        if (!theCache) {
+            theCache = {};
+            try {
+                if (_canAcceptData(target)) {
+                    if (!_createAccessor(target, data.id, theCache)) {
+                        target[data.id] = theCache;
                     }
                 }
             }
+            catch (e) {
+            }
         }
-        return {};
-    }
-    function findMetaTag(name) {
-        var doc = getDocument();
-        if (doc && name) {
-            return _getNamedValue(doc.querySelectorAll("meta"), name).content;
-        }
-        return null;
+        return theCache;
     }
-    function findNamedServerTiming(name) {
-        var value;
-        var perf = getPerformance();
-        if (perf) {
-            var navPerf = perf.getEntriesByType("navigation") || [];
-            value = _getNamedValue((navPerf[_DYN_LENGTH ] > 0 ? navPerf[0] : {}).serverTiming, name).description;
-        }
-        return value;
+    function createUniqueNamespace(name, includeVersion) {
+        if (includeVersion === void 0) { includeVersion = false; }
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
     }
-
-    var listenerFuncs = ["eventsSent", "eventsDiscarded", "eventsSendRequest", "perfEvent"];
-    var _aiNamespace = null;
-    var _debugListener;
-    function _listenerProxyFunc(name, config) {
-        return function () {
-            var args = arguments;
-            var dbgExt = getDebugExt(config);
-            if (dbgExt) {
-                var listener = dbgExt.listener;
-                if (listener && listener[name]) {
-                    listener[name][_DYN_APPLY ](listener, args);
+    function createElmNodeData(name) {
+        var data = {
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+            accept: function (target) {
+                return _canAcceptData(target);
+            },
+            get: function (target, name, defValue, addDefault) {
+                var theCache = target[data.id];
+                if (!theCache) {
+                    if (addDefault) {
+                        theCache = _getCache(data, target);
+                        theCache[normalizeJsName(name)] = defValue;
+                    }
+                    return defValue;
+                }
+                return theCache[normalizeJsName(name)];
+            },
+            kill: function (target, name) {
+                if (target && target[name]) {
+                    try {
+                        delete target[name];
+                    }
+                    catch (e) {
+                    }
                 }
             }
         };
+        return data;
     }
-    function _getExtensionNamespace() {
-        var target = getGlobalInst("Microsoft");
-        if (target) {
-            _aiNamespace = target["ApplicationInsights"];
-        }
-        return _aiNamespace;
+
+    var Undefined = strShimUndefined;
+    function newGuid() {
+        var uuid = generateW3CId();
+        return uuid[_DYN_SUBSTRING ](0, 8) + "-" + uuid[_DYN_SUBSTRING ](8, 12) + "-" + uuid[_DYN_SUBSTRING ](12, 16) + "-" + uuid[_DYN_SUBSTRING ](16, 20) + "-" + uuid[_DYN_SUBSTRING ](20);
     }
-    function getDebugExt(config) {
-        var ns = _aiNamespace;
-        if (!ns && config.disableDbgExt !== true) {
-            ns = _aiNamespace || _getExtensionNamespace();
+    function perfNow() {
+        var perf = getPerformance();
+        if (perf && perf.now) {
+            return perf.now();
         }
-        return ns ? ns["ChromeDbgExt"] : null;
+        return dateNow();
     }
-    function getDebugListener(config) {
-        if (!_debugListener) {
-            _debugListener = {};
-            for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH ]; lp++) {
-                _debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);
-            }
+    function generateW3CId() {
+        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+        var oct = STR_EMPTY, 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];
         }
-        return _debugListener;
+        var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
+        return oct[_DYN_SUBSTR ](0, 8) + oct[_DYN_SUBSTR ](9, 4) + "4" + oct[_DYN_SUBSTR ](13, 3) + clockSequenceHi + oct[_DYN_SUBSTR ](16, 3) + oct[_DYN_SUBSTR ](19, 12);
     }
 
-    var AiNonUserActionablePrefix = "AI (Internal): ";
-    var AiUserActionablePrefix = "AI: ";
-    var AIInternalMessagePrefix = "AITR_";
-    function _sanitizeDiagnosticText(text) {
-        if (text) {
-            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
+    var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]*)?$/;
+    var DEFAULT_VERSION = "00";
+    var INVALID_VERSION = "ff";
+    var INVALID_TRACE_ID = "00000000000000000000000000000000";
+    var INVALID_SPAN_ID = "0000000000000000";
+    var SAMPLED_FLAG = 0x01;
+    function _isValid(value, len, invalidValue) {
+        if (value && value[_DYN_LENGTH ] === len && value !== invalidValue) {
+            return !!value.match(/^[\da-f]*$/);
         }
-        return STR_EMPTY;
-    }
-    function _logToConsole(func, message) {
-        var theConsole = getConsole();
-        if (!!theConsole) {
-            var logFunc = "log";
-            if (theConsole[func]) {
-                logFunc = func;
-            }
-            if (isFunction(theConsole[logFunc])) {
-                theConsole[logFunc](message);
-            }
-        }
-    }
-    var _InternalLogMessage = /** @class */ (function () {
-        function _InternalLogMessage(msgId, msg, isUserAct, properties) {
-            if (isUserAct === void 0) { isUserAct = false; }
-            var _self = this;
-            _self[_DYN_MESSAGE_ID ] = msgId;
-            _self[_DYN_MESSAGE ] =
-                (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
-                    msgId;
-            var strProps = STR_EMPTY;
-            if (hasJSON()) {
-                strProps = getJSON().stringify(properties);
-            }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
-            _self[_DYN_MESSAGE ] += diagnosticText;
-        }
-        _InternalLogMessage.dataType = "MessageData";
-        return _InternalLogMessage;
-    }());
-    function safeGetLogger(core, config) {
-        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
-    }
-    var DiagnosticLogger = /** @class */ (function () {
-        function DiagnosticLogger(config) {
-            this.identifier = "DiagnosticLogger";
-            this.queue = [];
-            var _messageCount = 0;
-            var _messageLogged = {};
-            var _loggingLevelConsole;
-            var _loggingLevelTelemetry;
-            var _maxInternalMessageLimit;
-            var _enableDebugExceptions;
-            dynamicProto(DiagnosticLogger, this, function (_self) {
-                _setDefaultsFromConfig(config || {});
-                _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
-                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
-                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
-                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
-                _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
-                    if (isUserAct === void 0) { isUserAct = false; }
-                    var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                    if (_enableDebugExceptions) {
-                        throw dumpObj(message);
-                    }
-                    else {
-                        var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
-                        if (!isUndefined(message[_DYN_MESSAGE ])) {
-                            if (isUserAct) {
-                                var messageKey = +message[_DYN_MESSAGE_ID ];
-                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE ]);
-                                    _messageLogged[messageKey] = true;
-                                }
-                            }
-                            else {
-                                if (_loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE ]);
-                                }
-                            }
-                            _logInternalMessage(severity, message);
-                        }
-                        else {
-                            _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
-                        }
-                    }
-                };
-                _self[STR_WARN_TO_CONSOLE ] = function (message) {
-                    _logToConsole("warn", message);
-                    _debugExtMsg("warning", message);
-                };
-                _self[STR_ERROR_TO_CONSOLE ] = function (message) {
-                    _logToConsole("error", message);
-                    _debugExtMsg("error", message);
-                };
-                _self.resetInternalMessageCount = function () {
-                    _messageCount = 0;
-                    _messageLogged = {};
-                };
-                _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
-                function _logInternalMessage(severity, message) {
-                    if (_areInternalMessagesThrottled()) {
-                        return;
-                    }
-                    var logMessage = true;
-                    var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
-                    if (_messageLogged[messageKey]) {
-                        logMessage = false;
-                    }
-                    else {
-                        _messageLogged[messageKey] = true;
-                    }
-                    if (logMessage) {
-                        if (severity <= _loggingLevelTelemetry) {
-                            _self.queue[_DYN_PUSH ](message);
-                            _messageCount++;
-                            _debugExtMsg((severity === 1  ? "error" : "warn"), message);
-                        }
-                        if (_messageCount === _maxInternalMessageLimit) {
-                            var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                            var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                            _self.queue[_DYN_PUSH ](throttleMessage);
-                            if (severity === 1 ) {
-                                _self[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
-                            }
-                            else {
-                                _self[STR_WARN_TO_CONSOLE ](throttleLimitMessage);
-                            }
-                        }
-                    }
-                }
-                function _setDefaultsFromConfig(config) {
-                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
-                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
-                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
-                    _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
-                }
-                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).throwInternal(severity, msgId, msg, properties, isUserAct);
-    }
-    function _warnToConsole(logger, message) {
-        _getLogger(logger)[STR_WARN_TO_CONSOLE ](message);
-    }
-    function _logInternalMessage(logger, severity, message) {
-        _getLogger(logger)[_DYN_LOG_INTERNAL_MESSAGE ](severity, message);
-    }
-
-    var strExecutionContextKey = "ctx";
-    var strParentContextKey = "ParentContextKey";
-    var strChildrenContextKey = "ChildrenContextKey";
-    var _defaultPerfManager = null;
-    var PerfEvent = /** @class */ (function () {
-        function PerfEvent(name, payloadDetails, isAsync) {
-            var _self = this;
-            var accessorDefined = false;
-            _self.start = dateNow();
-            _self[_DYN_NAME ] = name;
-            _self[_DYN_IS_ASYNC ] = isAsync;
-            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
-            if (isFunction(payloadDetails)) {
-                var theDetails_1;
-                accessorDefined = objDefineAccessors(_self, "payload", function () {
-                    if (!theDetails_1 && isFunction(payloadDetails)) {
-                        theDetails_1 = payloadDetails();
-                        payloadDetails = null;
-                    }
-                    return theDetails_1;
-                });
-            }
-            _self[_DYN_GET_CTX ] = function (key) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
-                        return _self[key];
-                    }
-                    return (_self[strExecutionContextKey] || {})[key];
-                }
-                return null;
-            };
-            _self[_DYN_SET_CTX ] = function (key, value) {
-                if (key) {
-                    if (key === PerfEvent[strParentContextKey]) {
-                        if (!_self[key]) {
-                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
-                        }
-                        _self[key] = value;
-                    }
-                    else if (key === PerfEvent[strChildrenContextKey]) {
-                        _self[key] = value;
-                    }
-                    else {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
-                }
-            };
-            _self[_DYN_COMPLETE ] = function () {
-                var childTime = 0;
-                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                if (isArray(childEvts)) {
-                    for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
-                        var childEvt = childEvts[lp];
-                        if (childEvt) {
-                            childTime += childEvt[_DYN_TIME ];
-                        }
-                    }
-                }
-                _self[_DYN_TIME ] = dateNow() - _self.start;
-                _self.exTime = _self[_DYN_TIME ] - childTime;
-                _self[_DYN_COMPLETE ] = function () { };
-                if (!accessorDefined && isFunction(payloadDetails)) {
-                    _self.payload = payloadDetails();
-                }
-            };
-        }
-        PerfEvent.ParentContextKey = "parent";
-        PerfEvent.ChildrenContextKey = "childEvts";
-        return PerfEvent;
-    }());
-    var PerfManager = /** @class */ (function () {
-        function PerfManager(manager) {
-            this.ctx = {};
-            dynamicProto(PerfManager, this, function (_self) {
-                _self.create = function (src, payloadDetails, isAsync) {
-                    return new PerfEvent(src, payloadDetails, isAsync);
-                };
-                _self.fire = function (perfEvent) {
-                    if (perfEvent) {
-                        perfEvent[_DYN_COMPLETE ]();
-                        if (manager && isFunction(manager[STR_PERF_EVENT ])) {
-                            manager[STR_PERF_EVENT ](perfEvent);
-                        }
-                    }
-                };
-                _self[_DYN_SET_CTX ] = function (key, value) {
-                    if (key) {
-                        var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
-                        ctx[key] = value;
-                    }
-                };
-                _self[_DYN_GET_CTX ] = function (key) {
-                    return (_self[strExecutionContextKey] || {})[key];
-                };
-            });
-        }
-        PerfManager.__ieDyn=1;
-        return PerfManager;
-    }());
-    var doPerfActiveKey = "CoreUtils.doPerf";
-    function doPerf(mgrSource, getSource, func, details, isAsync) {
-        if (mgrSource) {
-            var perfMgr = mgrSource;
-            if (perfMgr[STR_GET_PERF_MGR]) {
-                perfMgr = perfMgr[STR_GET_PERF_MGR]();
-            }
-            if (perfMgr) {
-                var perfEvt = void 0;
-                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
-                try {
-                    perfEvt = perfMgr.create(getSource(), details, isAsync);
-                    if (perfEvt) {
-                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
-                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
-                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
-                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
-                                if (!children) {
-                                    children = [];
-                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
-                                }
-                                children[_DYN_PUSH ](perfEvt);
-                            }
-                        }
-                        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 setGblPerfMgr(perfManager) {
-        _defaultPerfManager = perfManager;
-    }
-    function getGblPerfMgr() {
-        return _defaultPerfManager;
-    }
-
-    var UInt32Mask = 0x100000000;
-    var MaxUInt32 = 0xffffffff;
-    var _mwcSeeded = false;
-    var _mwcW = 123456789;
-    var _mwcZ = 987654321;
-    function _mwcSeed(seedValue) {
-        if (seedValue < 0) {
-            seedValue >>>= 0;
-        }
-        _mwcW = (123456789 + seedValue) & MaxUInt32;
-        _mwcZ = (987654321 - seedValue) & MaxUInt32;
-        _mwcSeeded = true;
-    }
-    function _autoSeedMwc() {
-        try {
-            var now = dateNow() & 0x7fffffff;
-            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
-        }
-        catch (e) {
-        }
-    }
-    function randomValue(maxValue) {
-        if (maxValue > 0) {
-            return Math.floor((random32() / MaxUInt32) * (maxValue + 1)) >>> 0;
-        }
-        return 0;
-    }
-    function random32(signed) {
-        var value = 0;
-        var c = getCrypto() || getMsCrypto();
-        if (c && c.getRandomValues) {
-            value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
-        }
-        if (value === 0 && isIE()) {
-            if (!_mwcSeeded) {
-                _autoSeedMwc();
-            }
-            value = mwcRandom32() & MaxUInt32;
-        }
-        if (value === 0) {
-            value = Math.floor((UInt32Mask * Math.random()) | 0);
-        }
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function mwcRandomSeed(value) {
-        if (!value) {
-            _autoSeedMwc();
-        }
-        else {
-            _mwcSeed(value);
-        }
-    }
-    function mwcRandom32(signed) {
-        _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
-        _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
-        var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
-        if (!signed) {
-            value >>>= 0;
-        }
-        return value;
-    }
-    function newId(maxLength) {
-        if (maxLength === void 0) { maxLength = 22; }
-        var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        var number = random32() >>> 0;
-        var chars = 0;
-        var result = STR_EMPTY;
-        while (result[_DYN_LENGTH ] < maxLength) {
-            chars++;
-            result += base64chars.charAt(number & 0x3F);
-            number >>>= 6;
-            if (chars === 5) {
-                number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-                chars = 0;
-            }
-        }
-        return result;
-    }
-
-    var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2208-03";
-    var instanceName = "." + newId(6);
-    var _dataUid = 0;
-    function _createAccessor(target, prop, value) {
-        if (_objDefineProperty) {
-            try {
-                _objDefineProperty(target, prop, {
-                    value: value,
-                    enumerable: false,
-                    configurable: true
-                });
-                return true;
-            }
-            catch (e) {
-            }
-        }
-        return false;
-    }
-    function _canAcceptData(target) {
-        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
-    }
-    function _getCache(data, target) {
-        var theCache = target[data.id];
-        if (!theCache) {
-            theCache = {};
-            try {
-                if (_canAcceptData(target)) {
-                    if (!_createAccessor(target, data.id, theCache)) {
-                        target[data.id] = theCache;
-                    }
-                }
-            }
-            catch (e) {
-            }
-        }
-        return theCache;
-    }
-    function createUniqueNamespace(name, includeVersion) {
-        if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
-    }
-    function createElmNodeData(name) {
-        var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
-            accept: function (target) {
-                return _canAcceptData(target);
-            },
-            get: function (target, name, defValue, addDefault) {
-                var theCache = target[data.id];
-                if (!theCache) {
-                    if (addDefault) {
-                        theCache = _getCache(data, target);
-                        theCache[normalizeJsName(name)] = defValue;
-                    }
-                    return defValue;
-                }
-                return theCache[normalizeJsName(name)];
-            },
-            kill: function (target, name) {
-                if (target && target[name]) {
-                    try {
-                        delete target[name];
-                    }
-                    catch (e) {
-                    }
-                }
-            }
-        };
-        return data;
-    }
-
-    var strToGMTString = "toGMTString";
-    var strToUTCString = "toUTCString";
-    var strCookie = "cookie";
-    var strExpires = "expires";
-    var strEnabled = "enabled";
-    var strIsCookieUseDisabled = "isCookieUseDisabled";
-    var strDisableCookiesUsage = "disableCookiesUsage";
-    var strConfigCookieMgr = "_ckMgr";
-    var _supportsCookies = null;
-    var _allowUaSameSite = null;
-    var _parsedCookieValue = null;
-    var _doc = getDocument();
-    var _cookieCache = {};
-    var _globalCookieConfig = {};
-    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 _createCookieMgrConfig(rootConfig) {
-        var cookieMgrCfg = rootConfig[_DYN_COOKIE_CFG ] = rootConfig[_DYN_COOKIE_CFG ] || {};
-        setValue(cookieMgrCfg, "domain", rootConfig.cookieDomain, isNotNullOrUndefined, isNullOrUndefined);
-        setValue(cookieMgrCfg, "path", rootConfig.cookiePath || "/", null, isNullOrUndefined);
-        if (isNullOrUndefined(cookieMgrCfg[strEnabled])) {
-            var cookieEnabled = void 0;
-            if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
-                cookieEnabled = !rootConfig[strIsCookieUseDisabled];
-            }
-            if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
-                cookieEnabled = !rootConfig[strDisableCookiesUsage];
-            }
-            cookieMgrCfg[strEnabled] = cookieEnabled;
-        }
-        return cookieMgrCfg;
-    }
-    function safeGetCookieMgr(core, config) {
-        var cookieMgr;
-        if (core) {
-            cookieMgr = core.getCookieMgr();
-        }
-        else if (config) {
-            var cookieCfg = config[_DYN_COOKIE_CFG ];
-            if (cookieCfg[strConfigCookieMgr]) {
-                cookieMgr = cookieCfg[strConfigCookieMgr];
-            }
-            else {
-                cookieMgr = createCookieMgr(config);
-            }
-        }
-        if (!cookieMgr) {
-            cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER ]);
-        }
-        return cookieMgr;
-    }
-    function createCookieMgr(rootConfig, logger) {
-        var _a;
-        var cookieMgrConfig = _createCookieMgrConfig(rootConfig || _globalCookieConfig);
-        var _path = cookieMgrConfig.path || "/";
-        var _domain = cookieMgrConfig.domain;
-        var _enabled = cookieMgrConfig[strEnabled] !== false;
-        var cookieMgr = (_a = {
-                isEnabled: function () {
-                    var enabled = _enabled && areCookiesSupported(logger);
-                    var gblManager = _globalCookieConfig[strConfigCookieMgr];
-                    if (enabled && gblManager && cookieMgr !== gblManager) {
-                        enabled = _isMgrEnabled(gblManager);
-                    }
-                    return enabled;
-                }
-            },
-            _a[_DYN_SET_ENABLED ] = function (value) {
-                _enabled = value !== false;
-            },
-            _a.set = function (name, value, maxAgeSec, domain, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr)) {
-                    var values = {};
-                    var theValue = strTrim(value || STR_EMPTY);
-                    var idx = theValue[_DYN_INDEX_OF ](";");
-                    if (idx !== -1) {
-                        theValue = strTrim(value[_DYN_SUBSTRING ](0, idx));
-                        values = _extractParts(value[_DYN_SUBSTRING ](idx + 1));
-                    }
-                    setValue(values, "domain", domain || _domain, isTruthy, isUndefined);
-                    if (!isNullOrUndefined(maxAgeSec)) {
-                        var _isIE = isIE();
-                        if (isUndefined(values[strExpires])) {
-                            var nowMs = dateNow();
-                            var expireMs = nowMs + (maxAgeSec * 1000);
-                            if (expireMs > 0) {
-                                var expiry = new Date();
-                                expiry.setTime(expireMs);
-                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
-                            }
-                        }
-                        if (!_isIE) {
-                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
-                        }
-                    }
-                    var location_1 = getLocation();
-                    if (location_1 && location_1.protocol === "https:") {
-                        setValue(values, "secure", null, null, isUndefined);
-                        if (_allowUaSameSite === null) {
-                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
-                        }
-                        if (_allowUaSameSite) {
-                            setValue(values, "SameSite", "None", null, isUndefined);
-                        }
-                    }
-                    setValue(values, "path", path || _path, null, isUndefined);
-                    var setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
-                    setCookieFn(name, _formatCookieValue(theValue, values));
-                    result = true;
-                }
-                return result;
-            },
-            _a.get = function (name) {
-                var value = STR_EMPTY;
-                if (_isMgrEnabled(cookieMgr)) {
-                    value = (cookieMgrConfig.getCookie || _getCookieValue)(name);
-                }
-                return value;
-            },
-            _a.del = function (name, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr)) {
-                    result = cookieMgr.purge(name, path);
-                }
-                return result;
-            },
-            _a.purge = function (name, path) {
-                var _a;
-                var result = false;
-                if (areCookiesSupported(logger)) {
-                    var values = (_a = {},
-                        _a["path"] = path ? path : "/",
-                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
-                        _a);
-                    if (!isIE()) {
-                        values["max-age"] = "0";
-                    }
-                    var delCookie = cookieMgrConfig.delCookie || _setCookieValue;
-                    delCookie(name, _formatCookieValue(STR_EMPTY, values));
-                    result = true;
-                }
-                return result;
-            },
-            _a);
-        cookieMgr[strConfigCookieMgr] = cookieMgr;
-        return cookieMgr;
-    }
-    function areCookiesSupported(logger) {
-        if (_supportsCookies === null) {
-            _supportsCookies = false;
-            try {
-                var doc = _doc || {};
-                _supportsCookies = doc[strCookie] !== undefined;
-            }
-            catch (e) {
-                _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
-            }
-        }
-        return _supportsCookies;
-    }
-    function _extractParts(theValue) {
-        var values = {};
-        if (theValue && theValue[_DYN_LENGTH ]) {
-            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
-            arrForEach(parts, function (thePart) {
-                thePart = strTrim(thePart || STR_EMPTY);
-                if (thePart) {
-                    var idx = thePart[_DYN_INDEX_OF ]("=");
-                    if (idx === -1) {
-                        values[thePart] = null;
-                    }
-                    else {
-                        values[strTrim(thePart[_DYN_SUBSTRING ](0, idx))] = strTrim(thePart[_DYN_SUBSTRING ](idx + 1));
-                    }
-                }
-            });
-        }
-        return values;
-    }
-    function _formatDate(theDate, func) {
-        if (isFunction(theDate[func])) {
-            return theDate[func]();
-        }
-        return null;
-    }
-    function _formatCookieValue(value, values) {
-        var cookieValue = value || STR_EMPTY;
-        objForEachKey(values, function (name, theValue) {
-            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
-        });
-        return cookieValue;
-    }
-    function _getCookieValue(name) {
-        var cookieValue = STR_EMPTY;
-        if (_doc) {
-            var theCookie = _doc[strCookie] || STR_EMPTY;
-            if (_parsedCookieValue !== theCookie) {
-                _cookieCache = _extractParts(theCookie);
-                _parsedCookieValue = theCookie;
-            }
-            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
-        }
-        return cookieValue;
-    }
-    function _setCookieValue(name, cookieValue) {
-        if (_doc) {
-            _doc[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 strOnPrefix = "on";
-    var strAttachEvent = "attachEvent";
-    var strAddEventHelper = "addEventListener";
-    var strDetachEvent = "detachEvent";
-    var strRemoveEventListener = "removeEventListener";
-    var strEvents = "events";
-    var strVisibilityChangeEvt = "visibilitychange";
-    var strPageHide = "pagehide";
-    var strPageShow = "pageshow";
-    var strUnload = "unload";
-    var strBeforeUnload = "beforeunload";
-    var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
-    var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
-    var rRemoveEmptyNs = /\.[\.]+/g;
-    var rRemoveTrailingEmptyNs = /[\.]+$/;
-    var _guid = 1;
-    var elmNodeData = createElmNodeData("events");
-    var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
-    function _normalizeNamespace(name) {
-        if (name && name[_DYN_REPLACE ]) {
-            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
-        }
-        return name;
-    }
-    function _getEvtNamespace(eventName, evtNamespace) {
-        var _a;
-        if (evtNamespace) {
-            var theNamespace_1 = STR_EMPTY;
-            if (isArray(evtNamespace)) {
-                theNamespace_1 = STR_EMPTY;
-                arrForEach(evtNamespace, function (name) {
-                    name = _normalizeNamespace(name);
-                    if (name) {
-                        if (name[0] !== ".") {
-                            name = "." + name;
-                        }
-                        theNamespace_1 += name;
-                    }
-                });
-            }
-            else {
-                theNamespace_1 = _normalizeNamespace(evtNamespace);
-            }
-            if (theNamespace_1) {
-                if (theNamespace_1[0] !== ".") {
-                    theNamespace_1 = "." + theNamespace_1;
-                }
-                eventName = (eventName || STR_EMPTY) + theNamespace_1;
-            }
-        }
-        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
-        return _a = {},
-            _a[_DYN_TYPE ] = parsedEvent[1],
-            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT ](".").sort()).join("."),
-            _a;
-    }
-    function __getRegisteredEvents(target, eventName, evtNamespace) {
-        var theEvents = [];
-        var eventCache = elmNodeData.get(target, strEvents, {}, false);
-        var evtName = _getEvtNamespace(eventName, evtNamespace);
-        objForEachKey(eventCache, function (evtType, registeredEvents) {
-            arrForEach(registeredEvents, function (value) {
-                var _a;
-                if (!evtName[_DYN_TYPE ] || evtName[_DYN_TYPE ] === value.evtName[_DYN_TYPE ]) {
-                    if (!evtName.ns || evtName.ns === evtName.ns) {
-                        theEvents[_DYN_PUSH ]((_a = {},
-                            _a[_DYN_NAME ] = value.evtName[_DYN_TYPE ] + (value.evtName.ns ? "." + value.evtName.ns : STR_EMPTY),
-                            _a.handler = value[_DYN_HANDLER ],
-                            _a));
-                    }
-                }
-            });
-        });
-        return theEvents;
-    }
-    function _getRegisteredEvents(target, evtName, addDefault) {
-        if (addDefault === void 0) { addDefault = true; }
-        var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
-        var registeredEvents = aiEvts[evtName];
-        if (!registeredEvents) {
-            registeredEvents = aiEvts[evtName] = [];
-        }
-        return registeredEvents;
-    }
-    function _doDetach(obj, evtName, handlerRef, useCapture) {
-        if (obj && evtName && evtName[_DYN_TYPE ]) {
-            if (obj[strRemoveEventListener]) {
-                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
-            }
-            else if (obj[strDetachEvent]) {
-                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
-            }
-        }
-    }
-    function _doAttach(obj, evtName, handlerRef, useCapture) {
-        var result = false;
-        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
-            if (obj[strAddEventHelper]) {
-                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
-                result = true;
-            }
-            else if (obj[strAttachEvent]) {
-                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
-                result = true;
-            }
-        }
-        return result;
-    }
-    function _doUnregister(target, events, evtName, unRegFn) {
-        var idx = events[_DYN_LENGTH ];
-        while (idx--) {
-            var theEvent = events[idx];
-            if (theEvent) {
-                if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
-                    if (!unRegFn || unRegFn(theEvent)) {
-                        _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER ], theEvent.capture);
-                        events[_DYN_SPLICE ](idx, 1);
-                    }
-                }
-            }
-        }
-    }
-    function _unregisterEvents(target, evtName, unRegFn) {
-        if (evtName[_DYN_TYPE ]) {
-            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
-        }
-        else {
-            var eventCache = elmNodeData.get(target, strEvents, {});
-            objForEachKey(eventCache, function (evtType, events) {
-                _doUnregister(target, events, evtName, unRegFn);
-            });
-            if (objKeys(eventCache)[_DYN_LENGTH ] === 0) {
-                elmNodeData.kill(target, strEvents);
-            }
-        }
-    }
-    function mergeEvtNamespace(theNamespace, namespaces) {
-        var newNamespaces;
-        if (namespaces) {
-            if (isArray(namespaces)) {
-                newNamespaces = [theNamespace].concat(namespaces);
-            }
-            else {
-                newNamespaces = [theNamespace, namespaces];
-            }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
-        }
-        else {
-            newNamespaces = theNamespace;
-        }
-        return newNamespaces;
-    }
-    function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
-        var _a;
-        if (useCapture === void 0) { useCapture = false; }
-        var result = false;
-        if (target) {
-            try {
-                var evtName = _getEvtNamespace(eventName, evtNamespace);
-                result = _doAttach(target, evtName, handlerRef, useCapture);
-                if (result && elmNodeData.accept(target)) {
-                    var registeredEvent = (_a = {
-                            guid: _guid++,
-                            evtName: evtName
-                        },
-                        _a[_DYN_HANDLER ] = handlerRef,
-                        _a.capture = useCapture,
-                        _a);
-                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
-                }
-            }
-            catch (e) {
-            }
-        }
-        return result;
-    }
-    function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
-        if (useCapture === void 0) { useCapture = false; }
-        if (target) {
-            try {
-                var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
-                var found_1 = false;
-                _unregisterEvents(target, evtName_1, function (regEvent) {
-                    if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER ] === handlerRef) {
-                        found_1 = true;
-                        return true;
-                    }
-                    return false;
-                });
-                if (!found_1) {
-                    _doDetach(target, evtName_1, handlerRef, useCapture);
-                }
-            }
-            catch (e) {
-            }
-        }
-    }
-    function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
-        if (useCapture === void 0) { useCapture = false; }
-        return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
-    }
-    function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
-        if (useCapture === void 0) { useCapture = false; }
-        eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);
-    }
-    function addEventHandler(eventName, callback, evtNamespace) {
-        var result = false;
-        var w = getWindow();
-        if (w) {
-            result = eventOn(w, eventName, callback, evtNamespace);
-            result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
-        }
-        var doc = getDocument();
-        if (doc) {
-            result = eventOn(doc, eventName, callback, evtNamespace) || result;
-        }
-        return result;
-    }
-    function removeEventHandler(eventName, callback, evtNamespace) {
-        var w = getWindow();
-        if (w) {
-            eventOff(w, eventName, callback, evtNamespace);
-            eventOff(w["body"], eventName, callback, evtNamespace);
-        }
-        var doc = getDocument();
-        if (doc) {
-            eventOff(doc, eventName, callback, evtNamespace);
-        }
-    }
-    function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
-        var added = false;
-        if (listener && events && events[_DYN_LENGTH ] > 0) {
-            arrForEach(events, function (name) {
-                if (name) {
-                    if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
-                        added = addEventHandler(name, listener, evtNamespace) || added;
-                    }
-                }
-            });
-        }
-        return added;
-    }
-    function addEventListeners(events, listener, excludeEvents, evtNamespace) {
-        var added = false;
-        if (listener && events && isArray(events)) {
-            added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
-            if (!added && excludeEvents && excludeEvents[_DYN_LENGTH ] > 0) {
-                added = _addEventListeners(events, listener, null, evtNamespace);
-            }
-        }
-        return added;
-    }
-    function removeEventListeners(events, listener, evtNamespace) {
-        if (events && isArray(events)) {
-            arrForEach(events, function (name) {
-                if (name) {
-                    removeEventHandler(name, listener, evtNamespace);
-                }
-            });
-        }
-    }
-    function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
-        return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
-    }
-    function removePageUnloadEventListener(listener, evtNamespace) {
-        removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
-    }
-    function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
-        function _handlePageVisibility(evt) {
-            var doc = getDocument();
-            if (listener && doc && doc.visibilityState === "hidden") {
-                listener(evt);
-            }
-        }
-        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
-        var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
-        if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-            pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
-        }
-        if (!pageUnloadAdded && excludeEvents) {
-            pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
-        }
-        return pageUnloadAdded;
-    }
-    function removePageHideEventListener(listener, evtNamespace) {
-        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
-        removeEventListeners([strPageHide], listener, newNamespaces);
-        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
-    }
-    function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
-        function _handlePageVisibility(evt) {
-            var doc = getDocument();
-            if (listener && doc && doc.visibilityState === "visible") {
-                listener(evt);
-            }
-        }
-        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
-        var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
-        pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
-        if (!pageShowAdded && excludeEvents) {
-            pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
-        }
-        return pageShowAdded;
-    }
-    function removePageShowEventListener(listener, evtNamespace) {
-        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
-        removeEventListeners([strPageShow], listener, newNamespaces);
-        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
-    }
-
-    var _cookieMgrs = null;
-    var _canUseCookies;
-    var Undefined = strShimUndefined;
-    function newGuid() {
-        function randomHexDigit() {
-            return randomValue(15);
-        }
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"[_DYN_REPLACE ](GuidRegex, function (c) {
-            var r = (randomHexDigit() | 0), v = (c === "x" ? r : r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    function perfNow() {
-        var perf = getPerformance();
-        if (perf && perf.now) {
-            return perf.now();
-        }
-        return dateNow();
-    }
-    function generateW3CId() {
-        var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY, 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 oct[_DYN_SUBSTR ](0, 8) + oct[_DYN_SUBSTR ](9, 4) + "4" + oct[_DYN_SUBSTR ](13, 3) + clockSequenceHi + oct[_DYN_SUBSTR ](16, 3) + oct[_DYN_SUBSTR ](19, 12);
-    }
-    var CoreUtils = {
-        _canUseCookies: undefined,
-        isTypeof: isTypeof,
-        isUndefined: isUndefined,
-        isNullOrUndefined: isNullOrUndefined,
-        hasOwnProperty: hasOwnProperty,
-        isFunction: isFunction,
-        isObject: isObject,
-        isDate: isDate,
-        isArray: isArray,
-        isError: isError,
-        isString: isString,
-        isNumber: isNumber,
-        isBoolean: isBoolean,
-        toISOString: toISOString,
-        arrForEach: arrForEach,
-        arrIndexOf: arrIndexOf,
-        arrMap: arrMap,
-        arrReduce: arrReduce,
-        strTrim: strTrim,
-        objCreate: objCreateFn,
-        objKeys: objKeys,
-        objDefineAccessors: objDefineAccessors,
-        addEventHandler: addEventHandler,
-        dateNow: dateNow,
-        isIE: isIE,
-        disableCookies: disableCookies,
-        newGuid: newGuid,
-        perfNow: perfNow,
-        newId: newId,
-        randomValue: randomValue,
-        random32: random32,
-        mwcRandomSeed: mwcRandomSeed,
-        mwcRandom32: mwcRandom32,
-        generateW3CId: generateW3CId
-    };
-    var GuidRegex = /[xy]/g;
-    var EventHelper = {
-        Attach: attachEvent,
-        AttachEvent: attachEvent,
-        Detach: detachEvent,
-        DetachEvent: detachEvent
-    };
-    function _legacyCookieMgr(config, logger) {
-        var cookieMgr = _gblCookieMgr(config, logger);
-        var legacyCanUseCookies = CoreUtils._canUseCookies;
-        if (_cookieMgrs === null) {
-            _cookieMgrs = [];
-            _canUseCookies = legacyCanUseCookies;
-            objDefineAccessors(CoreUtils, "_canUseCookies", function () {
-                return _canUseCookies;
-            }, function (value) {
-                _canUseCookies = value;
-                arrForEach(_cookieMgrs, function (mgr) {
-                    mgr[_DYN_SET_ENABLED ](value);
-                });
-            });
-        }
-        if (arrIndexOf(_cookieMgrs, cookieMgr) === -1) {
-            _cookieMgrs[_DYN_PUSH ](cookieMgr);
-        }
-        if (isBoolean(legacyCanUseCookies)) {
-            cookieMgr[_DYN_SET_ENABLED ](legacyCanUseCookies);
-        }
-        if (isBoolean(_canUseCookies)) {
-            cookieMgr[_DYN_SET_ENABLED ](_canUseCookies);
-        }
-        return cookieMgr;
-    }
-    function disableCookies() {
-        _legacyCookieMgr()[_DYN_SET_ENABLED ](false);
-    }
-    function canUseCookies(logger) {
-        return _legacyCookieMgr(null, logger).isEnabled();
-    }
-    function getCookie(logger, name) {
-        return _legacyCookieMgr(null, logger).get(name);
-    }
-    function setCookie(logger, name, value, domain) {
-        _legacyCookieMgr(null, logger).set(name, value, null, domain);
-    }
-    function deleteCookie(logger, name) {
-        return _legacyCookieMgr(null, logger).del(name);
-    }
-
-    var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]*)?$/;
-    var DEFAULT_VERSION = "00";
-    var INVALID_VERSION = "ff";
-    var INVALID_TRACE_ID = "00000000000000000000000000000000";
-    var INVALID_SPAN_ID = "0000000000000000";
-    var SAMPLED_FLAG = 0x01;
-    function _isValid(value, len, invalidValue) {
-        if (value && value[_DYN_LENGTH ] === len && value !== invalidValue) {
-            return !!value.match(/^[\da-f]*$/);
-        }
-        return false;
+        return false;
     }
     function _formatValue(value, len, defValue) {
         if (_isValid(value, len)) {
@@ -3194,7 +2535,252 @@
             });
             _addChannelQueue(channelQueue, extensionQueue_1, core);
         }
-        return channelQueue;
+        return channelQueue;
+    }
+
+    var strToGMTString = "toGMTString";
+    var strToUTCString = "toUTCString";
+    var strCookie = "cookie";
+    var strExpires = "expires";
+    var strEnabled = "enabled";
+    var strIsCookieUseDisabled = "isCookieUseDisabled";
+    var strDisableCookiesUsage = "disableCookiesUsage";
+    var strConfigCookieMgr = "_ckMgr";
+    var _supportsCookies = null;
+    var _allowUaSameSite = null;
+    var _parsedCookieValue = null;
+    var _doc = getDocument();
+    var _cookieCache = {};
+    var _globalCookieConfig = {};
+    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 _createCookieMgrConfig(rootConfig) {
+        var cookieMgrCfg = rootConfig[_DYN_COOKIE_CFG ] = rootConfig[_DYN_COOKIE_CFG ] || {};
+        setValue(cookieMgrCfg, "domain", rootConfig.cookieDomain, isNotNullOrUndefined, isNullOrUndefined);
+        setValue(cookieMgrCfg, "path", rootConfig.cookiePath || "/", null, isNullOrUndefined);
+        if (isNullOrUndefined(cookieMgrCfg[strEnabled])) {
+            var cookieEnabled = void 0;
+            if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
+                cookieEnabled = !rootConfig[strIsCookieUseDisabled];
+            }
+            if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+                cookieEnabled = !rootConfig[strDisableCookiesUsage];
+            }
+            cookieMgrCfg[strEnabled] = cookieEnabled;
+        }
+        return cookieMgrCfg;
+    }
+    function safeGetCookieMgr(core, config) {
+        var cookieMgr;
+        if (core) {
+            cookieMgr = core.getCookieMgr();
+        }
+        else if (config) {
+            var cookieCfg = config[_DYN_COOKIE_CFG ];
+            if (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 = _createCookieMgrConfig(rootConfig || _globalCookieConfig);
+        var _path = cookieMgrConfig.path || "/";
+        var _domain = cookieMgrConfig.domain;
+        var _enabled = cookieMgrConfig[strEnabled] !== false;
+        var cookieMgr = {
+            isEnabled: function () {
+                var enabled = _enabled && areCookiesSupported(logger);
+                var gblManager = _globalCookieConfig[strConfigCookieMgr];
+                if (enabled && gblManager && cookieMgr !== gblManager) {
+                    enabled = _isMgrEnabled(gblManager);
+                }
+                return enabled;
+            },
+            setEnabled: function (value) {
+                _enabled = value !== false;
+            },
+            set: function (name, value, maxAgeSec, domain, path) {
+                var result = false;
+                if (_isMgrEnabled(cookieMgr)) {
+                    var values = {};
+                    var theValue = strTrim(value || STR_EMPTY);
+                    var idx = theValue.indexOf(";");
+                    if (idx !== -1) {
+                        theValue = strTrim(value[_DYN_SUBSTRING ](0, idx));
+                        values = _extractParts(value[_DYN_SUBSTRING ](idx + 1));
+                    }
+                    setValue(values, "domain", domain || _domain, isTruthy, isUndefined);
+                    if (!isNullOrUndefined(maxAgeSec)) {
+                        var _isIE = isIE();
+                        if (isUndefined(values[strExpires])) {
+                            var nowMs = dateNow();
+                            var expireMs = nowMs + (maxAgeSec * 1000);
+                            if (expireMs > 0) {
+                                var expiry = new Date();
+                                expiry.setTime(expireMs);
+                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
+                            }
+                        }
+                        if (!_isIE) {
+                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
+                        }
+                    }
+                    var location_1 = getLocation();
+                    if (location_1 && location_1.protocol === "https:") {
+                        setValue(values, "secure", null, null, isUndefined);
+                        if (_allowUaSameSite === null) {
+                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+                        }
+                        if (_allowUaSameSite) {
+                            setValue(values, "SameSite", "None", null, isUndefined);
+                        }
+                    }
+                    setValue(values, "path", path || _path, null, isUndefined);
+                    var setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+                    setCookieFn(name, _formatCookieValue(theValue, values));
+                    result = true;
+                }
+                return result;
+            },
+            get: function (name) {
+                var value = STR_EMPTY;
+                if (_isMgrEnabled(cookieMgr)) {
+                    value = (cookieMgrConfig.getCookie || _getCookieValue)(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["path"] = path ? path : "/",
+                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
+                        _a);
+                    if (!isIE()) {
+                        values["max-age"] = "0";
+                    }
+                    var delCookie = cookieMgrConfig.delCookie || _setCookieValue;
+                    delCookie(name, _formatCookieValue(STR_EMPTY, values));
+                    result = true;
+                }
+                return result;
+            }
+        };
+        cookieMgr[strConfigCookieMgr] = cookieMgr;
+        return cookieMgr;
+    }
+    function areCookiesSupported(logger) {
+        if (_supportsCookies === null) {
+            _supportsCookies = false;
+            try {
+                var doc = _doc || {};
+                _supportsCookies = doc[strCookie] !== undefined;
+            }
+            catch (e) {
+                _throwInternal(logger, 2 , 68 , "Cannot access document.cookie - " + getExceptionName(e), { exception: dumpObj(e) });
+            }
+        }
+        return _supportsCookies;
+    }
+    function _extractParts(theValue) {
+        var values = {};
+        if (theValue && theValue[_DYN_LENGTH ]) {
+            var parts = strTrim(theValue)[_DYN_SPLIT ](";");
+            arrForEach(parts, function (thePart) {
+                thePart = strTrim(thePart || STR_EMPTY);
+                if (thePart) {
+                    var idx = thePart.indexOf("=");
+                    if (idx === -1) {
+                        values[thePart] = null;
+                    }
+                    else {
+                        values[strTrim(thePart[_DYN_SUBSTRING ](0, idx))] = strTrim(thePart[_DYN_SUBSTRING ](idx + 1));
+                    }
+                }
+            });
+        }
+        return values;
+    }
+    function _formatDate(theDate, func) {
+        if (isFunction(theDate[func])) {
+            return theDate[func]();
+        }
+        return null;
+    }
+    function _formatCookieValue(value, values) {
+        var cookieValue = value || STR_EMPTY;
+        objForEachKey(values, function (name, theValue) {
+            cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : STR_EMPTY);
+        });
+        return cookieValue;
+    }
+    function _getCookieValue(name) {
+        var cookieValue = STR_EMPTY;
+        if (_doc) {
+            var theCookie = _doc[strCookie] || STR_EMPTY;
+            if (_parsedCookieValue !== theCookie) {
+                _cookieCache = _extractParts(theCookie);
+                _parsedCookieValue = theCookie;
+            }
+            cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);
+        }
+        return cookieValue;
+    }
+    function _setCookieValue(name, cookieValue) {
+        if (_doc) {
+            _doc[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;
     }
 
     function createUnloadHandlerContainer() {
@@ -3791,7 +3377,6 @@
                     }
                 }
                 function _getPlugin(pluginIdentifier) {
-                    var _a;
                     var theExt = null;
                     var thePlugin = null;
                     arrForEach(_self[_DYN__EXTENSIONS ], function (ext) {
@@ -3804,17 +3389,16 @@
                         thePlugin = _channelControl.getChannel(pluginIdentifier);
                     }
                     if (thePlugin) {
-                        theExt = (_a = {
-                                plugin: thePlugin
-                            },
-                            _a[_DYN_SET_ENABLED ] = function (enabled) {
+                        theExt = {
+                            plugin: thePlugin,
+                            setEnabled: function (enabled) {
                                 _getPluginState(thePlugin)[STR_DISABLED] = !enabled;
                             },
-                            _a.isEnabled = function () {
+                            isEnabled: function () {
                                 var pluginState = _getPluginState(thePlugin);
                                 return !pluginState[_DYN_TEARDOWN ] && !pluginState[STR_DISABLED];
                             },
-                            _a.remove = function (isAsync, removeCb) {
+                            remove: function (isAsync, removeCb) {
                                 var _a;
                                 if (isAsync === void 0) { isAsync = true; }
                                 var pluginsToRemove = [thePlugin];
@@ -3832,8 +3416,8 @@
                                     }
                                     removeCb && removeCb(removed);
                                 });
-                            },
-                            _a);
+                            }
+                        };
                     }
                     return theExt;
                 }
@@ -3952,112 +3536,422 @@
                 }
             });
         }
-        BaseCore.__ieDyn=1;
-        return BaseCore;
-    }());
-
-    function _runListeners(listeners, name, isAsync, callback) {
-        arrForEach(listeners, function (listener) {
-            if (listener && listener[name]) {
-                if (isAsync) {
-                    setTimeout(function () { return callback(listener); }, 0);
+        BaseCore.__ieDyn=1;
+        return BaseCore;
+    }());
+
+    function _runListeners(listeners, name, isAsync, callback) {
+        arrForEach(listeners, function (listener) {
+            if (listener && listener[name]) {
+                if (isAsync) {
+                    setTimeout(function () { return callback(listener); }, 0);
+                }
+                else {
+                    try {
+                        callback(listener);
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        });
+    }
+    var NotificationManager = /** @class */ (function () {
+        function NotificationManager(config) {
+            this.listeners = [];
+            var perfEvtsSendAll = !!(config || {}).perfEvtsSendAll;
+            dynamicProto(NotificationManager, this, function (_self) {
+                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
+                    _self.listeners[_DYN_PUSH ](listener);
+                };
+                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
+                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    while (index > -1) {
+                        _self.listeners[_DYN_SPLICE ](index, 1);
+                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    }
+                };
+                _self[STR_EVENTS_SENT ] = function (events) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
+                        listener[STR_EVENTS_SENT ](events);
+                    });
+                };
+                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
+                        listener[STR_EVENTS_DISCARDED ](events, reason);
+                    });
+                };
+                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
+                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
+                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
+                    });
+                };
+                _self[STR_PERF_EVENT ] = function (perfEvent) {
+                    if (perfEvent) {
+                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
+                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
+                                if (perfEvent[_DYN_IS_ASYNC ]) {
+                                    setTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
+                                }
+                                else {
+                                    listener[STR_PERF_EVENT ](perfEvent);
+                                }
+                            });
+                        }
+                    }
+                };
+            });
+        }
+        NotificationManager.__ieDyn=1;
+        return NotificationManager;
+    }());
+
+    var AppInsightsCore = /** @class */ (function (_super) {
+        __extendsFn(AppInsightsCore, _super);
+        function AppInsightsCore() {
+            var _this = _super.call(this) || this;
+            dynamicProto(AppInsightsCore, _this, function (_self, _base) {
+                _self[_DYN_INITIALIZE ] = function (config, extensions, logger, notificationManager) {
+                    _base[_DYN_INITIALIZE ](config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
+                };
+                _self.track = function (telemetryItem) {
+                    doPerf(_self[STR_GET_PERF_MGR ](), function () { return "AppInsightsCore:track"; }, function () {
+                        if (telemetryItem === null) {
+                            _notifyInvalidEvent(telemetryItem);
+                            throwError("Invalid telemetry item");
+                        }
+                        _validateTelemetryItem(telemetryItem);
+                        _base.track(telemetryItem);
+                    }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
+                };
+                function _validateTelemetryItem(telemetryItem) {
+                    if (isNullOrUndefined(telemetryItem[_DYN_NAME ])) {
+                        _notifyInvalidEvent(telemetryItem);
+                        throwError("telemetry name required");
+                    }
+                }
+                function _notifyInvalidEvent(telemetryItem) {
+                    var manager = _self[_DYN_GET_NOTIFY_MGR ]();
+                    if (manager) {
+                        manager[STR_EVENTS_DISCARDED ]([telemetryItem], 2 );
+                    }
+                }
+            });
+            return _this;
+        }
+        AppInsightsCore.__ieDyn=1;
+        return AppInsightsCore;
+    }(BaseCore));
+
+    var strOnPrefix = "on";
+    var strAttachEvent = "attachEvent";
+    var strAddEventHelper = "addEventListener";
+    var strDetachEvent = "detachEvent";
+    var strRemoveEventListener = "removeEventListener";
+    var strEvents = "events";
+    var strVisibilityChangeEvt = "visibilitychange";
+    var strPageHide = "pagehide";
+    var strPageShow = "pageshow";
+    var strUnload = "unload";
+    var strBeforeUnload = "beforeunload";
+    var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
+    var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
+    var rRemoveEmptyNs = /\.[\.]+/g;
+    var rRemoveTrailingEmptyNs = /[\.]+$/;
+    var _guid = 1;
+    var elmNodeData = createElmNodeData("events");
+    var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
+    function _normalizeNamespace(name) {
+        if (name && name[_DYN_REPLACE ]) {
+            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
+        }
+        return name;
+    }
+    function _getEvtNamespace(eventName, evtNamespace) {
+        var _a;
+        if (evtNamespace) {
+            var theNamespace_1 = STR_EMPTY;
+            if (isArray(evtNamespace)) {
+                theNamespace_1 = STR_EMPTY;
+                arrForEach(evtNamespace, function (name) {
+                    name = _normalizeNamespace(name);
+                    if (name) {
+                        if (name[0] !== ".") {
+                            name = "." + name;
+                        }
+                        theNamespace_1 += name;
+                    }
+                });
+            }
+            else {
+                theNamespace_1 = _normalizeNamespace(evtNamespace);
+            }
+            if (theNamespace_1) {
+                if (theNamespace_1[0] !== ".") {
+                    theNamespace_1 = "." + theNamespace_1;
+                }
+                eventName = (eventName || STR_EMPTY) + theNamespace_1;
+            }
+        }
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        return _a = {},
+            _a[_DYN_TYPE ] = parsedEvent[1],
+            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT ](".").sort()).join("."),
+            _a;
+    }
+    function __getRegisteredEvents(target, eventName, evtNamespace) {
+        var theEvents = [];
+        var eventCache = elmNodeData.get(target, strEvents, {}, false);
+        var evtName = _getEvtNamespace(eventName, evtNamespace);
+        objForEachKey(eventCache, function (evtType, registeredEvents) {
+            arrForEach(registeredEvents, function (value) {
+                var _a;
+                if (!evtName[_DYN_TYPE ] || evtName[_DYN_TYPE ] === value.evtName[_DYN_TYPE ]) {
+                    if (!evtName.ns || evtName.ns === evtName.ns) {
+                        theEvents[_DYN_PUSH ]((_a = {},
+                            _a[_DYN_NAME ] = value.evtName[_DYN_TYPE ] + (value.evtName.ns ? "." + value.evtName.ns : STR_EMPTY),
+                            _a.handler = value[_DYN_HANDLER ],
+                            _a));
+                    }
+                }
+            });
+        });
+        return theEvents;
+    }
+    function _getRegisteredEvents(target, evtName, addDefault) {
+        if (addDefault === void 0) { addDefault = true; }
+        var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
+        var registeredEvents = aiEvts[evtName];
+        if (!registeredEvents) {
+            registeredEvents = aiEvts[evtName] = [];
+        }
+        return registeredEvents;
+    }
+    function _doDetach(obj, evtName, handlerRef, useCapture) {
+        if (obj && evtName && evtName[_DYN_TYPE ]) {
+            if (obj[strRemoveEventListener]) {
+                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
+            }
+            else if (obj[strDetachEvent]) {
+                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
+            }
+        }
+    }
+    function _doAttach(obj, evtName, handlerRef, useCapture) {
+        var result = false;
+        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
+            if (obj[strAddEventHelper]) {
+                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
+                result = true;
+            }
+            else if (obj[strAttachEvent]) {
+                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
+                result = true;
+            }
+        }
+        return result;
+    }
+    function _doUnregister(target, events, evtName, unRegFn) {
+        var idx = events[_DYN_LENGTH ];
+        while (idx--) {
+            var theEvent = events[idx];
+            if (theEvent) {
+                if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
+                    if (!unRegFn || unRegFn(theEvent)) {
+                        _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER ], theEvent.capture);
+                        events[_DYN_SPLICE ](idx, 1);
+                    }
+                }
+            }
+        }
+    }
+    function _unregisterEvents(target, evtName, unRegFn) {
+        if (evtName[_DYN_TYPE ]) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
+        }
+        else {
+            var eventCache = elmNodeData.get(target, strEvents, {});
+            objForEachKey(eventCache, function (evtType, events) {
+                _doUnregister(target, events, evtName, unRegFn);
+            });
+            if (objKeys(eventCache)[_DYN_LENGTH ] === 0) {
+                elmNodeData.kill(target, strEvents);
+            }
+        }
+    }
+    function mergeEvtNamespace(theNamespace, namespaces) {
+        var newNamespaces;
+        if (namespaces) {
+            if (isArray(namespaces)) {
+                newNamespaces = [theNamespace].concat(namespaces);
+            }
+            else {
+                newNamespaces = [theNamespace, namespaces];
+            }
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
+        }
+        else {
+            newNamespaces = theNamespace;
+        }
+        return newNamespaces;
+    }
+    function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
+        if (useCapture === void 0) { useCapture = false; }
+        var result = false;
+        if (target) {
+            try {
+                var evtName = _getEvtNamespace(eventName, evtNamespace);
+                result = _doAttach(target, evtName, handlerRef, useCapture);
+                if (result && elmNodeData.accept(target)) {
+                    var registeredEvent = (_a = {
+                            guid: _guid++,
+                            evtName: evtName
+                        },
+                        _a[_DYN_HANDLER ] = handlerRef,
+                        _a.capture = useCapture,
+                        _a);
+                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
                 }
-                else {
-                    try {
-                        callback(listener);
-                    }
-                    catch (e) {
+            }
+            catch (e) {
+            }
+        }
+        return result;
+    }
+    function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
+        if (useCapture === void 0) { useCapture = false; }
+        if (target) {
+            try {
+                var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
+                var found_1 = false;
+                _unregisterEvents(target, evtName_1, function (regEvent) {
+                    if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER ] === handlerRef) {
+                        found_1 = true;
+                        return true;
                     }
+                    return false;
+                });
+                if (!found_1) {
+                    _doDetach(target, evtName_1, handlerRef, useCapture);
                 }
             }
-        });
+            catch (e) {
+            }
+        }
     }
-    var NotificationManager = /** @class */ (function () {
-        function NotificationManager(config) {
-            this.listeners = [];
-            var perfEvtsSendAll = !!(config || {}).perfEvtsSendAll;
-            dynamicProto(NotificationManager, this, function (_self) {
-                _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
-                    _self.listeners[_DYN_PUSH ](listener);
-                };
-                _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
-                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
-                    while (index > -1) {
-                        _self.listeners[_DYN_SPLICE ](index, 1);
-                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
-                    }
-                };
-                _self[STR_EVENTS_SENT ] = function (events) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
-                        listener[STR_EVENTS_SENT ](events);
-                    });
-                };
-                _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
-                        listener[STR_EVENTS_DISCARDED ](events, reason);
-                    });
-                };
-                _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
-                        listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
-                    });
-                };
-                _self[STR_PERF_EVENT ] = function (perfEvent) {
-                    if (perfEvent) {
-                        if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
-                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
-                                if (perfEvent[_DYN_IS_ASYNC ]) {
-                                    setTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
-                                }
-                                else {
-                                    listener[STR_PERF_EVENT ](perfEvent);
-                                }
-                            });
-                        }
-                    }
-                };
-            });
+    function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
+        if (useCapture === void 0) { useCapture = false; }
+        return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
+    }
+    function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
+        if (useCapture === void 0) { useCapture = false; }
+        eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);
+    }
+    function addEventHandler(eventName, callback, evtNamespace) {
+        var result = false;
+        var w = getWindow();
+        if (w) {
+            result = eventOn(w, eventName, callback, evtNamespace);
+            result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
         }
-        NotificationManager.__ieDyn=1;
-        return NotificationManager;
-    }());
-
-    var AppInsightsCore = /** @class */ (function (_super) {
-        __extendsFn(AppInsightsCore, _super);
-        function AppInsightsCore() {
-            var _this = _super.call(this) || this;
-            dynamicProto(AppInsightsCore, _this, function (_self, _base) {
-                _self[_DYN_INITIALIZE ] = function (config, extensions, logger, notificationManager) {
-                    _base[_DYN_INITIALIZE ](config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
-                };
-                _self.track = function (telemetryItem) {
-                    doPerf(_self[STR_GET_PERF_MGR ](), function () { return "AppInsightsCore:track"; }, function () {
-                        if (telemetryItem === null) {
-                            _notifyInvalidEvent(telemetryItem);
-                            throwError("Invalid telemetry item");
-                        }
-                        _validateTelemetryItem(telemetryItem);
-                        _base.track(telemetryItem);
-                    }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
-                };
-                function _validateTelemetryItem(telemetryItem) {
-                    if (isNullOrUndefined(telemetryItem[_DYN_NAME ])) {
-                        _notifyInvalidEvent(telemetryItem);
-                        throwError("telemetry name required");
+        var doc = getDocument();
+        if (doc) {
+            result = eventOn(doc, eventName, callback, evtNamespace) || result;
+        }
+        return result;
+    }
+    function removeEventHandler(eventName, callback, evtNamespace) {
+        var w = getWindow();
+        if (w) {
+            eventOff(w, eventName, callback, evtNamespace);
+            eventOff(w["body"], eventName, callback, evtNamespace);
+        }
+        var doc = getDocument();
+        if (doc) {
+            eventOff(doc, eventName, callback, evtNamespace);
+        }
+    }
+    function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
+        var added = false;
+        if (listener && events && events[_DYN_LENGTH ] > 0) {
+            arrForEach(events, function (name) {
+                if (name) {
+                    if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
+                        added = addEventHandler(name, listener, evtNamespace) || added;
                     }
                 }
-                function _notifyInvalidEvent(telemetryItem) {
-                    var manager = _self[_DYN_GET_NOTIFY_MGR ]();
-                    if (manager) {
-                        manager[STR_EVENTS_DISCARDED ]([telemetryItem], 2 );
-                    }
+            });
+        }
+        return added;
+    }
+    function addEventListeners(events, listener, excludeEvents, evtNamespace) {
+        var added = false;
+        if (listener && events && isArray(events)) {
+            added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
+            if (!added && excludeEvents && excludeEvents[_DYN_LENGTH ] > 0) {
+                added = _addEventListeners(events, listener, null, evtNamespace);
+            }
+        }
+        return added;
+    }
+    function removeEventListeners(events, listener, evtNamespace) {
+        if (events && isArray(events)) {
+            arrForEach(events, function (name) {
+                if (name) {
+                    removeEventHandler(name, listener, evtNamespace);
                 }
             });
-            return _this;
         }
-        AppInsightsCore.__ieDyn=1;
-        return AppInsightsCore;
-    }(BaseCore));
+    }
+    function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
+        return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
+    }
+    function removePageUnloadEventListener(listener, evtNamespace) {
+        removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
+    }
+    function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
+        function _handlePageVisibility(evt) {
+            var doc = getDocument();
+            if (listener && doc && doc.visibilityState === "hidden") {
+                listener(evt);
+            }
+        }
+        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+        var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
+        if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
+            pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
+        }
+        if (!pageUnloadAdded && excludeEvents) {
+            pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
+        }
+        return pageUnloadAdded;
+    }
+    function removePageHideEventListener(listener, evtNamespace) {
+        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+        removeEventListeners([strPageHide], listener, newNamespaces);
+        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+    }
+    function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
+        function _handlePageVisibility(evt) {
+            var doc = getDocument();
+            if (listener && doc && doc.visibilityState === "visible") {
+                listener(evt);
+            }
+        }
+        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+        var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
+        pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
+        if (!pageShowAdded && excludeEvents) {
+            pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
+        }
+        return pageShowAdded;
+    }
+    function removePageShowEventListener(listener, evtNamespace) {
+        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+        removeEventListeners([strPageShow], listener, newNamespaces);
+        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+    }
 
     var _a;
     var FAILED = "Failed";
@@ -4224,7 +4118,7 @@
                 _a);
             var hookCtx = [];
             var cbArgs = _createArgs([funcArgs], orgArgs);
-            funcArgs.evt = getGlobalInst("event");
+            funcArgs.evt = getInst("event");
             function _createArgs(target, theArgs) {
                 _arrLoop(theArgs, function (arg) {
                     target[_DYN_PUSH ](arg);
@@ -4255,11 +4149,11 @@
     function _getOwner(target, name, checkPrototype) {
         var owner = null;
         if (target) {
-            if (hasOwnProperty(target, name)) {
+            if (objHasOwnProperty(target, name)) {
                 owner = target;
             }
             else if (checkPrototype) {
-                owner = _getOwner(_getObjProto$1(target), name, false);
+                owner = _getOwner(_getObjProto(target), name, false);
             }
         }
         return owner;
@@ -4346,9 +4240,7 @@
     exports.AppInsightsCore = AppInsightsCore;
     exports.BaseCore = BaseCore;
     exports.BaseTelemetryPlugin = BaseTelemetryPlugin;
-    exports.CoreUtils = CoreUtils;
     exports.DiagnosticLogger = DiagnosticLogger;
-    exports.EventHelper = EventHelper;
     exports.EventsDiscardedReason = EventsDiscardedReason;
     exports.InstrumentEvent = InstrumentEvent;
     exports.InstrumentFunc = InstrumentFunc;
@@ -4365,7 +4257,6 @@
     exports._InternalLogMessage = _InternalLogMessage;
     exports._InternalMessageId = _InternalMessageId;
     exports.__getRegisteredEvents = __getRegisteredEvents;
-    exports._legacyCookieMgr = _legacyCookieMgr;
     exports._logInternalMessage = _logInternalMessage;
     exports._throwInternal = _throwInternal;
     exports._warnToConsole = _warnToConsole;
@@ -4380,10 +4271,8 @@
     exports.arrMap = arrMap;
     exports.arrReduce = arrReduce;
     exports.attachEvent = attachEvent;
-    exports.canUseCookies = canUseCookies;
     exports.createClassFromInterface = createClassFromInterface;
     exports.createCookieMgr = createCookieMgr;
-    exports.createEnumMap = createEnumMap;
     exports.createEnumStyle = createEnumStyle;
     exports.createProcessTelemetryContext = createProcessTelemetryContext;
     exports.createTraceParent = createTraceParent;
@@ -4391,10 +4280,8 @@
     exports.createUnloadHandlerContainer = createUnloadHandlerContainer;
     exports.createValueMap = createValueMap;
     exports.dateNow = dateNow;
-    exports.deepFreeze = deepFreeze;
-    exports.deleteCookie = deleteCookie;
+    exports.deepFreeze = objDeepFreeze;
     exports.detachEvent = detachEvent;
-    exports.disableCookies = disableCookies;
     exports.doPerf = doPerf;
     exports.dumpObj = dumpObj;
     exports.eventOff = eventOff;
@@ -4405,7 +4292,6 @@
     exports.formatTraceParent = formatTraceParent;
     exports.generateW3CId = generateW3CId;
     exports.getConsole = getConsole;
-    exports.getCookie = getCookie;
     exports.getCrypto = getCrypto;
     exports.getDebugExt = getDebugExt;
     exports.getDebugListener = getDebugListener;
@@ -4413,7 +4299,7 @@
     exports.getExceptionName = getExceptionName;
     exports.getGblPerfMgr = getGblPerfMgr;
     exports.getGlobal = getGlobal;
-    exports.getGlobalInst = getGlobalInst;
+    exports.getGlobalInst = getInst;
     exports.getHistory = getHistory;
     exports.getIEVersion = getIEVersion;
     exports.getJSON = getJSON;
@@ -4427,7 +4313,7 @@
     exports.hasHistory = hasHistory;
     exports.hasJSON = hasJSON;
     exports.hasNavigator = hasNavigator;
-    exports.hasOwnProperty = hasOwnProperty;
+    exports.hasOwnProperty = objHasOwnProperty;
     exports.hasWindow = hasWindow;
     exports.initializePlugins = initializePlugins;
     exports.isArray = isArray;
@@ -4485,7 +4371,6 @@
     exports.removePageUnloadEventListener = removePageUnloadEventListener;
     exports.safeGetCookieMgr = safeGetCookieMgr;
     exports.safeGetLogger = safeGetLogger;
-    exports.setCookie = setCookie;
     exports.setEnableEnvMocks = setEnableEnvMocks;
     exports.setGblPerfMgr = setGblPerfMgr;
     exports.setValue = setValue;
@@ -4504,7 +4389,7 @@
     exports.unloadComponents = unloadComponents;
     exports.useXDomainRequest = useXDomainRequest;
 
-    (function(obj, prop, descriptor) { /* ai_es3_polyfil defineProperty */ var func = Object["defineProperty"]; if (func) { try { return func(obj, prop, descriptor); } catch(e) { /* IE8 defines defineProperty, but will throw */ } } if (descriptor && typeof descriptor.value !== undefined) { obj[prop] = descriptor.value; } return obj; })(exports, '__esModule', { value: true });
+    Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
 //# sourceMappingURL=applicationinsights-core-js.js.map