@microsoft/applicationinsights-common 3.0.0-beta.2303-11 → 3.0.0-nightly3.2304-28

package/browser/es5/applicationinsights-common.cjs.js

@@ -0,0 +1,3965 @@
+/*!
+ * Application Insights JavaScript SDK - Common, 3.0.0-nightly3.2304-28
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+'use strict';
+
+var UNDEF_VALUE = undefined;
+var EMPTY = "";
+var FUNCTION = "function";
+var NUMBER = "number";
+var OBJECT = "object";
+var PROTOTYPE = "prototype";
+var STRING = "string";
+var UNDEFINED = "undefined";
+var CONSTRUCTOR = "constructor";
+var SYMBOL = "Symbol";
+var POLYFILL_TAG = "_polyfill";
+var INDEX_OF = "indexOf";
+var LENGTH = "length";
+var DONE = "done";
+var VALUE = "value";
+var NAME = "name";
+var SLICE = "slice";
+var ObjClass$1 = Object;
+var ObjProto$1 = ObjClass$1[PROTOTYPE];
+var StrCls = String;
+var StrProto = StrCls[PROTOTYPE];
+var MathCls = Math;
+var ArrCls = Array;
+var ArrProto = ArrCls[PROTOTYPE];
+
+function _safeGet(cb, defValue) {
+    var result = defValue;
+    try {
+        result = cb();
+    }
+    catch (e) {
+    }
+    return result;
+}
+
+function _createIs(theType) {
+    return function (value) {
+        return typeof value === theType;
+    };
+}
+function _createObjIs(theName) {
+    var theType = "[object " + theName + "]";
+    return function (value) {
+        return !!(value && objToString(value) === theType);
+    };
+}
+function objToString(value) {
+    return ObjProto$1.toString.call(value);
+}
+function isUndefined(value) {
+    return typeof value === UNDEFINED || value === UNDEFINED;
+}
+function isNullOrUndefined(value) {
+    return value === null || isUndefined(value);
+}
+function isStrictNullOrUndefined(value) {
+    return value === null || !isDefined(value);
+}
+function isDefined(arg) {
+    return !!arg || arg !== UNDEF_VALUE;
+}
+var isString = _createIs(STRING);
+var isFunction = _createIs(FUNCTION);
+function isObject(value) {
+    if (!value && isNullOrUndefined(value)) {
+        return false;
+    }
+    return !!value && typeof value === OBJECT;
+}
+var isArray = ArrCls.isArray;
+var isNumber = _createIs(NUMBER);
+var isError = _createObjIs("Error");
+
+var objGetOwnPropertyDescriptor = ObjClass$1.getOwnPropertyDescriptor;
+
+function objHasOwnProperty(obj, prop) {
+    return obj && ObjProto$1.hasOwnProperty.call(obj, prop);
+}
+
+var objHasOwn = ObjClass$1["hasOwn"] || polyObjHasOwn;
+function polyObjHasOwn(obj, prop) {
+    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
+}
+
+function objForEachKey(theObject, callbackfn, thisArg) {
+    if (theObject && isObject(theObject)) {
+        for (var prop in theObject) {
+            if (objHasOwn(theObject, prop)) {
+                if (callbackfn.call(thisArg || theObject, prop, theObject[prop]) === -1) {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+function _createKeyValueMap(values, keyType, valueType, completeFn) {
+    var theMap = {};
+    objForEachKey(values, function (key, value) {
+        theMap[key] = keyType ? value : key;
+        theMap[value] = valueType ? value : key;
+    });
+    return completeFn(theMap);
+}
+
+function throwError(message) {
+    throw new Error(message);
+}
+function throwTypeError(message) {
+    throw new TypeError(message);
+}
+
+var _objFreeze = ObjClass$1["freeze"];
+var _doNothing = function (value) { return value; };
+var objAssign = ObjClass$1["assign"];
+function objKeys(value) {
+    if (!isObject(value) || value === null) {
+        throwTypeError("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 objGetPrototypeOf = ObjClass$1["getPrototypeOf"] || _doNothing;
+
+function createEnum(values) {
+    return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
+}
+function createEnumKeyMap(values) {
+    return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+}
+function createSimpleMap(values) {
+    var mapClass = {};
+    objForEachKey(values, function (key, value) {
+        mapClass[key] = value[1];
+        mapClass[value[0]] = value[1];
+    });
+    return objDeepFreeze(mapClass);
+}
+function createTypeMap(values) {
+    return createSimpleMap(values);
+}
+
+var _wellKnownSymbolMap = createEnumKeyMap({
+    asyncIterator: 0 ,
+    hasInstance: 1 ,
+    isConcatSpreadable: 2 ,
+    iterator: 3 ,
+    match: 4 ,
+    matchAll: 5 ,
+    replace: 6 ,
+    search: 7 ,
+    species: 8 ,
+    split: 9 ,
+    toPrimitive: 10 ,
+    toStringTag: 11 ,
+    unscopables: 12
+});
+
+var asString = StrCls;
+
+var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
+var _globalCfg;
+function _getGlobalValue() {
+    var result;
+    if (typeof globalThis !== UNDEFINED) {
+        result = globalThis;
+    }
+    if (!result && typeof self !== UNDEFINED) {
+        result = self;
+    }
+    if (!result && typeof window !== UNDEFINED) {
+        result = window;
+    }
+    if (!result && typeof global !== UNDEFINED) {
+        result = global;
+    }
+    return result;
+}
+function _getGlobalConfig() {
+    if (!_globalCfg) {
+        var gbl = _getGlobalValue() || {};
+        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
+    }
+    return _globalCfg;
+}
+
+function dumpObj(object, format) {
+    var propertyValueDump = EMPTY;
+    if (isError(object)) {
+        propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+    }
+    else {
+        try {
+            propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+        }
+        catch (e) {
+            propertyValueDump = " - " + dumpObj(e, format);
+        }
+    }
+    return objToString(object) + ": " + propertyValueDump;
+}
+
+function _unwrapFunction(funcName, target, polyFunc) {
+    return function (thisArg) {
+        var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
+        if (theFunc || polyFunc) {
+            var theArgs = arguments;
+            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
+        }
+        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+    };
+}
+
+var mathMax = MathCls.max;
+
+var strSlice = _unwrapFunction(SLICE, StrProto);
+
+var strSubstring = _unwrapFunction("substring", StrProto);
+var strSubstr = _unwrapFunction("substr", StrProto, polyStrSubstr);
+function polyStrSubstr(value, start, length) {
+    if (isNullOrUndefined(value)) {
+        throwTypeError("'polyStrSubstr called with invalid " + dumpObj(value));
+    }
+    if (length < 0) {
+        return EMPTY;
+    }
+    start = start || 0;
+    if (start < 0) {
+        start = mathMax(start + value[LENGTH], 0);
+    }
+    if (isUndefined(length)) {
+        return strSlice(value, start);
+    }
+    return strSlice(value, start, start + length);
+}
+function strLeft(value, count) {
+    return strSubstring(value, 0, count);
+}
+
+var _polySymbols;
+function _globalSymbolRegistry() {
+    if (!_polySymbols) {
+        var gblCfg = _getGlobalConfig();
+        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
+    }
+    return _polySymbols;
+}
+var _wellKnownSymbolCache = {};
+function polyNewSymbol(description) {
+    var theSymbol = {
+        description: asString(description),
+        toString: function () { return SYMBOL + "(" + description + ")"; }
+    };
+    theSymbol[POLYFILL_TAG] = true;
+    return theSymbol;
+}
+function polySymbolFor(key) {
+    var registry = _globalSymbolRegistry();
+    if (!objHasOwn(registry, key)) {
+        var newSymbol = polyNewSymbol(key);
+        registry.k[key] = newSymbol;
+        registry.s[newSymbol] = asString(key);
+    }
+    return registry.k[key];
+}
+function polyGetKnownSymbol(name) {
+    var result;
+    var knownName = _wellKnownSymbolMap[name];
+    if (knownName) {
+        result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+    }
+    return result;
+}
+
+var propMap = {
+    e: "enumerable",
+    c: "configurable",
+    v: VALUE,
+    w: "writable",
+    g: "get",
+    s: "set"
+};
+function _createProp(value) {
+    var prop = {};
+    prop[propMap["c"]] = true;
+    prop[propMap["e"]] = true;
+    if (value.l) {
+        prop.get = function () { return value.l.v; };
+        var desc = objGetOwnPropertyDescriptor(value.l, "v");
+        if (desc && desc.set) {
+            prop.set = function (newValue) {
+                value.l.v = newValue;
+            };
+        }
+    }
+    objForEachKey(value, function (key, value) {
+        prop[propMap[key]] = isUndefined(value) ? prop[propMap[key]] : value;
+    });
+    return prop;
+}
+var objDefineProp = ObjClass$1["defineProperty"];
+function objDefine(target, key, propDesc) {
+    return objDefineProp(target, key, _createProp(propDesc));
+}
+
+var _globalLazyTestHooks;
+var _fetchLazyTestHooks = function () {
+    _globalLazyTestHooks = _getGlobalConfig();
+    _fetchLazyTestHooks = null;
+};
+function getLazy(cb) {
+    var lazyValue = {};
+    _fetchLazyTestHooks && _fetchLazyTestHooks();
+    lazyValue.b = _globalLazyTestHooks.lzy;
+    objDefineProp(lazyValue, "v", {
+        configurable: true,
+        get: function () {
+            var result = cb();
+            if (!_globalLazyTestHooks.lzy) {
+                objDefineProp(lazyValue, "v", {
+                    value: result
+                });
+                if (lazyValue.b) {
+                    delete lazyValue.b;
+                }
+            }
+            if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
+                lazyValue.b = _globalLazyTestHooks.lzy;
+            }
+            return result;
+        }
+    });
+    return lazyValue;
+}
+
+function _lazySafeGet(cb, defValue) {
+    return getLazy(function () { return _safeGet(cb, defValue); });
+}
+
+var WINDOW = "window";
+var _cachedGlobal;
+var _cachedWindow;
+var _cachedDocument;
+var _cachedNavigator;
+function _lazySafeGetInst(name) {
+    return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+}
+function getGlobal(useCached) {
+    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
+    return _cachedGlobal.v;
+}
+function getInst(name, useCached) {
+    var gbl = getGlobal(useCached);
+    if (gbl && gbl[name]) {
+        return gbl[name];
+    }
+    if (name === WINDOW && _cachedWindow) {
+        return _cachedWindow.v;
+    }
+    return null;
+}
+function getDocument() {
+    (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst("document"));
+    return _cachedDocument.v;
+}
+function hasWindow() {
+    return !!getWindow();
+}
+function getWindow() {
+    (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+    return _cachedWindow.v;
+}
+function hasNavigator() {
+    return !!getNavigator();
+}
+function getNavigator() {
+    (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+    return _cachedNavigator.v;
+}
+
+var _symbol;
+var _symbolFor;
+var _symbolKeyFor;
+function _getSymbolValue(name) {
+    return _lazySafeGet(function () {
+        return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+    }, UNDEF_VALUE);
+}
+function getSymbol() {
+    var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
+    resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
+    (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
+    (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
+    return _symbol.v;
+}
+function getKnownSymbol(name, noPoly) {
+    var knownName = _wellKnownSymbolMap[name];
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+}
+function newSymbol(description, noPoly) {
+    (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+}
+function symbolFor(key) {
+    (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
+    return (_symbolFor.v || polySymbolFor)(key);
+}
+
+function isIterator(value) {
+    return !!value && isFunction(value.next);
+}
+function isIterable(value) {
+    return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
+}
+
+function iterForOf(iter, callbackfn, thisArg) {
+    if (iter) {
+        if (!isIterator(iter)) {
+            var itSymbol = getKnownSymbol(3 );
+            iter = iter[itSymbol] ? iter[itSymbol]() : null;
+        }
+        if (isIterator(iter)) {
+            try {
+                var count = 0;
+                var value = iter.next();
+                while (!value[DONE]) {
+                    if (callbackfn.call(thisArg || iter, value[VALUE], count, iter) === -1) {
+                        break;
+                    }
+                    count++;
+                    value = iter.next();
+                }
+                iter.return && iter.return(value);
+            }
+            catch (e) {
+                iter.throw && iter.throw(e);
+            }
+        }
+    }
+}
+
+function arrAppend(target, elms) {
+    if (!isUndefined(elms) && target) {
+        if (isArray(elms)) {
+            target.push.apply(target, elms);
+        }
+        else if (isIterator(elms) || isIterable(elms)) {
+            iterForOf(elms, function (elm) {
+                target.push(elm);
+            });
+        }
+        else {
+            target.push(elms);
+        }
+    }
+    return target;
+}
+
+function arrForEach(theArray, callbackfn, thisArg) {
+    if (theArray) {
+        var len = theArray[LENGTH] >>> 0;
+        for (var idx = 0; idx < len; idx++) {
+            if (idx in theArray) {
+                if (callbackfn.call(thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
+
+var arrMap = _unwrapFunction("map", ArrProto);
+
+var arrReduce = _unwrapFunction("reduce", ArrProto);
+
+var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+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) { return d[key] = value; });
+        };
+    return fn(obj, proto);
+}
+
+function _createCustomError(name, d, baseClass) {
+    objSetPrototypeOf(d, baseClass);
+    function __() {
+        this.constructor = d;
+        this[NAME] = name;
+    }
+    __[PROTOTYPE] = baseClass[PROTOTYPE];
+    d[PROTOTYPE] = new __();
+    return d;
+}
+var _safeSetName = function (baseClass, name) {
+    try {
+        baseClass[PROTOTYPE][NAME] = name;
+    }
+    catch (e) {
+    }
+};
+function createCustomError(name, constructCb) {
+    var baseClass = Error;
+    var orgName = baseClass[PROTOTYPE][NAME];
+    var customError = _createCustomError(name, function () {
+        var _this = this;
+        try {
+            _safeSetName(baseClass, name);
+            _this = baseClass.apply(_this, arguments) || _this;
+            _this[NAME] = name;
+            constructCb && constructCb(_this, arguments);
+        }
+        finally {
+            _safeSetName(baseClass, orgName);
+        }
+        return _this;
+    }, baseClass);
+    return customError;
+}
+
+function utcNow() {
+    return (Date.now || polyUtcNow)();
+}
+function polyUtcNow() {
+    return new Date().getTime();
+}
+
+function _createTrimFn(exp) {
+    return function _doTrim(value) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError("strTrim called [" + dumpObj(value) + "]");
+        }
+        if (value && value.replace) {
+            value = value.replace(exp, EMPTY);
+        }
+        return value;
+    };
+}
+var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
+
+var strTrim = _unwrapFunction("trim", StrProto, polyStrTrim);
+
+var _fnToString;
+var _objCtrFnString;
+var _gblWindow;
+function isPlainObject(value) {
+    if (!value || typeof value !== OBJECT) {
+        return false;
+    }
+    if (!_gblWindow) {
+        _gblWindow = hasWindow() ? getWindow() : true;
+    }
+    var result = false;
+    if (value !== _gblWindow) {
+        if (!_objCtrFnString) {
+            _fnToString = Function[PROTOTYPE].toString;
+            _objCtrFnString = _fnToString.call(ObjClass$1);
+        }
+        try {
+            var proto = objGetPrototypeOf(value);
+            result = !proto;
+            if (!result) {
+                if (objHasOwnProperty(proto, CONSTRUCTOR)) {
+                    proto = proto[CONSTRUCTOR];
+                }
+                result = proto && typeof proto === FUNCTION && _fnToString.call(proto) === _objCtrFnString;
+            }
+        }
+        catch (ex) {
+        }
+    }
+    return result;
+}
+
+var _perf;
+function getPerformance() {
+    (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
+    return _perf.v;
+}
+
+var _objCreate = ObjClass$1["create"];
+var objCreate = _objCreate || polyObjCreate;
+function polyObjCreate(obj) {
+    if (!obj) {
+        return {};
+    }
+    var type = typeof obj;
+    if (type !== OBJECT && type !== FUNCTION) {
+        throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
+    }
+    function tempFunc() { }
+    tempFunc[PROTOTYPE] = obj;
+    return new tempFunc();
+}
+
+var strIndexOf = _unwrapFunction(INDEX_OF, StrProto);
+
+var REF = "ref";
+var UNREF = "un" + REF;
+var HAS_REF = "hasRef";
+var ENABLED = "enabled";
+function _createTimerHandler(startTimer, refreshFn, cancelFn) {
+    var _a;
+    var ref = true;
+    var timerId = startTimer ? refreshFn(null) : null;
+    var theTimerHandler;
+    var _unref = function () {
+        ref = false;
+        timerId && timerId[UNREF] && timerId[UNREF]();
+        return theTimerHandler;
+    };
+    var _ref = function () {
+        ref = true;
+        timerId && timerId[REF] && timerId[REF]();
+        return theTimerHandler;
+    };
+    var _hasRef = function () {
+        if (timerId && timerId[HAS_REF]) {
+            return timerId[HAS_REF]();
+        }
+        return ref;
+    };
+    var _refresh = function () {
+        timerId = refreshFn(timerId);
+        if (!ref) {
+            _unref();
+        }
+        return theTimerHandler;
+    };
+    var _cancel = function () {
+        timerId && cancelFn(timerId);
+        timerId = null;
+    };
+    var _setEnabled = function (value) {
+        !value && timerId && _cancel();
+        value && !timerId && _refresh();
+    };
+    theTimerHandler = (_a = {
+            cancel: _cancel,
+            refresh: _refresh
+        },
+        _a[HAS_REF] = _hasRef,
+        _a[REF] = _ref,
+        _a[UNREF] = _unref,
+        _a[ENABLED] = false,
+        _a);
+    objDefineProp(theTimerHandler, ENABLED, {
+        get: function () { return !!timerId; },
+        set: _setEnabled
+    });
+    return {
+        h: theTimerHandler,
+        dn: function () {
+            timerId = null;
+        }
+    };
+}
+
+function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
+    var isArr = isArray(overrideFn);
+    var len = isArr ? overrideFn.length : 0;
+    var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;
+    var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;
+    var timerFn = theArgs[0];
+    theArgs[0] = function () {
+        handler.dn();
+        timerFn.apply(self, arguments);
+    };
+    var handler = _createTimerHandler(startTimer, function (timerId) {
+        if (timerId) {
+            if (timerId.refresh) {
+                timerId.refresh();
+                return timerId;
+            }
+            clearFn.call(self, timerId);
+        }
+        return setFn.apply(self, theArgs);
+    }, function (timerId) {
+        clearFn.call(self, timerId);
+    });
+    return handler.h;
+}
+function scheduleTimeout(callback, timeout) {
+    return _createTimeoutWith(this, true, UNDEF_VALUE, arrSlice(arguments));
+}
+
+var createEnumStyle = createEnum;
+var createValueMap = createTypeMap;
+
+var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
+var _DYN_LENGTH$1 = "length";
+var _DYN_RD_ONLY = "rdOnly";
+var _DYN_NOTIFY = "notify";
+var _DYN_THROW_INTERNAL = "throwInternal";
+var _DYN_SET_DF = "setDf";
+var _DYN_WATCH = "watch";
+var _DYN_LOGGER = "logger";
+var _DYN_APPLY = "apply";
+var _DYN_PUSH = "push";
+var _DYN_SPLICE = "splice";
+var _DYN_CANCEL = "cancel";
+var _DYN_NAME$1 = "name";
+var _DYN_VERSION = "version";
+var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+var _DYN_MESSAGE_ID = "messageId";
+var _DYN_MESSAGE$1 = "message";
+var _DYN_DIAG_LOG = "diagLog";
+var _DYN_USER_AGENT = "userAgent";
+var _DYN_REPLACE = "replace";
+var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+var _DYN_TRACE_ID = "traceId";
+var _DYN_SPAN_ID = "spanId";
+var _DYN_TRACE_FLAGS = "traceFlags";
+
+var aggregationErrorType;
+function throwAggregationError(message, sourceErrors) {
+    if (!aggregationErrorType) {
+        aggregationErrorType = createCustomError("AggregationError", function (self, args) {
+            if (args[_DYN_LENGTH$1 ] > 1) {
+                self.errors = args[1];
+            }
+        });
+    }
+    var theMessage = message || "One or more errors occurred.";
+    arrForEach(sourceErrors, function (srcError, idx) {
+        theMessage += "\n".concat(idx, " > ").concat(dumpObj(srcError));
+    });
+    throw new aggregationErrorType(theMessage, sourceErrors || []);
+}
+
+var strShimFunction = "function";
+var strShimObject = "object";
+var strShimUndefined = "undefined";
+var strShimPrototype = "prototype";
+var ObjClass = Object;
+var ObjProto = ObjClass[strShimPrototype];
+
+(getGlobal() || {})["Symbol"];
+(getGlobal() || {})["Reflect"];
+var strHasOwnProperty = "hasOwnProperty";
+var __objAssignFnImpl = function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) {
+            if (ObjProto[strHasOwnProperty].call(s, p)) {
+                t[p] = s[p];
+            }
+        }
+    }
+    return t;
+};
+var __assignFn = objAssign || __objAssignFnImpl;
+var extendStaticsFn = function (d, b) {
+    extendStaticsFn = ObjClass["setPrototypeOf"] ||
+        ({ __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        }) ||
+        function (d, b) {
+            for (var p in b) {
+                if (b[strHasOwnProperty](p)) {
+                    d[p] = b[p];
+                }
+            }
+        };
+    return extendStaticsFn(d, b);
+};
+function __extendsFn(d, b) {
+    if (typeof b !== strShimFunction && b !== null) {
+        throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
+    }
+    extendStaticsFn(d, b);
+    function __() {
+        this.constructor = d;
+    }
+    d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
+}
+
+var _a;
+var Constructor = 'constructor';
+var Prototype = 'prototype';
+var strFunction = 'function';
+var DynInstFuncTable = '_dynInstFuncs';
+var DynProxyTag = '_isDynProxy';
+var DynClassName = '_dynClass';
+var DynClassNamePrefix = '_dynCls$';
+var DynInstChkTag = '_dynInstChk';
+var DynAllowInstChkTag = DynInstChkTag;
+var DynProtoDefaultOptions = '_dfOpts';
+var UnknownValue = '_unknown_';
+var str__Proto = "__proto__";
+var DynProtoBaseProto = "_dyn" + str__Proto;
+var DynProtoGlobalSettings = "__dynProto$Gbl";
+var DynProtoCurrent = "_dynInstProto";
+var strUseBaseInst = 'useBaseInst';
+var strSetInstFuncs = 'setInstFuncs';
+var Obj = Object;
+var _objGetPrototypeOf = Obj["getPrototypeOf"];
+var _objGetOwnProps = Obj["getOwnPropertyNames"];
+var _gbl = getGlobal();
+var _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {
+    o: (_a = {},
+        _a[strSetInstFuncs] = true,
+        _a[strUseBaseInst] = true,
+        _a),
+    n: 1000
+});
+function _isObjectOrArrayPrototype(target) {
+    return target && (target === Obj[Prototype] || target === Array[Prototype]);
+}
+function _isObjectArrayOrFunctionPrototype(target) {
+    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+}
+function _getObjProto(target) {
+    var newProto;
+    if (target) {
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
+        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+        newProto = target[DynProtoBaseProto] || curProto;
+        if (!objHasOwnProperty(target, DynProtoBaseProto)) {
+            delete target[DynProtoCurrent];
+            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+            target[DynProtoCurrent] = curProto;
+        }
+    }
+    return newProto;
+}
+function _forEachProp(target, func) {
+    var props = [];
+    if (_objGetOwnProps) {
+        props = _objGetOwnProps(target);
+    }
+    else {
+        for (var name_1 in target) {
+            if (typeof name_1 === "string" && objHasOwnProperty(target, name_1)) {
+                props.push(name_1);
+            }
+        }
+    }
+    if (props && props.length > 0) {
+        for (var lp = 0; lp < props.length; lp++) {
+            func(props[lp]);
+        }
+    }
+}
+function _isDynamicCandidate(target, funcName, skipOwn) {
+    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)));
+}
+function _throwTypeError(message) {
+    throwTypeError("DynamicProto: " + message);
+}
+function _getInstanceFuncs(thisTarget) {
+    var instFuncs = {};
+    _forEachProp(thisTarget, function (name) {
+        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+            instFuncs[name] = thisTarget[name];
+        }
+    });
+    return instFuncs;
+}
+function _hasVisited(values, value) {
+    for (var lp = values.length - 1; lp >= 0; lp--) {
+        if (values[lp] === value) {
+            return true;
+        }
+    }
+    return false;
+}
+function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+    function _instFuncProxy(target, funcHost, funcName) {
+        var theFunc = funcHost[funcName];
+        if (theFunc[DynProxyTag] && useBaseInst) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
+            }
+        }
+        return function () {
+            return theFunc.apply(target, arguments);
+        };
+    }
+    var baseFuncs = {};
+    _forEachProp(instFuncs, function (name) {
+        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+    });
+    var baseProto = _getObjProto(classProto);
+    var visited = [];
+    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+        _forEachProp(baseProto, function (name) {
+            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+            }
+        });
+        visited.push(baseProto);
+        baseProto = _getObjProto(baseProto);
+    }
+    return baseFuncs;
+}
+function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+    var instFunc = null;
+    if (target && objHasOwnProperty(proto, DynClassName)) {
+        var instFuncTable = target[DynInstFuncTable] || {};
+        instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+        if (!instFunc) {
+            _throwTypeError("Missing [" + funcName + "] " + strFunction);
+        }
+        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+            var canAddInst = !objHasOwnProperty(target, funcName);
+            var objProto = _getObjProto(target);
+            var visited = [];
+            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                var protoFunc = objProto[funcName];
+                if (protoFunc) {
+                    canAddInst = (protoFunc === currentDynProtoProxy);
+                    break;
+                }
+                visited.push(objProto);
+                objProto = _getObjProto(objProto);
+            }
+            try {
+                if (canAddInst) {
+                    target[funcName] = instFunc;
+                }
+                instFunc[DynInstChkTag] = 1;
+            }
+            catch (e) {
+                instFuncTable[DynAllowInstChkTag] = false;
+            }
+        }
+    }
+    return instFunc;
+}
+function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+    var protoFunc = proto[funcName];
+    if (protoFunc === currentDynProtoProxy) {
+        protoFunc = _getObjProto(proto)[funcName];
+    }
+    if (typeof protoFunc !== strFunction) {
+        _throwTypeError("[" + funcName + "] is not a " + strFunction);
+    }
+    return protoFunc;
+}
+function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+    function _createDynamicPrototype(proto, funcName) {
+        var dynProtoProxy = function () {
+            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+            return instFunc.apply(this, arguments);
+        };
+        dynProtoProxy[DynProxyTag] = 1;
+        return dynProtoProxy;
+    }
+    if (!_isObjectOrArrayPrototype(proto)) {
+        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+        var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+        if (instFuncTable[DynAllowInstChkTag] !== false) {
+            instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+        }
+        _forEachProp(target, function (name) {
+            if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                instFuncs_1[name] = target[name];
+                delete target[name];
+                if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                    proto[name] = _createDynamicPrototype(proto, name);
+                }
+            }
+        });
+    }
+}
+function _checkPrototype(classProto, thisTarget) {
+    if (_objGetPrototypeOf) {
+        var visited = [];
+        var thisProto = _getObjProto(thisTarget);
+        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+            if (thisProto === classProto) {
+                return true;
+            }
+            visited.push(thisProto);
+            thisProto = _getObjProto(thisProto);
+        }
+        return false;
+    }
+    return true;
+}
+function _getObjName(target, unknownValue) {
+    if (objHasOwnProperty(target, Prototype)) {
+        return target.name || unknownValue || UnknownValue;
+    }
+    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+}
+function dynamicProto(theClass, target, delegateFunc, options) {
+    if (!objHasOwnProperty(theClass, Prototype)) {
+        _throwTypeError("theClass is an invalid class definition.");
+    }
+    var classProto = theClass[Prototype];
+    if (!_checkPrototype(classProto, target)) {
+        _throwTypeError("[" + _getObjName(theClass) + "] not in hierarchy of [" + _getObjName(target) + "]");
+    }
+    var className = null;
+    if (objHasOwnProperty(classProto, DynClassName)) {
+        className = classProto[DynClassName];
+    }
+    else {
+        className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _gblInst.n;
+        _gblInst.n++;
+        classProto[DynClassName] = className;
+    }
+    var perfOptions = dynamicProto[DynProtoDefaultOptions];
+    var useBaseInst = !!perfOptions[strUseBaseInst];
+    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+        useBaseInst = !!options[strUseBaseInst];
+    }
+    var instFuncs = _getInstanceFuncs(target);
+    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+    delegateFunc(target, baseFuncs);
+    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
+    if (setInstanceFunc && options) {
+        setInstanceFunc = !!options[strSetInstFuncs];
+    }
+    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+}
+dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
+
+var UNDEFINED_VALUE = undefined;
+var STR_EMPTY = "";
+var STR_ERROR_TO_CONSOLE = "errorToConsole";
+var STR_WARN_TO_CONSOLE = "warnToConsole";
+var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
+
+var rCamelCase = /-([a-z])/g;
+var rNormalizeInvalid = /([^\w\d_$])/g;
+var rLeadingNumeric = /^(\d+[\w\d_$])/;
+function isNotNullOrUndefined(value) {
+    return !isNullOrUndefined(value);
+}
+function normalizeJsName(name) {
+    var value = name;
+    if (value && isString(value)) {
+        value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
+            return letter.toUpperCase();
+        });
+        value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
+        value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
+            return "_" + match;
+        });
+    }
+    return value;
+}
+function strContains(value, search) {
+    if (value && search) {
+        return strIndexOf(value, search) !== -1;
+    }
+    return false;
+}
+function toISOString(date) {
+    return date && date.toISOString() || "";
+}
+function getExceptionName(object) {
+    if (isError(object)) {
+        return object[_DYN_NAME$1 ];
+    }
+    return STR_EMPTY;
+}
+function createClassFromInterface(defaults) {
+    return /** @class */ (function () {
+        function class_1() {
+            var _this = this;
+            if (defaults) {
+                objForEachKey(defaults, function (field, value) {
+                    _this[field] = value;
+                });
+            }
+        }
+        return class_1;
+    }());
+}
+
+var strConsole = "console";
+var strJSON = "JSON";
+var strCrypto = "crypto";
+var strMsCrypto = "msCrypto";
+var strMsie = "msie";
+var strTrident = "trident/";
+var _isTrident = null;
+var _navUserAgentCheck = null;
+var _beaconsSupported = null;
+function getConsole() {
+    if (typeof console !== strShimUndefined) {
+        return console;
+    }
+    return getInst(strConsole);
+}
+function hasJSON() {
+    return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
+}
+function getJSON() {
+    if (hasJSON()) {
+        return JSON || getInst(strJSON);
+    }
+    return null;
+}
+function getCrypto() {
+    return getInst(strCrypto);
+}
+function getMsCrypto() {
+    return getInst(strMsCrypto);
+}
+function isIE() {
+    var nav = getNavigator();
+    if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+        _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+        var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    }
+    return _isTrident;
+}
+function isBeaconsSupported() {
+    if (_beaconsSupported === null) {
+        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
+    }
+    return _beaconsSupported;
+}
+function _getNamedValue(values, name) {
+    if (values) {
+        for (var i = 0; i < values[_DYN_LENGTH$1 ]; i++) {
+            var value = values[i];
+            if (value[_DYN_NAME$1 ]) {
+                if (value[_DYN_NAME$1 ] === name) {
+                    return value;
+                }
+            }
+        }
+    }
+    return {};
+}
+function findMetaTag(name) {
+    var doc = getDocument();
+    if (doc && name) {
+        return _getNamedValue(doc.querySelectorAll("meta"), name).content;
+    }
+    return null;
+}
+function findNamedServerTiming(name) {
+    var value;
+    var perf = getPerformance();
+    if (perf) {
+        var navPerf = perf.getEntriesByType("navigation") || [];
+        value = _getNamedValue((navPerf[_DYN_LENGTH$1 ] > 0 ? navPerf[0] : {}).serverTiming, name).description;
+    }
+    return value;
+}
+
+var UInt32Mask = 0x100000000;
+var MaxUInt32 = 0xffffffff;
+var SEED1 = 123456789;
+var SEED2 = 987654321;
+var _mwcSeeded = false;
+var _mwcW = SEED1;
+var _mwcZ = SEED2;
+function _mwcSeed(seedValue) {
+    if (seedValue < 0) {
+        seedValue >>>= 0;
+    }
+    _mwcW = (SEED1 + seedValue) & MaxUInt32;
+    _mwcZ = (SEED2 - seedValue) & MaxUInt32;
+    _mwcSeeded = true;
+}
+function _autoSeedMwc() {
+    try {
+        var now = utcNow() & 0x7fffffff;
+        _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+    }
+    catch (e) {
+    }
+}
+function 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 mwcRandom32(signed) {
+    _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;
+    _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;
+    var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;
+    if (!signed) {
+        value >>>= 0;
+    }
+    return value;
+}
+function newId(maxLength) {
+    if (maxLength === void 0) { maxLength = 22; }
+    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var number = random32() >>> 0;
+    var chars = 0;
+    var result = STR_EMPTY;
+    while (result[_DYN_LENGTH$1 ] < maxLength) {
+        chars++;
+        result += base64chars.charAt(number & 0x3F);
+        number >>>= 6;
+        if (chars === 5) {
+            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+            chars = 0;
+        }
+    }
+    return result;
+}
+
+var version = "3.0.0-nightly3.2304-28";
+var instanceName = "." + newId(6);
+var _dataUid = 0;
+function createUniqueNamespace(name, includeVersion) {
+    if (includeVersion === void 0) { includeVersion = false; }
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+}
+
+function _isConfigDefaults(value) {
+    return (value && isObject(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
+}
+function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
+    var defValue;
+    var isDefaultValid = cfgDefaults.dfVal || isDefined;
+    if (theConfig && cfgDefaults.fb) {
+        var fallbacks = cfgDefaults.fb;
+        if (!isArray(fallbacks)) {
+            fallbacks = [fallbacks];
+        }
+        for (var lp = 0; lp < fallbacks[_DYN_LENGTH$1 ]; lp++) {
+            var fallback = fallbacks[lp];
+            var fbValue = theConfig[fallback];
+            if (isDefaultValid(fbValue)) {
+                defValue = fbValue;
+            }
+            else if (dynamicHandler) {
+                fbValue = dynamicHandler.cfg[fallback];
+                if (isDefaultValid(fbValue)) {
+                    defValue = fbValue;
+                }
+                dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);
+            }
+            if (isDefaultValid(defValue)) {
+                break;
+            }
+        }
+    }
+    if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {
+        defValue = cfgDefaults.v;
+    }
+    return defValue;
+}
+function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
+    var theValue = cfgDefaults;
+    if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
+        theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    if (theValue) {
+        if (_isConfigDefaults(theValue)) {
+            theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
+        }
+        var newValue_1;
+        if (isArray(theValue)) {
+            newValue_1 = [];
+            newValue_1[_DYN_LENGTH$1 ] = theValue[_DYN_LENGTH$1 ];
+        }
+        else if (isPlainObject(theValue)) {
+            newValue_1 = {};
+        }
+        if (newValue_1) {
+            objForEachKey(theValue, function (key, value) {
+                if (value && _isConfigDefaults(value)) {
+                    value = _resolveDefaultValue(dynamicHandler, theConfig, value);
+                }
+                newValue_1[key] = value;
+            });
+            theValue = newValue_1;
+        }
+    }
+    return theValue;
+}
+function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
+    var isValid;
+    var setFn;
+    var defValue;
+    var cfgDefaults = defaultValue;
+    var mergeDf;
+    var reference;
+    var readOnly;
+    if (_isConfigDefaults(cfgDefaults)) {
+        isValid = cfgDefaults.isVal;
+        setFn = cfgDefaults.set;
+        readOnly = cfgDefaults[_DYN_RD_ONLY ];
+        mergeDf = cfgDefaults.mrg;
+        reference = cfgDefaults.ref;
+        if (!reference && isUndefined(reference)) {
+            reference = !!mergeDf;
+        }
+        defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+    }
+    else {
+        defValue = defaultValue;
+    }
+    var theValue;
+    var usingDefault = true;
+    var cfgValue = theConfig[name];
+    if (cfgValue || !isNullOrUndefined(cfgValue)) {
+        theValue = cfgValue;
+        usingDefault = false;
+        if (isValid && theValue !== defValue && !isValid(theValue)) {
+            theValue = defValue;
+            usingDefault = true;
+        }
+        if (setFn) {
+            theValue = setFn(theValue, defValue, theConfig);
+            usingDefault = theValue === defValue;
+        }
+    }
+    if (!usingDefault) {
+        if (isPlainObject(theValue) || isArray(defValue)) {
+            if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {
+                objForEachKey(defValue, function (dfName, dfValue) {
+                    _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
+                });
+            }
+        }
+    }
+    else if (defValue) {
+        theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
+    }
+    else {
+        theValue = defValue;
+    }
+    dynamicHandler.set(theConfig, name, theValue);
+    if (reference) {
+        dynamicHandler.ref(theConfig, name);
+    }
+    if (readOnly) {
+        dynamicHandler[_DYN_RD_ONLY ](theConfig, name);
+    }
+}
+
+var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+var BLOCK_DYNAMIC = symbolFor("[[ai_blkDynCfg_1]]");
+var FORCE_DYNAMIC = symbolFor("[[ai_frcDynCfg_1]]");
+function _cfgDeepCopy(source) {
+    if (source) {
+        var target_1;
+        if (isArray(source)) {
+            target_1 = [];
+            target_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
+        }
+        else if (isPlainObject(source)) {
+            target_1 = {};
+        }
+        if (target_1) {
+            objForEachKey(source, function (key, value) {
+                target_1[key] = _cfgDeepCopy(value);
+            });
+            return target_1;
+        }
+    }
+    return source;
+}
+function getDynamicConfigHandler(value) {
+    if (value) {
+        var handler = value[CFG_HANDLER_LINK] || value;
+        if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler;
+        }
+    }
+    return null;
+}
+function _canMakeDynamic(value) {
+    var result = false;
+    if (value) {
+        result = value[FORCE_DYNAMIC];
+        if (!result && !value[BLOCK_DYNAMIC]) {
+            result = isPlainObject(value) || isArray(value);
+        }
+    }
+    return result;
+}
+function throwInvalidAccess(message) {
+    throwTypeError("InvalidAccess:" + message);
+}
+
+var arrayMethodsToPatch = [
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice"
+];
+function _patchArray(state, target) {
+    if (isArray(target)) {
+        arrForEach(arrayMethodsToPatch, function (method) {
+            var orgMethod = target[method];
+            target[method] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var result = orgMethod[_DYN_APPLY ](this, args);
+                _makeDynamicObject(state, target);
+                return result;
+            };
+        });
+    }
+}
+function _getOwnPropGetter(target, name) {
+    var propDesc = objGetOwnPropertyDescriptor(target, name);
+    return propDesc && propDesc.get;
+}
+function _makeDynamicProperty(state, theConfig, name, value) {
+    var detail = {
+        n: name,
+        h: [],
+        trk: function (handler) {
+            if (handler && handler.fn) {
+                if (arrIndexOf(detail.h, handler) === -1) {
+                    detail.h[_DYN_PUSH ](handler);
+                }
+                state.trk(handler, detail);
+            }
+        },
+        clr: function (handler) {
+            var idx = arrIndexOf(detail.h, handler);
+            if (idx !== -1) {
+                detail.h[_DYN_SPLICE ](idx, 1);
+            }
+        }
+    };
+    var checkDynamic = true;
+    var isObjectOrArray = false;
+    function _getProperty() {
+        if (checkDynamic) {
+            isObjectOrArray = isObjectOrArray || _canMakeDynamic(value);
+            if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {
+                value = _makeDynamicObject(state, value);
+            }
+            checkDynamic = false;
+        }
+        var activeHandler = state.act;
+        if (activeHandler) {
+            detail.trk(activeHandler);
+        }
+        return value;
+    }
+    _getProperty[state.prop] = {
+        chng: function () {
+            state.add(detail);
+        }
+    };
+    function _setProperty(newValue) {
+        if (value !== newValue) {
+            if (!!_getProperty[state.ro] && !state.upd) {
+                throwInvalidAccess("[" + name + "] is read-only:" + dumpObj(theConfig));
+            }
+            if (checkDynamic) {
+                isObjectOrArray = isObjectOrArray || _canMakeDynamic(value);
+                checkDynamic = false;
+            }
+            var isReferenced = isObjectOrArray && _getProperty[state.rf];
+            if (isObjectOrArray) {
+                if (isReferenced) {
+                    objForEachKey(value, function (key) {
+                        value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;
+                    });
+                    objForEachKey(newValue, function (key, theValue) {
+                        _setDynamicProperty(state, value, key, theValue);
+                    });
+                    newValue = value;
+                }
+                else if (value && value[CFG_HANDLER_LINK]) {
+                    objForEachKey(value, function (key) {
+                        var getter = _getOwnPropGetter(value, key);
+                        if (getter) {
+                            var valueState = getter[state.prop];
+                            valueState && valueState.chng();
+                        }
+                    });
+                }
+            }
+            if (newValue !== value) {
+                var newIsObjectOrArray = newValue && _canMakeDynamic(newValue);
+                if (!isReferenced && newIsObjectOrArray) {
+                    _makeDynamicObject(state, newValue);
+                }
+                value = newValue;
+                isObjectOrArray = newIsObjectOrArray;
+            }
+            state.add(detail);
+        }
+    }
+    objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });
+}
+function _setDynamicProperty(state, target, name, value, inPlace, rdOnly) {
+    if (target) {
+        var getter = _getOwnPropGetter(target, name);
+        var isDynamic = getter && !!getter[state.prop];
+        if (!isDynamic) {
+            _makeDynamicProperty(state, target, name, value);
+            if (inPlace || rdOnly) {
+                getter = _getOwnPropGetter(target, name);
+            }
+        }
+        else {
+            target[name] = value;
+        }
+        if (inPlace) {
+            getter[state.rf] = inPlace;
+        }
+        if (rdOnly) {
+            getter[state.ro] = rdOnly;
+        }
+    }
+    return target;
+}
+function _makeDynamicObject(state, target) {
+    objForEachKey(target, function (key, value) {
+        _setDynamicProperty(state, target, key, value);
+    });
+    if (!target[CFG_HANDLER_LINK]) {
+        objDefineProp(target, CFG_HANDLER_LINK, {
+            get: function () {
+                return state.hdlr;
+            }
+        });
+        _patchArray(state, target);
+    }
+    return target;
+}
+
+var symPrefix = "[[ai_";
+var symPostfix = "]]";
+function _createState(cfgHandler) {
+    var _a;
+    var dynamicPropertySymbol = newSymbol(symPrefix + "get" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyReadOnly = newSymbol(symPrefix + "ro" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyReferenced = newSymbol(symPrefix + "rf" + cfgHandler.uid + symPostfix);
+    var dynamicPropertyDetail = newSymbol(symPrefix + "dtl" + cfgHandler.uid + symPostfix);
+    var _waitingHandlers = null;
+    var _watcherTimer = null;
+    var theState;
+    function _useHandler(activeHandler, callback) {
+        var prevWatcher = theState.act;
+        try {
+            theState.act = activeHandler;
+            if (activeHandler && activeHandler[dynamicPropertyDetail]) {
+                arrForEach(activeHandler[dynamicPropertyDetail], function (detail) {
+                    detail.clr(activeHandler);
+                });
+                activeHandler[dynamicPropertyDetail] = [];
+            }
+            callback({
+                cfg: cfgHandler.cfg,
+                set: cfgHandler.set.bind(cfgHandler),
+                setDf: cfgHandler[_DYN_SET_DF ].bind(cfgHandler),
+                ref: cfgHandler.ref.bind(cfgHandler),
+                rdOnly: cfgHandler[_DYN_RD_ONLY ].bind(cfgHandler)
+            });
+        }
+        catch (e) {
+            var logger = cfgHandler[_DYN_LOGGER ];
+            if (logger) {
+                logger[_DYN_THROW_INTERNAL ](1 , 107 , dumpObj(e));
+            }
+            throw e;
+        }
+        finally {
+            theState.act = prevWatcher || null;
+        }
+    }
+    function _notifyWatchers() {
+        if (_waitingHandlers) {
+            var notifyHandlers = _waitingHandlers;
+            _waitingHandlers = null;
+            _watcherTimer && _watcherTimer[_DYN_CANCEL ]();
+            _watcherTimer = null;
+            var watcherFailures_1 = [];
+            arrForEach(notifyHandlers, function (handler) {
+                if (handler) {
+                    if (handler[dynamicPropertyDetail]) {
+                        arrForEach(handler[dynamicPropertyDetail], function (detail) {
+                            detail.clr(handler);
+                        });
+                        handler[dynamicPropertyDetail] = null;
+                    }
+                    if (handler.fn) {
+                        try {
+                            _useHandler(handler, handler.fn);
+                        }
+                        catch (e) {
+                            watcherFailures_1[_DYN_PUSH ](e);
+                        }
+                    }
+                }
+            });
+            if (_waitingHandlers) {
+                try {
+                    _notifyWatchers();
+                }
+                catch (e) {
+                    watcherFailures_1[_DYN_PUSH ](e);
+                }
+            }
+            if (watcherFailures_1[_DYN_LENGTH$1 ] > 0) {
+                throwAggregationError("Watcher error(s): ", watcherFailures_1);
+            }
+        }
+    }
+    function _addWatcher(detail) {
+        if (detail && detail.h[_DYN_LENGTH$1 ] > 0) {
+            if (!_waitingHandlers) {
+                _waitingHandlers = [];
+            }
+            if (!_watcherTimer) {
+                _watcherTimer = scheduleTimeout(function () {
+                    _watcherTimer = null;
+                    _notifyWatchers();
+                }, 0);
+            }
+            for (var idx = 0; idx < detail.h[_DYN_LENGTH$1 ]; idx++) {
+                var handler = detail.h[idx];
+                if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
+                    _waitingHandlers[_DYN_PUSH ](handler);
+                }
+            }
+        }
+    }
+    function _trackHandler(handler, detail) {
+        if (handler) {
+            var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
+            if (arrIndexOf(details, detail) === -1) {
+                details[_DYN_PUSH ](detail);
+            }
+        }
+    }
+    theState = (_a = {
+            prop: dynamicPropertySymbol,
+            ro: dynamicPropertyReadOnly,
+            rf: dynamicPropertyReferenced,
+            hdlr: cfgHandler,
+            add: _addWatcher
+        },
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.use = _useHandler,
+        _a.trk = _trackHandler,
+        _a);
+    return theState;
+}
+
+function _createAndUseHandler(state, configHandler) {
+    var handler = {
+        fn: configHandler,
+        rm: function () {
+            handler.fn = null;
+            state = null;
+            configHandler = null;
+        }
+    };
+    state.use(handler, configHandler);
+    return handler;
+}
+function _createDynamicHandler(logger, target, inPlace) {
+    var _a;
+    var dynamicHandler = getDynamicConfigHandler(target);
+    if (dynamicHandler) {
+        return dynamicHandler;
+    }
+    var uid = createUniqueNamespace("dyncfg", true);
+    var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+    var theState;
+    function _notifyWatchers() {
+        theState[_DYN_NOTIFY ]();
+    }
+    function _setValue(target, name, value) {
+        return _setDynamicProperty(theState, target, name, value)[name];
+    }
+    function _watch(configHandler) {
+        return _createAndUseHandler(theState, configHandler);
+    }
+    function _block(configHandler, allowUpdate) {
+        theState.use(null, function (details) {
+            var prevUpd = theState.upd;
+            try {
+                if (!isUndefined(allowUpdate)) {
+                    theState.upd = allowUpdate;
+                }
+                configHandler(details);
+            }
+            finally {
+                theState.upd = prevUpd;
+            }
+        });
+    }
+    function _ref(target, name) {
+        return _setDynamicProperty(theState, target, name, target[name], true)[name];
+    }
+    function _rdOnly(target, name) {
+        return _setDynamicProperty(theState, target, name, target[name], false, true)[name];
+    }
+    function _applyDefaults(theConfig, defaultValues) {
+        if (defaultValues) {
+            objForEachKey(defaultValues, function (name, value) {
+                _applyDefaultValue(cfgHandler, theConfig, name, value);
+            });
+        }
+        return theConfig;
+    }
+    var cfgHandler = (_a = {
+            uid: null,
+            cfg: newTarget
+        },
+        _a[_DYN_LOGGER ] = logger,
+        _a[_DYN_NOTIFY ] = _notifyWatchers,
+        _a.set = _setValue,
+        _a[_DYN_SET_DF ] = _applyDefaults,
+        _a[_DYN_WATCH ] = _watch,
+        _a.ref = _ref,
+        _a[_DYN_RD_ONLY ] = _rdOnly,
+        _a._block = _block,
+        _a);
+    objDefine(cfgHandler, "uid", {
+        c: false,
+        e: false,
+        w: false,
+        v: uid
+    });
+    theState = _createState(cfgHandler);
+    _makeDynamicObject(theState, newTarget);
+    return cfgHandler;
+}
+function _logInvalidAccess(logger, message) {
+    if (logger) {
+        logger[STR_WARN_TO_CONSOLE ](message);
+        logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+    }
+    else {
+        throwInvalidAccess(message);
+    }
+}
+function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+    var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+    if (defaultConfig) {
+        dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
+    }
+    return dynamicHandler;
+}
+function onConfigChange(config, configHandler, logger) {
+    var handler = config[CFG_HANDLER_LINK] || config;
+    if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+        return handler[_DYN_WATCH ](configHandler);
+    }
+    _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+    createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+}
+
+var _aiNamespace = null;
+function _getExtensionNamespace() {
+    var target = getInst("Microsoft");
+    if (target) {
+        _aiNamespace = target["ApplicationInsights"];
+    }
+    return _aiNamespace;
+}
+function getDebugExt(config) {
+    var ns = _aiNamespace;
+    if (!ns && config.disableDbgExt !== true) {
+        ns = _aiNamespace || _getExtensionNamespace();
+    }
+    return ns ? ns["ChromeDbgExt"] : null;
+}
+
+var AiNonUserActionablePrefix = "AI (Internal): ";
+var AiUserActionablePrefix = "AI: ";
+var AIInternalMessagePrefix = "AITR_";
+var defaultValues = {
+    loggingLevelConsole: 0,
+    loggingLevelTelemetry: 1,
+    maxMessageLimit: 25,
+    enableDebug: false
+};
+function _sanitizeDiagnosticText(text) {
+    if (text) {
+        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
+    }
+    return STR_EMPTY;
+}
+function _logToConsole(func, message) {
+    var theConsole = getConsole();
+    if (!!theConsole) {
+        var logFunc = "log";
+        if (theConsole[func]) {
+            logFunc = func;
+        }
+        if (isFunction(theConsole[logFunc])) {
+            theConsole[logFunc](message);
+        }
+    }
+}
+var _InternalLogMessage = /** @class */ (function () {
+    function _InternalLogMessage(msgId, msg, isUserAct, properties) {
+        if (isUserAct === void 0) { isUserAct = false; }
+        var _self = this;
+        _self[_DYN_MESSAGE_ID ] = msgId;
+        _self[_DYN_MESSAGE$1 ] =
+            (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$1 ] += diagnosticText;
+    }
+    _InternalLogMessage.dataType = "MessageData";
+    return _InternalLogMessage;
+}());
+function safeGetLogger(core, config) {
+    return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
+}
+var DiagnosticLogger = /** @class */ (function () {
+    function DiagnosticLogger(config) {
+        this.identifier = "DiagnosticLogger";
+        this.queue = [];
+        var _messageCount = 0;
+        var _messageLogged = {};
+        var _loggingLevelConsole;
+        var _loggingLevelTelemetry;
+        var _maxInternalMessageLimit;
+        var _enableDebug;
+        dynamicProto(DiagnosticLogger, this, function (_self) {
+            _setDefaultsFromConfig(config || {});
+            _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+            _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
+                if (isUserAct === void 0) { isUserAct = false; }
+                var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
+                if (_enableDebug) {
+                    throw dumpObj(message);
+                }
+                else {
+                    var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
+                    if (!isUndefined(message[_DYN_MESSAGE$1 ])) {
+                        if (isUserAct) {
+                            var messageKey = +message[_DYN_MESSAGE_ID ];
+                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                                _messageLogged[messageKey] = true;
+                            }
+                        }
+                        else {
+                            if (_loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                            }
+                        }
+                        _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) {
+                var handler = createDynamicConfig(config, defaultValues, _self);
+                handler[_DYN_WATCH ](function (details) {
+                    var config = details.cfg;
+                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                    _maxInternalMessageLimit = config.maxMessageLimit;
+                    _enableDebug = config.enableDebug;
+                });
+            }
+            function _areInternalMessagesThrottled() {
+                return _messageCount >= _maxInternalMessageLimit;
+            }
+            function _debugExtMsg(name, data) {
+                var dbgExt = getDebugExt(config || {});
+                if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
+                    dbgExt[_DYN_DIAG_LOG ](name, data);
+                }
+            }
+        });
+    }
+    DiagnosticLogger.__ieDyn=1;
+    return DiagnosticLogger;
+}());
+function _getLogger(logger) {
+    return (logger || new DiagnosticLogger());
+}
+function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
+    if (isUserAct === void 0) { isUserAct = false; }
+    _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
+}
+
+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 strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi + strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
+}
+
+var TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]{1,64})?$/i;
+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$1 ] === len && value !== invalidValue) {
+        return !!value.match(/^[\da-f]*$/i);
+    }
+    return false;
+}
+function _formatValue(value, len, defValue) {
+    if (_isValid(value, len)) {
+        return value;
+    }
+    return defValue;
+}
+function _formatFlags(value) {
+    if (isNaN(value) || value < 0 || value > 255) {
+        value = 0x01;
+    }
+    var result = value.toString(16);
+    while (result[_DYN_LENGTH$1 ] < 2) {
+        result = "0" + result;
+    }
+    return result;
+}
+function createTraceParent(traceId, spanId, flags, version) {
+    var _a;
+    return _a = {},
+        _a[_DYN_VERSION ] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+        _a[_DYN_TRACE_ID ] = isValidTraceId(traceId) ? traceId : generateW3CId(),
+        _a[_DYN_SPAN_ID ] = isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),
+        _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,
+        _a;
+}
+function parseTraceParent(value) {
+    var _a;
+    if (!value) {
+        return null;
+    }
+    if (isArray(value)) {
+        value = value[0] || "";
+    }
+    if (!value || !isString(value) || value[_DYN_LENGTH$1 ] > 8192) {
+        return null;
+    }
+    var match = TRACE_PARENT_REGEX.exec(strTrim(value));
+    if (!match ||
+        match[1] === INVALID_VERSION ||
+        match[2] === INVALID_TRACE_ID ||
+        match[3] === INVALID_SPAN_ID) {
+        return null;
+    }
+    return _a = {
+            version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+            traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
+            spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]()
+        },
+        _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
+        _a;
+}
+function isValidTraceId(value) {
+    return _isValid(value, 32, INVALID_TRACE_ID);
+}
+function isValidSpanId(value) {
+    return _isValid(value, 16, INVALID_SPAN_ID);
+}
+function isValidTraceParent(value) {
+    if (!value ||
+        !_isValid(value[_DYN_VERSION ], 2, INVALID_VERSION) ||
+        !_isValid(value[_DYN_TRACE_ID ], 32, INVALID_TRACE_ID) ||
+        !_isValid(value[_DYN_SPAN_ID ], 16, INVALID_SPAN_ID) ||
+        !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS ]), 2)) {
+        return false;
+    }
+    return true;
+}
+function isSampledFlag(value) {
+    if (isValidTraceParent(value)) {
+        return (value[_DYN_TRACE_FLAGS ] & SAMPLED_FLAG) === SAMPLED_FLAG;
+    }
+    return false;
+}
+function formatTraceParent(value) {
+    if (value) {
+        var flags = _formatFlags(value[_DYN_TRACE_FLAGS ]);
+        if (!_isValid(flags, 2)) {
+            flags = "01";
+        }
+        var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
+        if (version !== "00" && version !== "ff") {
+            version = DEFAULT_VERSION;
+        }
+        return "".concat(version.toLowerCase(), "-").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), "-").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), "-").concat(flags.toLowerCase());
+    }
+    return "";
+}
+function findW3cTraceParent() {
+    var name = "traceparent";
+    var traceParent = parseTraceParent(findMetaTag(name));
+    if (!traceParent) {
+        traceParent = parseTraceParent(findNamedServerTiming(name));
+    }
+    return traceParent;
+}
+
+function createUnloadHookContainer() {
+    var _hooks = [];
+    function _doUnload(logger) {
+        var oldHooks = _hooks;
+        _hooks = [];
+        arrForEach(oldHooks, function (fn) {
+            try {
+                (fn.rm || fn.remove).call(fn);
+            }
+            catch (e) {
+                _throwInternal(logger, 2 , 73 , "Unloading:" + dumpObj(e));
+            }
+        });
+    }
+    function _addHook(hooks) {
+        if (hooks) {
+            arrAppend(_hooks, hooks);
+        }
+    }
+    return {
+        run: _doUnload,
+        add: _addHook
+    };
+}
+
+var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+var SampleRate = "sampleRate";
+var ProcessLegacy = "ProcessLegacy";
+var HttpMethod = "http.method";
+var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
+var DEFAULT_BREEZE_PATH = "/v2/track";
+var strNotSpecified = "not_specified";
+var strIkey = "iKey";
+
+var RequestHeaders = createValueMap({
+    requestContextHeader: [0 , "Request-Context"],
+    requestContextTargetKey: [1 , "appId"],
+    requestContextAppIdFormat: [2 , "appId=cid-v1:"],
+    requestIdHeader: [3 , "Request-Id"],
+    traceParentHeader: [4 , "traceparent"],
+    traceStateHeader: [5 , "tracestate"],
+    sdkContextHeader: [6 , "Sdk-Context"],
+    sdkContextHeaderAppIdRequest: [7 , "appId"],
+    requestContextHeaderLowerCase: [8 , "request-context"]
+});
+
+var _DYN_SPLIT = "split";
+var _DYN_LENGTH = "length";
+var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
+var _DYN_TO_STRING = "toString";
+var _DYN_REMOVE_ITEM = "removeItem";
+var _DYN_NAME = "name";
+var _DYN_MESSAGE = "message";
+var _DYN_COUNT = "count";
+var _DYN_PRE_TRIGGER_DATE = "preTriggerDate";
+var _DYN_DISABLED = "disabled";
+var _DYN_INTERVAL = "interval";
+var _DYN_DAYS_OF_MONTH = "daysOfMonth";
+var _DYN_DATE = "date";
+var _DYN_GET_UTCDATE = "getUTCDate";
+var _DYN_STRINGIFY = "stringify";
+var _DYN_PATHNAME = "pathname";
+var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
+var _DYN_EXTENSION_CONFIG = "extensionConfig";
+var _DYN_EXCEPTIONS = "exceptions";
+var _DYN_PARSED_STACK = "parsedStack";
+var _DYN_PROPERTIES = "properties";
+var _DYN_MEASUREMENTS = "measurements";
+var _DYN_SIZE_IN_BYTES = "sizeInBytes";
+var _DYN_TYPE_NAME = "typeName";
+var _DYN_SEVERITY_LEVEL = "severityLevel";
+var _DYN_PROBLEM_GROUP = "problemGroup";
+var _DYN_IS_MANUAL = "isManual";
+var _DYN__CREATE_FROM_INTERFA1 = "CreateFromInterface";
+var _DYN_ASSEMBLY = "assembly";
+var _DYN_HAS_FULL_STACK = "hasFullStack";
+var _DYN_LEVEL = "level";
+var _DYN_METHOD = "method";
+var _DYN_FILE_NAME = "fileName";
+var _DYN_LINE = "line";
+var _DYN_DURATION = "duration";
+var _DYN_RECEIVED_RESPONSE = "receivedResponse";
+var _DYN_SUBSTRING = "substring";
+
+function dataSanitizeKeyAndAddUniqueness(logger, key, map) {
+    var origLength = key[_DYN_LENGTH ];
+    var field = dataSanitizeKey(logger, key);
+    if (field[_DYN_LENGTH ] !== origLength) {
+        var i = 0;
+        var uniqueField = field;
+        while (map[uniqueField] !== undefined) {
+            i++;
+            uniqueField = field[_DYN_SUBSTRING ](0, 150  - 3) + dsPadNumber(i);
+        }
+        field = uniqueField;
+    }
+    return field;
+}
+function dataSanitizeKey(logger, name) {
+    var nameTrunc;
+    if (name) {
+        name = strTrim(name[_DYN_TO_STRING ]());
+        if (name[_DYN_LENGTH ] > 150 ) {
+            nameTrunc = name[_DYN_SUBSTRING ](0, 150 );
+            _throwInternal(logger, 2 , 57 , "name is too long.  It has been truncated to " + 150  + " characters.", { name: name }, true);
+        }
+    }
+    return nameTrunc || name;
+}
+function dataSanitizeString(logger, value, maxLength) {
+    if (maxLength === void 0) { maxLength = 1024 ; }
+    var valueTrunc;
+    if (value) {
+        maxLength = maxLength ? maxLength : 1024 ;
+        value = strTrim(value[_DYN_TO_STRING ]());
+        if (value[_DYN_LENGTH ] > maxLength) {
+            valueTrunc = value[_DYN_SUBSTRING ](0, maxLength);
+            _throwInternal(logger, 2 , 61 , "string value is too long. It has been truncated to " + maxLength + " characters.", { value: value }, true);
+        }
+    }
+    return valueTrunc || value;
+}
+function dataSanitizeUrl(logger, url) {
+    return dataSanitizeInput(logger, url, 2048 , 66 );
+}
+function dataSanitizeMessage(logger, message) {
+    var messageTrunc;
+    if (message) {
+        if (message[_DYN_LENGTH ] > 32768 ) {
+            messageTrunc = message[_DYN_SUBSTRING ](0, 32768 );
+            _throwInternal(logger, 2 , 56 , "message is too long, it has been truncated to " + 32768  + " characters.", { message: message }, true);
+        }
+    }
+    return messageTrunc || message;
+}
+function dataSanitizeException(logger, exception) {
+    var exceptionTrunc;
+    if (exception) {
+        var value = "" + exception;
+        if (value[_DYN_LENGTH ] > 32768 ) {
+            exceptionTrunc = value[_DYN_SUBSTRING ](0, 32768 );
+            _throwInternal(logger, 2 , 52 , "exception is too long, it has been truncated to " + 32768  + " characters.", { exception: exception }, true);
+        }
+    }
+    return exceptionTrunc || exception;
+}
+function dataSanitizeProperties(logger, properties) {
+    if (properties) {
+        var tempProps_1 = {};
+        objForEachKey(properties, function (prop, value) {
+            if (isObject(value) && hasJSON()) {
+                try {
+                    value = getJSON()[_DYN_STRINGIFY ](value);
+                }
+                catch (e) {
+                    _throwInternal(logger, 2 , 49 , "custom property is not valid", { exception: e }, true);
+                }
+            }
+            value = dataSanitizeString(logger, value, 8192 );
+            prop = dataSanitizeKeyAndAddUniqueness(logger, prop, tempProps_1);
+            tempProps_1[prop] = value;
+        });
+        properties = tempProps_1;
+    }
+    return properties;
+}
+function dataSanitizeMeasurements(logger, measurements) {
+    if (measurements) {
+        var tempMeasurements_1 = {};
+        objForEachKey(measurements, function (measure, value) {
+            measure = dataSanitizeKeyAndAddUniqueness(logger, measure, tempMeasurements_1);
+            tempMeasurements_1[measure] = value;
+        });
+        measurements = tempMeasurements_1;
+    }
+    return measurements;
+}
+function dataSanitizeId(logger, id) {
+    return id ? dataSanitizeInput(logger, id, 128 , 69 )[_DYN_TO_STRING ]() : id;
+}
+function dataSanitizeInput(logger, input, maxLength, _msgId) {
+    var inputTrunc;
+    if (input) {
+        input = strTrim(input[_DYN_TO_STRING ]());
+        if (input[_DYN_LENGTH ] > maxLength) {
+            inputTrunc = input[_DYN_SUBSTRING ](0, maxLength);
+            _throwInternal(logger, 2 , _msgId, "input is too long, it has been truncated to " + maxLength + " characters.", { data: input }, true);
+        }
+    }
+    return inputTrunc || input;
+}
+function dsPadNumber(num) {
+    var s = "00" + num;
+    return strSubstr(s, s[_DYN_LENGTH ] - 3);
+}
+
+var _document = getDocument() || {};
+var _htmlAnchorIdx = 0;
+var _htmlAnchorElement = [null, null, null, null, null];
+function urlParseUrl(url) {
+    var anchorIdx = _htmlAnchorIdx;
+    var anchorCache = _htmlAnchorElement;
+    var tempAnchor = anchorCache[anchorIdx];
+    if (!_document.createElement) {
+        tempAnchor = { host: urlParseHost(url, true) };
+    }
+    else if (!anchorCache[anchorIdx]) {
+        tempAnchor = anchorCache[anchorIdx] = _document.createElement("a");
+    }
+    tempAnchor.href = url;
+    anchorIdx++;
+    if (anchorIdx >= anchorCache[_DYN_LENGTH ]) {
+        anchorIdx = 0;
+    }
+    _htmlAnchorIdx = anchorIdx;
+    return tempAnchor;
+}
+function urlGetAbsoluteUrl(url) {
+    var result;
+    var a = urlParseUrl(url);
+    if (a) {
+        result = a.href;
+    }
+    return result;
+}
+function urlGetPathName(url) {
+    var result;
+    var a = urlParseUrl(url);
+    if (a) {
+        result = a[_DYN_PATHNAME ];
+    }
+    return result;
+}
+function urlGetCompleteUrl(method, absoluteUrl) {
+    if (method) {
+        return method.toUpperCase() + " " + absoluteUrl;
+    }
+    return absoluteUrl;
+}
+function urlParseHost(url, inclPort) {
+    var fullHost = urlParseFullHost(url, inclPort) || "";
+    if (fullHost) {
+        var match = fullHost.match(/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
+        if (match != null && match[_DYN_LENGTH ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH ] > 0) {
+            return match[2] + (match[3] || "");
+        }
+    }
+    return fullHost;
+}
+function urlParseFullHost(url, inclPort) {
+    var result = null;
+    if (url) {
+        var match = url.match(/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
+        if (match != null && match[_DYN_LENGTH ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH ] > 0) {
+            result = match[2] || "";
+            if (inclPort && match[_DYN_LENGTH ] > 2) {
+                var protocol = (match[1] || "")[_DYN_TO_LOWER_CASE ]();
+                var port = match[3] || "";
+                if (protocol === "http" && port === ":80") {
+                    port = "";
+                }
+                else if (protocol === "https" && port === ":443") {
+                    port = "";
+                }
+                result += port;
+            }
+        }
+    }
+    return result;
+}
+
+var _internalEndpoints = [
+    DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH,
+    "https://breeze.aimon.applicationinsights.io" + DEFAULT_BREEZE_PATH,
+    "https://dc-int.services.visualstudio.com" + DEFAULT_BREEZE_PATH
+];
+var _correlationIdPrefix = "cid-v1:";
+function isInternalApplicationInsightsEndpoint(endpointUrl) {
+    return arrIndexOf(_internalEndpoints, endpointUrl[_DYN_TO_LOWER_CASE ]()) !== -1;
+}
+function correlationIdSetPrefix(prefix) {
+    _correlationIdPrefix = prefix;
+}
+function correlationIdGetPrefix() {
+    return _correlationIdPrefix;
+}
+function correlationIdCanIncludeCorrelationHeader(config, requestUrl, currentHost) {
+    if (!requestUrl || (config && config.disableCorrelationHeaders)) {
+        return false;
+    }
+    if (config && config[_DYN_CORRELATION_HEADER_E0 ]) {
+        for (var i = 0; i < config.correlationHeaderExcludePatterns[_DYN_LENGTH ]; i++) {
+            if (config[_DYN_CORRELATION_HEADER_E0 ][i].test(requestUrl)) {
+                return false;
+            }
+        }
+    }
+    var requestHost = urlParseUrl(requestUrl).host[_DYN_TO_LOWER_CASE ]();
+    if (requestHost && (strIndexOf(requestHost, ":443") !== -1 || strIndexOf(requestHost, ":80") !== -1)) {
+        requestHost = (urlParseFullHost(requestUrl, true) || "")[_DYN_TO_LOWER_CASE ]();
+    }
+    if ((!config || !config.enableCorsCorrelation) && (requestHost && requestHost !== currentHost)) {
+        return false;
+    }
+    var includedDomains = config && config.correlationHeaderDomains;
+    if (includedDomains) {
+        var matchExists_1;
+        arrForEach(includedDomains, function (domain) {
+            var regex = new RegExp(domain.toLowerCase().replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*"));
+            matchExists_1 = matchExists_1 || regex.test(requestHost);
+        });
+        if (!matchExists_1) {
+            return false;
+        }
+    }
+    var excludedDomains = config && config.correlationHeaderExcludedDomains;
+    if (!excludedDomains || excludedDomains[_DYN_LENGTH ] === 0) {
+        return true;
+    }
+    for (var i = 0; i < excludedDomains[_DYN_LENGTH ]; i++) {
+        var regex = new RegExp(excludedDomains[i].toLowerCase().replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*"));
+        if (regex.test(requestHost)) {
+            return false;
+        }
+    }
+    return requestHost && requestHost[_DYN_LENGTH ] > 0;
+}
+function correlationIdGetCorrelationContext(responseHeader) {
+    if (responseHeader) {
+        var correlationId = correlationIdGetCorrelationContextValue(responseHeader, RequestHeaders[1 ]);
+        if (correlationId && correlationId !== _correlationIdPrefix) {
+            return correlationId;
+        }
+    }
+}
+function correlationIdGetCorrelationContextValue(responseHeader, key) {
+    if (responseHeader) {
+        var keyValues = responseHeader[_DYN_SPLIT ](",");
+        for (var i = 0; i < keyValues[_DYN_LENGTH ]; ++i) {
+            var keyValue = keyValues[i][_DYN_SPLIT ]("=");
+            if (keyValue[_DYN_LENGTH ] === 2 && keyValue[0] === key) {
+                return keyValue[1];
+            }
+        }
+    }
+}
+function AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName) {
+    var target, name = commandName, data = commandName;
+    if (absoluteUrl && absoluteUrl[_DYN_LENGTH ] > 0) {
+        var parsedUrl = urlParseUrl(absoluteUrl);
+        target = parsedUrl.host;
+        if (!name) {
+            if (parsedUrl[_DYN_PATHNAME ] != null) {
+                var pathName = (parsedUrl.pathname[_DYN_LENGTH ] === 0) ? "/" : parsedUrl[_DYN_PATHNAME ];
+                if (pathName.charAt(0) !== "/") {
+                    pathName = "/" + pathName;
+                }
+                data = parsedUrl[_DYN_PATHNAME ];
+                name = dataSanitizeString(logger, method ? method + " " + pathName : pathName);
+            }
+            else {
+                name = dataSanitizeString(logger, absoluteUrl);
+            }
+        }
+    }
+    else {
+        target = commandName;
+        name = commandName;
+    }
+    return {
+        target: target,
+        name: name,
+        data: data
+    };
+}
+function dateTimeUtilsNow() {
+    var perf = getPerformance();
+    if (perf && perf.now && perf.timing) {
+        var now = perf.now() + perf.timing.navigationStart;
+        if (now > 0) {
+            return now;
+        }
+    }
+    return utcNow();
+}
+function dateTimeUtilsDuration(start, end) {
+    var result = null;
+    if (start !== 0 && end !== 0 && !isNullOrUndefined(start) && !isNullOrUndefined(end)) {
+        result = end - start;
+    }
+    return result;
+}
+function createDistributedTraceContextFromTrace(telemetryTrace, parentCtx) {
+    var trace = telemetryTrace || {};
+    return {
+        getName: function () {
+            return trace[_DYN_NAME ];
+        },
+        setName: function (newValue) {
+            parentCtx && parentCtx.setName(newValue);
+            trace[_DYN_NAME ] = newValue;
+        },
+        getTraceId: function () {
+            return trace.traceID;
+        },
+        setTraceId: function (newValue) {
+            parentCtx && parentCtx.setTraceId(newValue);
+            if (isValidTraceId(newValue)) {
+                trace.traceID = newValue;
+            }
+        },
+        getSpanId: function () {
+            return trace.parentID;
+        },
+        setSpanId: function (newValue) {
+            parentCtx && parentCtx.setSpanId(newValue);
+            if (isValidSpanId(newValue)) {
+                trace.parentID = newValue;
+            }
+        },
+        getTraceFlags: function () {
+            return trace.traceFlags;
+        },
+        setTraceFlags: function (newTraceFlags) {
+            parentCtx && parentCtx.setTraceFlags(newTraceFlags);
+            trace.traceFlags = newTraceFlags;
+        }
+    };
+}
+
+var StorageType = createEnumStyle({
+    LocalStorage: 0 ,
+    SessionStorage: 1
+});
+var DistributedTracingModes = createEnumStyle({
+    AI: 0 ,
+    AI_AND_W3C: 1 ,
+    W3C: 2
+});
+
+var _canUseLocalStorage = undefined;
+var _canUseSessionStorage = undefined;
+function _getLocalStorageObject() {
+    if (utlCanUseLocalStorage()) {
+        return _getVerifiedStorageObject(StorageType.LocalStorage);
+    }
+    return null;
+}
+function _getVerifiedStorageObject(storageType) {
+    try {
+        if (isNullOrUndefined(getGlobal())) {
+            return null;
+        }
+        var uid = (new Date)[_DYN_TO_STRING ]();
+        var storage = getInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
+        storage.setItem(uid, uid);
+        var fail = storage.getItem(uid) !== uid;
+        storage[_DYN_REMOVE_ITEM ](uid);
+        if (!fail) {
+            return storage;
+        }
+    }
+    catch (exception) {
+    }
+    return null;
+}
+function _getSessionStorageObject() {
+    if (utlCanUseSessionStorage()) {
+        return _getVerifiedStorageObject(StorageType.SessionStorage);
+    }
+    return null;
+}
+function utlDisableStorage() {
+    _canUseLocalStorage = false;
+    _canUseSessionStorage = false;
+}
+function utlEnableStorage() {
+    _canUseLocalStorage = utlCanUseLocalStorage(true);
+    _canUseSessionStorage = utlCanUseSessionStorage(true);
+}
+function utlCanUseLocalStorage(reset) {
+    if (reset || _canUseLocalStorage === undefined) {
+        _canUseLocalStorage = !!_getVerifiedStorageObject(StorageType.LocalStorage);
+    }
+    return _canUseLocalStorage;
+}
+function utlGetLocalStorage(logger, name) {
+    var storage = _getLocalStorageObject();
+    if (storage !== null) {
+        try {
+            return storage.getItem(name);
+        }
+        catch (e) {
+            _canUseLocalStorage = false;
+            _throwInternal(logger, 2 , 1 , "Browser failed read of local storage. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return null;
+}
+function utlSetLocalStorage(logger, name, data) {
+    var storage = _getLocalStorageObject();
+    if (storage !== null) {
+        try {
+            storage.setItem(name, data);
+            return true;
+        }
+        catch (e) {
+            _canUseLocalStorage = false;
+            _throwInternal(logger, 2 , 3 , "Browser failed write to local storage. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return false;
+}
+function utlRemoveStorage(logger, name) {
+    var storage = _getLocalStorageObject();
+    if (storage !== null) {
+        try {
+            storage[_DYN_REMOVE_ITEM ](name);
+            return true;
+        }
+        catch (e) {
+            _canUseLocalStorage = false;
+            _throwInternal(logger, 2 , 5 , "Browser failed removal of local storage item. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return false;
+}
+function utlCanUseSessionStorage(reset) {
+    if (reset || _canUseSessionStorage === undefined) {
+        _canUseSessionStorage = !!_getVerifiedStorageObject(StorageType.SessionStorage);
+    }
+    return _canUseSessionStorage;
+}
+function utlGetSessionStorageKeys() {
+    var keys = [];
+    if (utlCanUseSessionStorage()) {
+        objForEachKey(getInst("sessionStorage"), function (key) {
+            keys.push(key);
+        });
+    }
+    return keys;
+}
+function utlGetSessionStorage(logger, name) {
+    var storage = _getSessionStorageObject();
+    if (storage !== null) {
+        try {
+            return storage.getItem(name);
+        }
+        catch (e) {
+            _canUseSessionStorage = false;
+            _throwInternal(logger, 2 , 2 , "Browser failed read of session storage. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return null;
+}
+function utlSetSessionStorage(logger, name, data) {
+    var storage = _getSessionStorageObject();
+    if (storage !== null) {
+        try {
+            storage.setItem(name, data);
+            return true;
+        }
+        catch (e) {
+            _canUseSessionStorage = false;
+            _throwInternal(logger, 2 , 4 , "Browser failed write to session storage. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return false;
+}
+function utlRemoveSessionStorage(logger, name) {
+    var storage = _getSessionStorageObject();
+    if (storage !== null) {
+        try {
+            storage[_DYN_REMOVE_ITEM ](name);
+            return true;
+        }
+        catch (e) {
+            _canUseSessionStorage = false;
+            _throwInternal(logger, 2 , 6 , "Browser failed removal of session storage item. " + getExceptionName(e), { exception: dumpObj(e) });
+        }
+    }
+    return false;
+}
+
+var THROTTLE_STORAGE_PREFIX = "appInsightsThrottle";
+var ThrottleMgr = /** @class */ (function () {
+    function ThrottleMgr(config, core, namePrefix, unloadHookContainer) {
+        var _self = this;
+        var _canUseLocalStorage;
+        var _logger;
+        var _config;
+        var _localStorageName;
+        var _localStorageObj;
+        var _isTriggered;
+        var _namePrefix;
+        var _queue;
+        var _isReady = false;
+        var _isSpecificDaysGiven = false;
+        _initConfig();
+        _self["_getDbgPlgTargets"] = function () {
+            return [_queue];
+        };
+        _self.getConfig = function () {
+            return _config;
+        };
+        _self.canThrottle = function () {
+            return _canThrottle(_config, _canUseLocalStorage, _localStorageObj);
+        };
+        _self.isTriggered = function () {
+            return _isTriggered;
+        };
+        _self.isReady = function () {
+            return _isReady;
+        };
+        _self.flush = function () {
+            try {
+                if (_isReady && _queue[_DYN_LENGTH ] > 0) {
+                    var items = _queue.slice(0);
+                    _queue = [];
+                    arrForEach(items, function (item) {
+                        _flushMessage(item.msgID, item[_DYN_MESSAGE ], item.severity, false);
+                    });
+                    return true;
+                }
+            }
+            catch (err) {
+            }
+            return false;
+        };
+        _self.onReadyState = function (isReady) {
+            _isReady = isNullOrUndefined(isReady) ? true : isReady;
+            return _self.flush();
+        };
+        _self.sendMessage = function (msgID, message, severity) {
+            return _flushMessage(msgID, message, severity, true);
+        };
+        function _flushMessage(msgID, message, severity, saveUnsentMsg) {
+            if (_isReady) {
+                var isSampledIn = _canSampledIn();
+                if (!isSampledIn) {
+                    return;
+                }
+                var canThrottle = _canThrottle(_config, _canUseLocalStorage, _localStorageObj);
+                var throttled = false;
+                var number = 0;
+                try {
+                    if (canThrottle && !_isTriggered) {
+                        number = Math.min(_config.limit.maxSendNumber, _localStorageObj[_DYN_COUNT ] + 1);
+                        _localStorageObj[_DYN_COUNT ] = 0;
+                        throttled = true;
+                        _isTriggered = true;
+                        _localStorageObj[_DYN_PRE_TRIGGER_DATE ] = new Date();
+                    }
+                    else {
+                        _isTriggered = canThrottle;
+                        _localStorageObj[_DYN_COUNT ] += 1;
+                    }
+                    _resetLocalStorage(_logger, _localStorageName, _localStorageObj);
+                    for (var i = 0; i < number; i++) {
+                        _sendMessage(msgID, _logger, message, severity);
+                    }
+                }
+                catch (e) {
+                }
+                return {
+                    isThrottled: throttled,
+                    throttleNum: number
+                };
+            }
+            else {
+                if (!!saveUnsentMsg) {
+                    _queue.push({
+                        msgID: msgID,
+                        message: message,
+                        severity: severity
+                    });
+                }
+            }
+            return null;
+        }
+        function _initConfig() {
+            _logger = safeGetLogger(core);
+            _isTriggered = false;
+            _queue = [];
+            _namePrefix = isNotNullOrUndefined(namePrefix) ? namePrefix : "";
+            unloadHookContainer = unloadHookContainer || createUnloadHookContainer();
+            config = createDynamicConfig(config || {}, null, _logger).cfg;
+            var unloadHook = onConfigChange((config), function () {
+                var _a, _b;
+                _canUseLocalStorage = utlCanUseLocalStorage();
+                var configMgr = config || {};
+                _config = {};
+                _config[_DYN_DISABLED ] = !!configMgr[_DYN_DISABLED ];
+                _config.msgKey = configMgr.msgKey || 0 ;
+                var configInterval = configMgr[_DYN_INTERVAL ] || {};
+                _isSpecificDaysGiven = (configInterval === null || configInterval === void 0 ? void 0 : configInterval.daysOfMonth) && (configInterval === null || configInterval === void 0 ? void 0 : configInterval.daysOfMonth[_DYN_LENGTH ]) > 0;
+                _config[_DYN_INTERVAL ] = _getIntervalConfig(configInterval);
+                var limit = {
+                    samplingRate: ((_a = configMgr.limit) === null || _a === void 0 ? void 0 : _a.samplingRate) || 100,
+                    maxSendNumber: ((_b = configMgr.limit) === null || _b === void 0 ? void 0 : _b.maxSendNumber) || 1
+                };
+                _config.limit = limit;
+                _localStorageName = _getLocalStorageName(_config.msgKey, _namePrefix);
+                if (_canUseLocalStorage && _localStorageName) {
+                    _localStorageObj = _getLocalStorageObj(utlGetLocalStorage(_logger, _localStorageName), _logger, _localStorageName);
+                }
+                if (_localStorageObj) {
+                    _isTriggered = _isTriggeredOnCurDate(_localStorageObj[_DYN_PRE_TRIGGER_DATE ]);
+                }
+            });
+            unloadHookContainer && unloadHookContainer.add(unloadHook);
+        }
+        function _getIntervalConfig(interval) {
+            interval = interval || {};
+            var monthInterval = interval === null || interval === void 0 ? void 0 : interval.monthInterval;
+            var dayInterval = interval === null || interval === void 0 ? void 0 : interval.dayInterval;
+            if (isNullOrUndefined(monthInterval) && isNullOrUndefined(dayInterval)) {
+                interval.monthInterval = 3;
+                if (!_isSpecificDaysGiven) {
+                    interval[_DYN_DAYS_OF_MONTH ] = [28];
+                    _isSpecificDaysGiven = true;
+                }
+            }
+            interval = {
+                monthInterval: interval === null || interval === void 0 ? void 0 : interval.monthInterval,
+                dayInterval: interval === null || interval === void 0 ? void 0 : interval.dayInterval,
+                daysOfMonth: interval === null || interval === void 0 ? void 0 : interval.daysOfMonth
+            };
+            return interval;
+        }
+        function _canThrottle(config, canUseLocalStorage, localStorageObj) {
+            if (!config[_DYN_DISABLED ] && canUseLocalStorage && isNotNullOrUndefined(localStorageObj)) {
+                var curDate = _getThrottleDate();
+                var date = localStorageObj[_DYN_DATE ];
+                var interval = config[_DYN_INTERVAL ];
+                var monthCheck = 1;
+                if (interval === null || interval === void 0 ? void 0 : interval.monthInterval) {
+                    var monthExpand = (curDate.getUTCFullYear() - date.getUTCFullYear()) * 12 + curDate.getUTCMonth() - date.getUTCMonth();
+                    monthCheck = _checkInterval(interval.monthInterval, 0, monthExpand);
+                }
+                var dayCheck = 1;
+                if (_isSpecificDaysGiven) {
+                    dayCheck = arrIndexOf(interval[_DYN_DAYS_OF_MONTH ], curDate[_DYN_GET_UTCDATE ]());
+                }
+                else if (interval === null || interval === void 0 ? void 0 : interval.dayInterval) {
+                    var daySpan = Math.floor((curDate.getTime() - date.getTime()) / 86400000);
+                    dayCheck = _checkInterval(interval.dayInterval, 0, daySpan);
+                }
+                return monthCheck >= 0 && dayCheck >= 0;
+            }
+            return false;
+        }
+        function _getLocalStorageName(msgKey, prefix) {
+            var fix = isNotNullOrUndefined(prefix) ? prefix : "";
+            if (msgKey) {
+                return THROTTLE_STORAGE_PREFIX + fix + "-" + msgKey;
+            }
+            return null;
+        }
+        function _isTriggeredOnCurDate(preTriggerDate) {
+            try {
+                if (preTriggerDate) {
+                    var curDate = new Date();
+                    return preTriggerDate.getUTCFullYear() === curDate.getUTCFullYear() &&
+                        preTriggerDate.getUTCMonth() === curDate.getUTCMonth() &&
+                        preTriggerDate[_DYN_GET_UTCDATE ]() === curDate[_DYN_GET_UTCDATE ]();
+                }
+            }
+            catch (e) {
+            }
+            return false;
+        }
+        function _getLocalStorageObj(value, logger, storageName) {
+            try {
+                var storageObj = {
+                    date: _getThrottleDate(),
+                    count: 0
+                };
+                if (value) {
+                    var obj = JSON.parse(value);
+                    return {
+                        date: _getThrottleDate(obj[_DYN_DATE ]) || storageObj[_DYN_DATE ],
+                        count: obj[_DYN_COUNT ] || storageObj[_DYN_COUNT ],
+                        preTriggerDate: obj.preTriggerDate ? _getThrottleDate(obj[_DYN_PRE_TRIGGER_DATE ]) : undefined
+                    };
+                }
+                else {
+                    _resetLocalStorage(logger, storageName, storageObj);
+                    return storageObj;
+                }
+            }
+            catch (e) {
+            }
+            return null;
+        }
+        function _getThrottleDate(dateStr) {
+            try {
+                if (dateStr) {
+                    var date = new Date(dateStr);
+                    if (!isNaN(date.getDate())) {
+                        return date;
+                    }
+                }
+                else {
+                    return new Date();
+                }
+            }
+            catch (e) {
+            }
+            return null;
+        }
+        function _resetLocalStorage(logger, storageName, obj) {
+            try {
+                return utlSetLocalStorage(logger, storageName, strTrim(JSON[_DYN_STRINGIFY ](obj)));
+            }
+            catch (e) {
+            }
+            return false;
+        }
+        function _checkInterval(interval, start, current) {
+            if (interval <= 0) {
+                return 1;
+            }
+            return (current >= start) && (current - start) % interval == 0 ? Math.floor((current - start) / interval) + 1 : -1;
+        }
+        function _sendMessage(msgID, logger, message, severity) {
+            _throwInternal(logger, severity || 1 , msgID, message);
+        }
+        function _canSampledIn() {
+            return randomValue(1000000) <= _config.limit.samplingRate;
+        }
+    }
+    return ThrottleMgr;
+}());
+
+var _FIELDS_SEPARATOR = ";";
+var _FIELD_KEY_VALUE_SEPARATOR = "=";
+function parseConnectionString(connectionString) {
+    if (!connectionString) {
+        return {};
+    }
+    var kvPairs = connectionString[_DYN_SPLIT ](_FIELDS_SEPARATOR);
+    var result = arrReduce(kvPairs, function (fields, kv) {
+        var kvParts = kv[_DYN_SPLIT ](_FIELD_KEY_VALUE_SEPARATOR);
+        if (kvParts[_DYN_LENGTH ] === 2) {
+            var key = kvParts[0][_DYN_TO_LOWER_CASE ]();
+            var value = kvParts[1];
+            fields[key] = value;
+        }
+        return fields;
+    }, {});
+    if (objKeys(result)[_DYN_LENGTH ] > 0) {
+        if (result.endpointsuffix) {
+            var locationPrefix = result.location ? result.location + "." : "";
+            result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
+        }
+        result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || DEFAULT_BREEZE_ENDPOINT;
+    }
+    return result;
+}
+var ConnectionStringParser = {
+    parse: parseConnectionString
+};
+
+var Envelope = /** @class */ (function () {
+    function Envelope(logger, data, name) {
+        var _this = this;
+        var _self = this;
+        _self.ver = 1;
+        _self.sampleRate = 100.0;
+        _self.tags = {};
+        _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
+        _self.data = data;
+        _self.time = toISOString(new Date());
+        _self.aiDataContract = {
+            time: 1 ,
+            iKey: 1 ,
+            name: 1 ,
+            sampleRate: function () {
+                return (_this.sampleRate === 100) ? 4  : 1 ;
+            },
+            tags: 1 ,
+            data: 1
+        };
+    }
+    return Envelope;
+}());
+
+var Event$1 = /** @class */ (function () {
+    function Event(logger, name, properties, measurements) {
+        this.aiDataContract = {
+            ver: 1 ,
+            name: 1 ,
+            properties: 0 ,
+            measurements: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+    }
+    Event.envelopeType = "Microsoft.ApplicationInsights.{0}.Event";
+    Event.dataType = "EventData";
+    return Event;
+}());
+
+var NoMethod = "<no_method>";
+var strError = "error";
+var strStack = "stack";
+var strStackDetails = "stackDetails";
+var strErrorSrc = "errorSrc";
+var strMessage = "message";
+var strDescription = "description";
+function _stringify(value, convertToString) {
+    var result = value;
+    if (result && !isString(result)) {
+        if (JSON && JSON[_DYN_STRINGIFY ]) {
+            result = JSON[_DYN_STRINGIFY ](value);
+            if (convertToString && (!result || result === "{}")) {
+                if (isFunction(value[_DYN_TO_STRING ])) {
+                    result = value[_DYN_TO_STRING ]();
+                }
+                else {
+                    result = "" + value;
+                }
+            }
+        }
+        else {
+            result = "" + value + " - (Missing JSON.stringify)";
+        }
+    }
+    return result || "";
+}
+function _formatMessage(theEvent, errorType) {
+    var evtMessage = theEvent;
+    if (theEvent) {
+        if (evtMessage && !isString(evtMessage)) {
+            evtMessage = theEvent[strMessage] || theEvent[strDescription] || evtMessage;
+        }
+        if (evtMessage && !isString(evtMessage)) {
+            evtMessage = _stringify(evtMessage, true);
+        }
+        if (theEvent["filename"]) {
+            evtMessage = evtMessage + " @" + (theEvent["filename"] || "") + ":" + (theEvent["lineno"] || "?") + ":" + (theEvent["colno"] || "?");
+        }
+    }
+    if (errorType && errorType !== "String" && errorType !== "Object" && errorType !== "Error" && strIndexOf(evtMessage || "", errorType) === -1) {
+        evtMessage = errorType + ": " + evtMessage;
+    }
+    return evtMessage || "";
+}
+function _isExceptionDetailsInternal(value) {
+    try {
+        if (isObject(value)) {
+            return "hasFullStack" in value && "typeName" in value;
+        }
+    }
+    catch (e) {
+    }
+    return false;
+}
+function _isExceptionInternal(value) {
+    try {
+        if (isObject(value)) {
+            return ("ver" in value && "exceptions" in value && "properties" in value);
+        }
+    }
+    catch (e) {
+    }
+    return false;
+}
+function _isStackDetails(details) {
+    return details && details.src && isString(details.src) && details.obj && isArray(details.obj);
+}
+function _convertStackObj(errorStack) {
+    var src = errorStack || "";
+    if (!isString(src)) {
+        if (isString(src[strStack])) {
+            src = src[strStack];
+        }
+        else {
+            src = "" + src;
+        }
+    }
+    var items = src[_DYN_SPLIT ]("\n");
+    return {
+        src: src,
+        obj: items
+    };
+}
+function _getOperaStack(errorMessage) {
+    var stack = [];
+    var lines = errorMessage[_DYN_SPLIT ]("\n");
+    for (var lp = 0; lp < lines[_DYN_LENGTH ]; lp++) {
+        var entry = lines[lp];
+        if (lines[lp + 1]) {
+            entry += "@" + lines[lp + 1];
+            lp++;
+        }
+        stack.push(entry);
+    }
+    return {
+        src: errorMessage,
+        obj: stack
+    };
+}
+function _getStackFromErrorObj(errorObj) {
+    var details = null;
+    if (errorObj) {
+        try {
+            if (errorObj[strStack]) {
+                details = _convertStackObj(errorObj[strStack]);
+            }
+            else if (errorObj[strError] && errorObj[strError][strStack]) {
+                details = _convertStackObj(errorObj[strError][strStack]);
+            }
+            else if (errorObj["exception"] && errorObj.exception[strStack]) {
+                details = _convertStackObj(errorObj.exception[strStack]);
+            }
+            else if (_isStackDetails(errorObj)) {
+                details = errorObj;
+            }
+            else if (_isStackDetails(errorObj[strStackDetails])) {
+                details = errorObj[strStackDetails];
+            }
+            else if (window && window["opera"] && errorObj[strMessage]) {
+                details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
+            }
+            else if (errorObj["reason"] && errorObj.reason[strStack]) {
+                details = _convertStackObj(errorObj.reason[strStack]);
+            }
+            else if (isString(errorObj)) {
+                details = _convertStackObj(errorObj);
+            }
+            else {
+                var evtMessage = errorObj[strMessage] || errorObj[strDescription] || "";
+                if (isString(errorObj[strErrorSrc])) {
+                    if (evtMessage) {
+                        evtMessage += "\n";
+                    }
+                    evtMessage += " from " + errorObj[strErrorSrc];
+                }
+                if (evtMessage) {
+                    details = _convertStackObj(evtMessage);
+                }
+            }
+        }
+        catch (e) {
+            details = _convertStackObj(e);
+        }
+    }
+    return details || {
+        src: "",
+        obj: null
+    };
+}
+function _formatStackTrace(stackDetails) {
+    var stack = "";
+    if (stackDetails) {
+        if (stackDetails.obj) {
+            arrForEach(stackDetails.obj, function (entry) {
+                stack += entry + "\n";
+            });
+        }
+        else {
+            stack = stackDetails.src || "";
+        }
+    }
+    return stack;
+}
+function _parseStack(stack) {
+    var parsedStack;
+    var frames = stack.obj;
+    if (frames && frames[_DYN_LENGTH ] > 0) {
+        parsedStack = [];
+        var level_1 = 0;
+        var totalSizeInBytes_1 = 0;
+        arrForEach(frames, function (frame) {
+            var theFrame = frame[_DYN_TO_STRING ]();
+            if (_StackFrame.regex.test(theFrame)) {
+                var parsedFrame = new _StackFrame(theFrame, level_1++);
+                totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
+                parsedStack.push(parsedFrame);
+            }
+        });
+        var exceptionParsedStackThreshold = 32 * 1024;
+        if (totalSizeInBytes_1 > exceptionParsedStackThreshold) {
+            var left = 0;
+            var right = parsedStack[_DYN_LENGTH ] - 1;
+            var size = 0;
+            var acceptedLeft = left;
+            var acceptedRight = right;
+            while (left < right) {
+                var lSize = parsedStack[left][_DYN_SIZE_IN_BYTES ];
+                var rSize = parsedStack[right][_DYN_SIZE_IN_BYTES ];
+                size += lSize + rSize;
+                if (size > exceptionParsedStackThreshold) {
+                    var howMany = acceptedRight - acceptedLeft + 1;
+                    parsedStack.splice(acceptedLeft, howMany);
+                    break;
+                }
+                acceptedLeft = left;
+                acceptedRight = right;
+                left++;
+                right--;
+            }
+        }
+    }
+    return parsedStack;
+}
+function _getErrorType(errorType) {
+    var typeName = "";
+    if (errorType) {
+        typeName = errorType.typeName || errorType[_DYN_NAME ] || "";
+        if (!typeName) {
+            try {
+                var funcNameRegex = /function (.{1,200})\(/;
+                var results = (funcNameRegex).exec((errorType).constructor[_DYN_TO_STRING ]());
+                typeName = (results && results[_DYN_LENGTH ] > 1) ? results[1] : "";
+            }
+            catch (e) {
+            }
+        }
+    }
+    return typeName;
+}
+function _formatErrorCode(errorObj) {
+    if (errorObj) {
+        try {
+            if (!isString(errorObj)) {
+                var errorType = _getErrorType(errorObj);
+                var result = _stringify(errorObj, false);
+                if (!result || result === "{}") {
+                    if (errorObj[strError]) {
+                        errorObj = errorObj[strError];
+                        errorType = _getErrorType(errorObj);
+                    }
+                    result = _stringify(errorObj, true);
+                }
+                if (strIndexOf(result, errorType) !== 0 && errorType !== "String") {
+                    return errorType + ":" + result;
+                }
+                return result;
+            }
+        }
+        catch (e) {
+        }
+    }
+    return "" + (errorObj || "");
+}
+var Exception = /** @class */ (function () {
+    function Exception(logger, exception, properties, measurements, severityLevel, id) {
+        this.aiDataContract = {
+            ver: 1 ,
+            exceptions: 1 ,
+            severityLevel: 0 ,
+            properties: 0 ,
+            measurements: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        if (!_isExceptionInternal(exception)) {
+            if (!properties) {
+                properties = {};
+            }
+            _self[_DYN_EXCEPTIONS ] = [new _ExceptionDetails(logger, exception, properties)];
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+            if (severityLevel) {
+                _self[_DYN_SEVERITY_LEVEL ] = severityLevel;
+            }
+            if (id) {
+                _self.id = id;
+            }
+        }
+        else {
+            _self[_DYN_EXCEPTIONS ] = exception[_DYN_EXCEPTIONS ] || [];
+            _self[_DYN_PROPERTIES ] = exception[_DYN_PROPERTIES ];
+            _self[_DYN_MEASUREMENTS ] = exception[_DYN_MEASUREMENTS ];
+            if (exception[_DYN_SEVERITY_LEVEL ]) {
+                _self[_DYN_SEVERITY_LEVEL ] = exception[_DYN_SEVERITY_LEVEL ];
+            }
+            if (exception.id) {
+                _self.id = exception.id;
+            }
+            if (exception[_DYN_PROBLEM_GROUP ]) {
+                _self[_DYN_PROBLEM_GROUP ] = exception[_DYN_PROBLEM_GROUP ];
+            }
+            if (!isNullOrUndefined(exception[_DYN_IS_MANUAL ])) {
+                _self[_DYN_IS_MANUAL ] = exception[_DYN_IS_MANUAL ];
+            }
+        }
+    }
+    Exception.CreateAutoException = function (message, url, lineNumber, columnNumber, error, evt, stack, errorSrc) {
+        var _a;
+        var errorType = _getErrorType(error || evt || message);
+        return _a = {},
+            _a[_DYN_MESSAGE ] = _formatMessage(message, errorType),
+            _a.url = url,
+            _a.lineNumber = lineNumber,
+            _a.columnNumber = columnNumber,
+            _a.error = _formatErrorCode(error || evt || message),
+            _a.evt = _formatErrorCode(evt || message),
+            _a[_DYN_TYPE_NAME ] = errorType,
+            _a.stackDetails = _getStackFromErrorObj(stack || error || evt),
+            _a.errorSrc = errorSrc,
+            _a;
+    };
+    Exception.CreateFromInterface = function (logger, exception, properties, measurements) {
+        var exceptions = exception[_DYN_EXCEPTIONS ]
+            && arrMap(exception[_DYN_EXCEPTIONS ], function (ex) { return _ExceptionDetails[_DYN__CREATE_FROM_INTERFA1 ](logger, ex); });
+        var exceptionData = new Exception(logger, __assignFn(__assignFn({}, exception), { exceptions: exceptions }), properties, measurements);
+        return exceptionData;
+    };
+    Exception.prototype.toInterface = function () {
+        var _a;
+        var _b = this, exceptions = _b.exceptions, properties = _b.properties, measurements = _b.measurements, severityLevel = _b.severityLevel, problemGroup = _b.problemGroup, id = _b.id, isManual = _b.isManual;
+        var exceptionDetailsInterface = exceptions instanceof Array
+            && arrMap(exceptions, function (exception) { return exception.toInterface(); })
+            || undefined;
+        return _a = {
+                ver: "4.0"
+            },
+            _a[_DYN_EXCEPTIONS ] = exceptionDetailsInterface,
+            _a.severityLevel = severityLevel,
+            _a.properties = properties,
+            _a.measurements = measurements,
+            _a.problemGroup = problemGroup,
+            _a.id = id,
+            _a.isManual = isManual,
+            _a;
+    };
+    Exception.CreateSimpleException = function (message, typeName, assembly, fileName, details, line) {
+        var _a;
+        return {
+            exceptions: [
+                (_a = {},
+                    _a[_DYN_HAS_FULL_STACK ] = true,
+                    _a.message = message,
+                    _a.stack = details,
+                    _a.typeName = typeName,
+                    _a)
+            ]
+        };
+    };
+    Exception.envelopeType = "Microsoft.ApplicationInsights.{0}.Exception";
+    Exception.dataType = "ExceptionData";
+    Exception.formatError = _formatErrorCode;
+    return Exception;
+}());
+var _ExceptionDetails = /** @class */ (function () {
+    function _ExceptionDetails(logger, exception, properties) {
+        this.aiDataContract = {
+            id: 0 ,
+            outerId: 0 ,
+            typeName: 1 ,
+            message: 1 ,
+            hasFullStack: 0 ,
+            stack: 0 ,
+            parsedStack: 2
+        };
+        var _self = this;
+        if (!_isExceptionDetailsInternal(exception)) {
+            var error = exception;
+            var evt = error && error.evt;
+            if (!isError(error)) {
+                error = error[strError] || evt || error;
+            }
+            _self[_DYN_TYPE_NAME ] = dataSanitizeString(logger, _getErrorType(error)) || strNotSpecified;
+            _self[_DYN_MESSAGE ] = dataSanitizeMessage(logger, _formatMessage(exception || error, _self[_DYN_TYPE_NAME ])) || strNotSpecified;
+            var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
+            _self[_DYN_PARSED_STACK ] = _parseStack(stack);
+            if (isArray(_self[_DYN_PARSED_STACK ])) {
+                arrMap(_self[_DYN_PARSED_STACK ], function (frame) { return frame[_DYN_ASSEMBLY ] = dataSanitizeString(logger, frame[_DYN_ASSEMBLY ]); });
+            }
+            _self[strStack] = dataSanitizeException(logger, _formatStackTrace(stack));
+            _self.hasFullStack = isArray(_self.parsedStack) && _self.parsedStack[_DYN_LENGTH ] > 0;
+            if (properties) {
+                properties[_DYN_TYPE_NAME ] = properties[_DYN_TYPE_NAME ] || _self[_DYN_TYPE_NAME ];
+            }
+        }
+        else {
+            _self[_DYN_TYPE_NAME ] = exception[_DYN_TYPE_NAME ];
+            _self[_DYN_MESSAGE ] = exception[_DYN_MESSAGE ];
+            _self[strStack] = exception[strStack];
+            _self[_DYN_PARSED_STACK ] = exception[_DYN_PARSED_STACK ] || [];
+            _self[_DYN_HAS_FULL_STACK ] = exception[_DYN_HAS_FULL_STACK ];
+        }
+    }
+    _ExceptionDetails.prototype.toInterface = function () {
+        var _a;
+        var _self = this;
+        var parsedStack = _self[_DYN_PARSED_STACK ] instanceof Array
+            && arrMap(_self[_DYN_PARSED_STACK ], function (frame) { return frame.toInterface(); });
+        var exceptionDetailsInterface = (_a = {
+                id: _self.id,
+                outerId: _self.outerId,
+                typeName: _self[_DYN_TYPE_NAME ],
+                message: _self[_DYN_MESSAGE ],
+                hasFullStack: _self[_DYN_HAS_FULL_STACK ],
+                stack: _self[strStack]
+            },
+            _a[_DYN_PARSED_STACK ] = parsedStack || undefined,
+            _a);
+        return exceptionDetailsInterface;
+    };
+    _ExceptionDetails.CreateFromInterface = function (logger, exception) {
+        var parsedStack = (exception[_DYN_PARSED_STACK ] instanceof Array
+            && arrMap(exception[_DYN_PARSED_STACK ], function (frame) { return _StackFrame[_DYN__CREATE_FROM_INTERFA1 ](frame); }))
+            || exception[_DYN_PARSED_STACK ];
+        var exceptionDetails = new _ExceptionDetails(logger, __assignFn(__assignFn({}, exception), { parsedStack: parsedStack }));
+        return exceptionDetails;
+    };
+    return _ExceptionDetails;
+}());
+var _StackFrame = /** @class */ (function () {
+    function _StackFrame(sourceFrame, level) {
+        this.aiDataContract = {
+            level: 1 ,
+            method: 1 ,
+            assembly: 0 ,
+            fileName: 0 ,
+            line: 0
+        };
+        var _self = this;
+        _self[_DYN_SIZE_IN_BYTES ] = 0;
+        if (typeof sourceFrame === "string") {
+            var frame = sourceFrame;
+            _self[_DYN_LEVEL ] = level;
+            _self[_DYN_METHOD ] = NoMethod;
+            _self[_DYN_ASSEMBLY ] = strTrim(frame);
+            _self[_DYN_FILE_NAME ] = "";
+            _self[_DYN_LINE ] = 0;
+            var matches = frame.match(_StackFrame.regex);
+            if (matches && matches[_DYN_LENGTH ] >= 5) {
+                _self[_DYN_METHOD ] = strTrim(matches[2]) || _self[_DYN_METHOD ];
+                _self[_DYN_FILE_NAME ] = strTrim(matches[4]);
+                _self[_DYN_LINE ] = parseInt(matches[5]) || 0;
+            }
+        }
+        else {
+            _self[_DYN_LEVEL ] = sourceFrame[_DYN_LEVEL ];
+            _self[_DYN_METHOD ] = sourceFrame[_DYN_METHOD ];
+            _self[_DYN_ASSEMBLY ] = sourceFrame[_DYN_ASSEMBLY ];
+            _self[_DYN_FILE_NAME ] = sourceFrame[_DYN_FILE_NAME ];
+            _self[_DYN_LINE ] = sourceFrame[_DYN_LINE ];
+            _self[_DYN_SIZE_IN_BYTES ] = 0;
+        }
+        _self.sizeInBytes += _self.method[_DYN_LENGTH ];
+        _self.sizeInBytes += _self.fileName[_DYN_LENGTH ];
+        _self.sizeInBytes += _self.assembly[_DYN_LENGTH ];
+        _self[_DYN_SIZE_IN_BYTES ] += _StackFrame.baseSize;
+        _self.sizeInBytes += _self.level.toString()[_DYN_LENGTH ];
+        _self.sizeInBytes += _self.line.toString()[_DYN_LENGTH ];
+    }
+    _StackFrame.CreateFromInterface = function (frame) {
+        return new _StackFrame(frame, null );
+    };
+    _StackFrame.prototype.toInterface = function () {
+        var _self = this;
+        return {
+            level: _self[_DYN_LEVEL ],
+            method: _self[_DYN_METHOD ],
+            assembly: _self[_DYN_ASSEMBLY ],
+            fileName: _self[_DYN_FILE_NAME ],
+            line: _self[_DYN_LINE ]
+        };
+    };
+    _StackFrame.regex = /^([\s]+at)?[\s]{0,50}([^\@\()]+?)[\s]{0,50}(\@|\()([^\(\n]+):([0-9]+):([0-9]+)(\)?)$/;
+    _StackFrame.baseSize = 58;
+    return _StackFrame;
+}());
+
+var DataPoint = /** @class */ (function () {
+    function DataPoint() {
+        this.aiDataContract = {
+            name: 1 ,
+            kind: 0 ,
+            value: 1 ,
+            count: 0 ,
+            min: 0 ,
+            max: 0 ,
+            stdDev: 0
+        };
+        this.kind = 0 ;
+    }
+    return DataPoint;
+}());
+
+var Metric = /** @class */ (function () {
+    function Metric(logger, name, value, count, min, max, stdDev, properties, measurements) {
+        this.aiDataContract = {
+            ver: 1 ,
+            metrics: 1 ,
+            properties: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        var dataPoint = new DataPoint();
+        dataPoint[_DYN_COUNT ] = count > 0 ? count : undefined;
+        dataPoint.max = isNaN(max) || max === null ? undefined : max;
+        dataPoint.min = isNaN(min) || min === null ? undefined : min;
+        dataPoint[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
+        dataPoint.value = value;
+        dataPoint.stdDev = isNaN(stdDev) || stdDev === null ? undefined : stdDev;
+        _self.metrics = [dataPoint];
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+    }
+    Metric.envelopeType = "Microsoft.ApplicationInsights.{0}.Metric";
+    Metric.dataType = "MetricData";
+    return Metric;
+}());
+
+var strEmpty = "";
+function stringToBoolOrDefault(str, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = false; }
+    if (str === undefined || str === null) {
+        return defaultValue;
+    }
+    return str.toString()[_DYN_TO_LOWER_CASE ]() === "true";
+}
+function msToTimeSpan(totalms) {
+    if (isNaN(totalms) || totalms < 0) {
+        totalms = 0;
+    }
+    totalms = Math.round(totalms);
+    var ms = strEmpty + totalms % 1000;
+    var sec = strEmpty + Math.floor(totalms / 1000) % 60;
+    var min = strEmpty + Math.floor(totalms / (1000 * 60)) % 60;
+    var hour = strEmpty + Math.floor(totalms / (1000 * 60 * 60)) % 24;
+    var days = Math.floor(totalms / (1000 * 60 * 60 * 24));
+    ms = ms[_DYN_LENGTH ] === 1 ? "00" + ms : ms[_DYN_LENGTH ] === 2 ? "0" + ms : ms;
+    sec = sec[_DYN_LENGTH ] < 2 ? "0" + sec : sec;
+    min = min[_DYN_LENGTH ] < 2 ? "0" + min : min;
+    hour = hour[_DYN_LENGTH ] < 2 ? "0" + hour : hour;
+    return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
+}
+function getExtensionByName(extensions, identifier) {
+    var extension = null;
+    arrForEach(extensions, function (value) {
+        if (value.identifier === identifier) {
+            extension = value;
+            return -1;
+        }
+    });
+    return extension;
+}
+function isCrossOriginError(message, url, lineNumber, columnNumber, error) {
+    return !error && isString(message) && (message === "Script error." || message === "Script error");
+}
+
+var PageView = /** @class */ (function () {
+    function PageView(logger, name, url, durationMs, properties, measurements, id) {
+        this.aiDataContract = {
+            ver: 1 ,
+            name: 0 ,
+            url: 0 ,
+            duration: 0 ,
+            properties: 0 ,
+            measurements: 0 ,
+            id: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        _self.id = dataSanitizeId(logger, id);
+        _self.url = dataSanitizeUrl(logger, url);
+        _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
+        if (!isNaN(durationMs)) {
+            _self[_DYN_DURATION ] = msToTimeSpan(durationMs);
+        }
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+    }
+    PageView.envelopeType = "Microsoft.ApplicationInsights.{0}.Pageview";
+    PageView.dataType = "PageviewData";
+    return PageView;
+}());
+
+var RemoteDependencyData = /** @class */ (function () {
+    function RemoteDependencyData(logger, id, absoluteUrl, commandName, value, success, resultCode, method, requestAPI, correlationContext, properties, measurements) {
+        if (requestAPI === void 0) { requestAPI = "Ajax"; }
+        this.aiDataContract = {
+            id: 1 ,
+            ver: 1 ,
+            name: 0 ,
+            resultCode: 0 ,
+            duration: 0 ,
+            success: 0 ,
+            data: 0 ,
+            target: 0 ,
+            type: 0 ,
+            properties: 0 ,
+            measurements: 0 ,
+            kind: 0 ,
+            value: 0 ,
+            count: 0 ,
+            min: 0 ,
+            max: 0 ,
+            stdDev: 0 ,
+            dependencyKind: 0 ,
+            dependencySource: 0 ,
+            commandName: 0 ,
+            dependencyTypeName: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        _self.id = id;
+        _self[_DYN_DURATION ] = msToTimeSpan(value);
+        _self.success = success;
+        _self.resultCode = resultCode + "";
+        _self.type = dataSanitizeString(logger, requestAPI);
+        var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
+        _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
+        _self.target = dataSanitizeString(logger, dependencyFields.target);
+        if (correlationContext) {
+            _self.target = "".concat(_self.target, " | ").concat(correlationContext);
+        }
+        _self[_DYN_NAME ] = dataSanitizeString(logger, dependencyFields[_DYN_NAME ]);
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+    }
+    RemoteDependencyData.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
+    RemoteDependencyData.dataType = "RemoteDependencyData";
+    return RemoteDependencyData;
+}());
+
+var Trace = /** @class */ (function () {
+    function Trace(logger, message, severityLevel, properties, measurements) {
+        this.aiDataContract = {
+            ver: 1 ,
+            message: 1 ,
+            severityLevel: 0 ,
+            properties: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        message = message || strNotSpecified;
+        _self[_DYN_MESSAGE ] = dataSanitizeMessage(logger, message);
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+        if (severityLevel) {
+            _self[_DYN_SEVERITY_LEVEL ] = severityLevel;
+        }
+    }
+    Trace.envelopeType = "Microsoft.ApplicationInsights.{0}.Message";
+    Trace.dataType = "MessageData";
+    return Trace;
+}());
+
+var PageViewPerformance = /** @class */ (function () {
+    function PageViewPerformance(logger, name, url, unused, properties, measurements, cs4BaseData) {
+        this.aiDataContract = {
+            ver: 1 ,
+            name: 0 ,
+            url: 0 ,
+            duration: 0 ,
+            perfTotal: 0 ,
+            networkConnect: 0 ,
+            sentRequest: 0 ,
+            receivedResponse: 0 ,
+            domProcessing: 0 ,
+            properties: 0 ,
+            measurements: 0
+        };
+        var _self = this;
+        _self.ver = 2;
+        _self.url = dataSanitizeUrl(logger, url);
+        _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
+        _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+        _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
+        if (cs4BaseData) {
+            _self.domProcessing = cs4BaseData.domProcessing;
+            _self[_DYN_DURATION ] = cs4BaseData[_DYN_DURATION ];
+            _self.networkConnect = cs4BaseData.networkConnect;
+            _self.perfTotal = cs4BaseData.perfTotal;
+            _self[_DYN_RECEIVED_RESPONSE ] = cs4BaseData[_DYN_RECEIVED_RESPONSE ];
+            _self.sentRequest = cs4BaseData.sentRequest;
+        }
+    }
+    PageViewPerformance.envelopeType = "Microsoft.ApplicationInsights.{0}.PageviewPerformance";
+    PageViewPerformance.dataType = "PageviewPerformanceData";
+    return PageViewPerformance;
+}());
+
+var Data = /** @class */ (function () {
+    function Data(baseType, data) {
+        this.aiDataContract = {
+            baseType: 1 ,
+            baseData: 1
+        };
+        this.baseType = baseType;
+        this.baseData = data;
+    }
+    return Data;
+}());
+
+var SeverityLevel = createEnumStyle({
+    Verbose: 0 ,
+    Information: 1 ,
+    Warning: 2 ,
+    Error: 3 ,
+    Critical: 4
+});
+
+var ConfigurationManager = /** @class */ (function () {
+    function ConfigurationManager() {
+    }
+    ConfigurationManager.getConfig = function (config, field, identifier, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = false; }
+        var configValue;
+        if (identifier && config[_DYN_EXTENSION_CONFIG ] && config[_DYN_EXTENSION_CONFIG ][identifier] && !isNullOrUndefined(config[_DYN_EXTENSION_CONFIG ][identifier][field])) {
+            configValue = config[_DYN_EXTENSION_CONFIG ][identifier][field];
+        }
+        else {
+            configValue = config[field];
+        }
+        return !isNullOrUndefined(configValue) ? configValue : defaultValue;
+    };
+    return ConfigurationManager;
+}());
+
+function _aiNameFunc(baseName) {
+    var aiName = "ai." + baseName + ".";
+    return function (name) {
+        return aiName + name;
+    };
+}
+var _aiApplication = _aiNameFunc("application");
+var _aiDevice = _aiNameFunc("device");
+var _aiLocation = _aiNameFunc("location");
+var _aiOperation = _aiNameFunc("operation");
+var _aiSession = _aiNameFunc("session");
+var _aiUser = _aiNameFunc("user");
+var _aiCloud = _aiNameFunc("cloud");
+var _aiInternal = _aiNameFunc("internal");
+var ContextTagKeys = /** @class */ (function (_super) {
+    __extendsFn(ContextTagKeys, _super);
+    function ContextTagKeys() {
+        return _super.call(this) || this;
+    }
+    return ContextTagKeys;
+}(createClassFromInterface({
+    applicationVersion: _aiApplication("ver"),
+    applicationBuild: _aiApplication("build"),
+    applicationTypeId: _aiApplication("typeId"),
+    applicationId: _aiApplication("applicationId"),
+    applicationLayer: _aiApplication("layer"),
+    deviceId: _aiDevice("id"),
+    deviceIp: _aiDevice("ip"),
+    deviceLanguage: _aiDevice("language"),
+    deviceLocale: _aiDevice("locale"),
+    deviceModel: _aiDevice("model"),
+    deviceFriendlyName: _aiDevice("friendlyName"),
+    deviceNetwork: _aiDevice("network"),
+    deviceNetworkName: _aiDevice("networkName"),
+    deviceOEMName: _aiDevice("oemName"),
+    deviceOS: _aiDevice("os"),
+    deviceOSVersion: _aiDevice("osVersion"),
+    deviceRoleInstance: _aiDevice("roleInstance"),
+    deviceRoleName: _aiDevice("roleName"),
+    deviceScreenResolution: _aiDevice("screenResolution"),
+    deviceType: _aiDevice("type"),
+    deviceMachineName: _aiDevice("machineName"),
+    deviceVMName: _aiDevice("vmName"),
+    deviceBrowser: _aiDevice("browser"),
+    deviceBrowserVersion: _aiDevice("browserVersion"),
+    locationIp: _aiLocation("ip"),
+    locationCountry: _aiLocation("country"),
+    locationProvince: _aiLocation("province"),
+    locationCity: _aiLocation("city"),
+    operationId: _aiOperation("id"),
+    operationName: _aiOperation("name"),
+    operationParentId: _aiOperation("parentId"),
+    operationRootId: _aiOperation("rootId"),
+    operationSyntheticSource: _aiOperation("syntheticSource"),
+    operationCorrelationVector: _aiOperation("correlationVector"),
+    sessionId: _aiSession("id"),
+    sessionIsFirst: _aiSession("isFirst"),
+    sessionIsNew: _aiSession("isNew"),
+    userAccountAcquisitionDate: _aiUser("accountAcquisitionDate"),
+    userAccountId: _aiUser("accountId"),
+    userAgent: _aiUser("userAgent"),
+    userId: _aiUser("id"),
+    userStoreRegion: _aiUser("storeRegion"),
+    userAuthUserId: _aiUser("authUserId"),
+    userAnonymousUserAcquisitionDate: _aiUser("anonUserAcquisitionDate"),
+    userAuthenticatedUserAcquisitionDate: _aiUser("authUserAcquisitionDate"),
+    cloudName: _aiCloud("name"),
+    cloudRole: _aiCloud("role"),
+    cloudRoleVer: _aiCloud("roleVer"),
+    cloudRoleInstance: _aiCloud("roleInstance"),
+    cloudEnvironment: _aiCloud("environment"),
+    cloudLocation: _aiCloud("location"),
+    cloudDeploymentUnit: _aiCloud("deploymentUnit"),
+    internalNodeName: _aiInternal("nodeName"),
+    internalSdkVersion: _aiInternal("sdkVersion"),
+    internalAgentVersion: _aiInternal("agentVersion"),
+    internalSnippet: _aiInternal("snippet"),
+    internalSdkSrc: _aiInternal("sdkSrc")
+})));
+
+function createTelemetryItem(item, baseType, envelopeName, logger, customProperties, systemProperties) {
+    var _a;
+    envelopeName = dataSanitizeString(logger, envelopeName) || strNotSpecified;
+    if (isNullOrUndefined(item) ||
+        isNullOrUndefined(baseType) ||
+        isNullOrUndefined(envelopeName)) {
+        throwError("Input doesn't contain all required fields");
+    }
+    var iKey = "";
+    if (item[strIkey]) {
+        iKey = item[strIkey];
+        delete item[strIkey];
+    }
+    var telemetryItem = (_a = {},
+        _a[_DYN_NAME ] = envelopeName,
+        _a.time = toISOString(new Date()),
+        _a.iKey = iKey,
+        _a.ext = systemProperties ? systemProperties : {},
+        _a.tags = [],
+        _a.data = {},
+        _a.baseType = baseType,
+        _a.baseData = item
+    ,
+        _a);
+    if (!isNullOrUndefined(customProperties)) {
+        objForEachKey(customProperties, function (prop, value) {
+            telemetryItem.data[prop] = value;
+        });
+    }
+    return telemetryItem;
+}
+var TelemetryItemCreator = /** @class */ (function () {
+    function TelemetryItemCreator() {
+    }
+    TelemetryItemCreator.create = createTelemetryItem;
+    return TelemetryItemCreator;
+}());
+
+var Extensions = {
+    UserExt: "user",
+    DeviceExt: "device",
+    TraceExt: "trace",
+    WebExt: "web",
+    AppExt: "app",
+    OSExt: "os",
+    SessionExt: "ses",
+    SDKExt: "sdk"
+};
+var CtxTagKeys = new ContextTagKeys();
+
+function createDomEvent(eventName) {
+    var event = null;
+    if (isFunction(Event)) {
+        event = new Event(eventName);
+    }
+    else {
+        var doc = getDocument();
+        if (doc && doc.createEvent) {
+            event = doc.createEvent("Event");
+            event.initEvent(eventName, true, true);
+        }
+    }
+    return event;
+}
+
+var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
+var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
+var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
+
+exports.AnalyticsPluginIdentifier = AnalyticsPluginIdentifier;
+exports.BreezeChannelIdentifier = BreezeChannelIdentifier;
+exports.ConfigurationManager = ConfigurationManager;
+exports.ConnectionStringParser = ConnectionStringParser;
+exports.ContextTagKeys = ContextTagKeys;
+exports.CtxTagKeys = CtxTagKeys;
+exports.DEFAULT_BREEZE_ENDPOINT = DEFAULT_BREEZE_ENDPOINT;
+exports.DEFAULT_BREEZE_PATH = DEFAULT_BREEZE_PATH;
+exports.Data = Data;
+exports.DisabledPropertyName = DisabledPropertyName;
+exports.DistributedTracingModes = DistributedTracingModes;
+exports.Envelope = Envelope;
+exports.Event = Event$1;
+exports.Exception = Exception;
+exports.Extensions = Extensions;
+exports.HttpMethod = HttpMethod;
+exports.Metric = Metric;
+exports.PageView = PageView;
+exports.PageViewPerformance = PageViewPerformance;
+exports.ProcessLegacy = ProcessLegacy;
+exports.PropertiesPluginIdentifier = PropertiesPluginIdentifier;
+exports.RemoteDependencyData = RemoteDependencyData;
+exports.RequestHeaders = RequestHeaders;
+exports.SampleRate = SampleRate;
+exports.SeverityLevel = SeverityLevel;
+exports.TelemetryItemCreator = TelemetryItemCreator;
+exports.ThrottleMgr = ThrottleMgr;
+exports.Trace = Trace;
+exports.correlationIdCanIncludeCorrelationHeader = correlationIdCanIncludeCorrelationHeader;
+exports.correlationIdGetCorrelationContext = correlationIdGetCorrelationContext;
+exports.correlationIdGetCorrelationContextValue = correlationIdGetCorrelationContextValue;
+exports.correlationIdGetPrefix = correlationIdGetPrefix;
+exports.correlationIdSetPrefix = correlationIdSetPrefix;
+exports.createDistributedTraceContextFromTrace = createDistributedTraceContextFromTrace;
+exports.createDomEvent = createDomEvent;
+exports.createTelemetryItem = createTelemetryItem;
+exports.createTraceParent = createTraceParent;
+exports.dataSanitizeException = dataSanitizeException;
+exports.dataSanitizeId = dataSanitizeId;
+exports.dataSanitizeInput = dataSanitizeInput;
+exports.dataSanitizeKey = dataSanitizeKey;
+exports.dataSanitizeKeyAndAddUniqueness = dataSanitizeKeyAndAddUniqueness;
+exports.dataSanitizeMeasurements = dataSanitizeMeasurements;
+exports.dataSanitizeMessage = dataSanitizeMessage;
+exports.dataSanitizeProperties = dataSanitizeProperties;
+exports.dataSanitizeString = dataSanitizeString;
+exports.dataSanitizeUrl = dataSanitizeUrl;
+exports.dateTimeUtilsDuration = dateTimeUtilsDuration;
+exports.dateTimeUtilsNow = dateTimeUtilsNow;
+exports.dsPadNumber = dsPadNumber;
+exports.findW3cTraceParent = findW3cTraceParent;
+exports.formatTraceParent = formatTraceParent;
+exports.getExtensionByName = getExtensionByName;
+exports.isBeaconApiSupported = isBeaconsSupported;
+exports.isCrossOriginError = isCrossOriginError;
+exports.isInternalApplicationInsightsEndpoint = isInternalApplicationInsightsEndpoint;
+exports.isSampledFlag = isSampledFlag;
+exports.isValidSpanId = isValidSpanId;
+exports.isValidTraceId = isValidTraceId;
+exports.isValidTraceParent = isValidTraceParent;
+exports.msToTimeSpan = msToTimeSpan;
+exports.parseConnectionString = parseConnectionString;
+exports.parseTraceParent = parseTraceParent;
+exports.strNotSpecified = strNotSpecified;
+exports.stringToBoolOrDefault = stringToBoolOrDefault;
+exports.urlGetAbsoluteUrl = urlGetAbsoluteUrl;
+exports.urlGetCompleteUrl = urlGetCompleteUrl;
+exports.urlGetPathName = urlGetPathName;
+exports.urlParseFullHost = urlParseFullHost;
+exports.urlParseHost = urlParseHost;
+exports.urlParseUrl = urlParseUrl;
+exports.utlCanUseLocalStorage = utlCanUseLocalStorage;
+exports.utlCanUseSessionStorage = utlCanUseSessionStorage;
+exports.utlDisableStorage = utlDisableStorage;
+exports.utlEnableStorage = utlEnableStorage;
+exports.utlGetLocalStorage = utlGetLocalStorage;
+exports.utlGetSessionStorage = utlGetSessionStorage;
+exports.utlGetSessionStorageKeys = utlGetSessionStorageKeys;
+exports.utlRemoveSessionStorage = utlRemoveSessionStorage;
+exports.utlRemoveStorage = utlRemoveStorage;
+exports.utlSetLocalStorage = utlSetLocalStorage;
+exports.utlSetSessionStorage = utlSetSessionStorage;
+//# sourceMappingURL=applicationinsights-common.cjs.js.map