@vc-shell/framework 1.1.44 → 1.1.46

package/dist/vendor-microsoft-applicationinsights-channel-js-Dyd_PXA3.js

@@ -0,0 +1,2153 @@
+import { d as dynamicProto } from './vendor-microsoft-dynamicproto-js-CFBBUu9p.js';
+import { E as Event, T as Trace, P as PageView, f as PageViewPerformance, g as Exception, M as Metric, R as RemoteDependencyData, q as Envelope, H as HttpMethod, C as CtxTagKeys, n as dataSanitizeString, S as SampleRate, r as Data, a as utlGetSessionStorage, b as utlSetSessionStorage, c as utlRemoveSessionStorage, t as ContextTagKeys, B as BreezeChannelIdentifier, v as createOfflineListener, u as utlCanUseSessionStorage, w as isInternalApplicationInsightsEndpoint, x as ProcessLegacy, y as RequestHeaders, z as DEFAULT_BREEZE_ENDPOINT, F as DEFAULT_BREEZE_PATH, k as utlSetStoragePrefix } from './vendor-microsoft-applicationinsights-common-CfmP1_Qr.js';
+import { i as isNullOrUndefined, x as objForEachKey, D as isNumber, w as isString, E as isTruthy, d as arrForEach, r as isFunction, F as arrIndexOf, v as isArray, e as dumpObj, A as isObject, n as objDeepFreeze, G as isPromiseLike, o as objDefine, m as mathFloor, H as mathMax, I as mathMin, u as utcNow, s as scheduleTimeout, J as getInst } from './vendor-nevware21-ts-utils-e8v8Jty3.js';
+import { b as _warnToConsole, _ as _throwInternal, h as hasJSON, c as getJSON, x as toISOString, y as optimizeObject, z as setValue, a as getExceptionName, s as safeGetLogger, m as mergeEvtNamespace, e as createUniqueNamespace, o as onConfigChange, i as createProcessTelemetryContext, A as ActiveStatus, C as isBeaconsSupported, v as isFetchSupported, S as SenderPostManager, D as prependTransports, E as getIEVersion, F as runTargetUnload, G as parseResponse, H as formatErrorMessageXdr, J as formatErrorMessageXhr, K as isFeatureEnabled, n as cfgDfValidate, l as cfgDfBoolean, L as objExtend, B as BaseTelemetryPlugin } from './vendor-microsoft-applicationinsights-core-js-Cq4YSEvZ.js';
+import { a as __assignFn, _ as __extendsFn } from './vendor-microsoft-applicationinsights-shims-CX8sJgar.js';
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+// ###################################################################################################################################################
+// Note: DON'T Export these const from the package as we are still targeting IE/ES5 this will export a mutable variables that someone could change ###
+// ###################################################################################################################################################
+// Generally you should only put values that are used more than 2 times and then only if not already exposed as a constant (such as SdkCoreNames)
+// as when using "short" named values from here they will be will be minified smaller than the SdkCoreNames[eSdkCoreNames.xxxx] value.
+var STR_DURATION = "duration";
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+// @skip-file-minify
+// ##############################################################
+// AUTO GENERATED FILE: This file is Auto Generated during build.
+// ##############################################################
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// Note: DON'T Export these const from the package as we are still targeting ES5 which can result in a mutable variables that someone could change!!!
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+var _DYN_TAGS = "tags"; // Count: 17
+var _DYN_DEVICE_TYPE = "deviceType"; // Count: 3
+var _DYN_DATA = "data"; // Count: 13
+var _DYN_NAME = "name"; // Count: 8
+var _DYN_TRACE_ID = "traceID"; // Count: 5
+var _DYN_LENGTH = "length"; // Count: 38
+var _DYN_STRINGIFY = "stringify"; // Count: 5
+var _DYN_MEASUREMENTS = "measurements"; // Count: 7
+var _DYN_DATA_TYPE = "dataType"; // Count: 10
+var _DYN_ENVELOPE_TYPE = "envelopeType"; // Count: 7
+var _DYN_TO_STRING = "toString"; // Count: 7
+var _DYN_ENQUEUE = "enqueue"; // Count: 7
+var _DYN_COUNT = "count"; // Count: 7
+var _DYN_PUSH = "push"; // Count: 9
+var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson"; // Count: 3
+var _DYN_CLEAR = "clear"; // Count: 6
+var _DYN_MARK_AS_SENT = "markAsSent"; // Count: 4
+var _DYN_CLEAR_SENT = "clearSent"; // Count: 5
+var _DYN_BUFFER_OVERRIDE = "bufferOverride"; // Count: 3
+var _DYN__BUFFER__KEY = "BUFFER_KEY"; // Count: 5
+var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY"; // Count: 8
+var _DYN_CONCAT = "concat"; // Count: 6
+var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE"; // Count: 5
+var _DYN_TRIGGER_SEND = "triggerSend"; // Count: 5
+var _DYN_DIAG_LOG = "diagLog"; // Count: 16
+var _DYN_INITIALIZE = "initialize"; // Count: 3
+var _DYN__SENDER = "_sender"; // Count: 5
+var _DYN_ENDPOINT_URL = "endpointUrl"; // Count: 5
+var _DYN_INSTRUMENTATION_KEY = "instrumentationKey"; // Count: 5
+var _DYN_CUSTOM_HEADERS = "customHeaders"; // Count: 3
+var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes"; // Count: 2
+var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon"; // Count: 3
+var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled"; // Count: 3
+var _DYN_ALWAYS_USE_XHR_OVERR4 = "alwaysUseXhrOverride"; // Count: 2
+var _DYN_ENABLE_SESSION_STORA5 = "enableSessionStorageBuffer"; // Count: 2
+var _DYN__BUFFER = "_buffer"; // Count: 9
+var _DYN_ONUNLOAD_DISABLE_FET6 = "onunloadDisableFetch"; // Count: 2
+var _DYN_DISABLE_SEND_BEACON_7 = "disableSendBeaconSplit"; // Count: 2
+var _DYN_GET_SENDER_INST = "getSenderInst"; // Count: 4
+var _DYN__ON_ERROR = "_onError"; // Count: 7
+var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess"; // Count: 3
+var _DYN__ON_SUCCESS = "_onSuccess"; // Count: 6
+var _DYN_ITEMS_RECEIVED = "itemsReceived"; // Count: 3
+var _DYN_ITEMS_ACCEPTED = "itemsAccepted"; // Count: 3
+var _DYN_BASE_TYPE = "baseType"; // Count: 4
+var _DYN_SAMPLE_RATE = "sampleRate"; // Count: 4
+var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore"; // Count: 4
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+// these two constants are used to filter out properties not needed when trying to extract custom properties and measurements from the incoming payload
+var strBaseType = "baseType";
+var strBaseData = "baseData";
+var strProperties = "properties";
+var strTrue = "true";
+function _setValueIf(target, field, value) {
+    return setValue(target, field, value, isTruthy);
+}
+/*
+ * Maps Part A data from CS 4.0
+ */
+function _extractPartAExtensions(logger, item, env) {
+    // todo: switch to keys from common in this method
+    var envTags = env[_DYN_TAGS /* @min:%2etags */] = env[_DYN_TAGS /* @min:%2etags */] || {};
+    var itmExt = item.ext = item.ext || {};
+    var itmTags = item[_DYN_TAGS /* @min:%2etags */] = item[_DYN_TAGS /* @min:%2etags */] || [];
+    var extUser = itmExt.user;
+    if (extUser) {
+        _setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
+        _setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
+    }
+    var extApp = itmExt.app;
+    if (extApp) {
+        _setValueIf(envTags, CtxTagKeys.sessionId, extApp.sesId);
+    }
+    var extDevice = itmExt.device;
+    if (extDevice) {
+        _setValueIf(envTags, CtxTagKeys.deviceId, extDevice.id || extDevice.localId);
+        _setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE /* @min:%2edeviceType */], extDevice.deviceClass);
+        _setValueIf(envTags, CtxTagKeys.deviceIp, extDevice.ip);
+        _setValueIf(envTags, CtxTagKeys.deviceModel, extDevice.model);
+        _setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE /* @min:%2edeviceType */], extDevice[_DYN_DEVICE_TYPE /* @min:%2edeviceType */]);
+    }
+    var web = item.ext.web;
+    if (web) {
+        _setValueIf(envTags, CtxTagKeys.deviceLanguage, web.browserLang);
+        _setValueIf(envTags, CtxTagKeys.deviceBrowserVersion, web.browserVer);
+        _setValueIf(envTags, CtxTagKeys.deviceBrowser, web.browser);
+        var envData = env[_DYN_DATA /* @min:%2edata */] = env[_DYN_DATA /* @min:%2edata */] || {};
+        var envBaseData = envData[strBaseData] = envData[strBaseData] || {};
+        var envProps = envBaseData[strProperties] = envBaseData[strProperties] || {};
+        _setValueIf(envProps, "domain", web.domain);
+        _setValueIf(envProps, "isManual", web.isManual ? strTrue : null);
+        _setValueIf(envProps, "screenRes", web.screenRes);
+        _setValueIf(envProps, "userConsent", web.userConsent ? strTrue : null);
+    }
+    var extOs = itmExt.os;
+    if (extOs) {
+        _setValueIf(envTags, CtxTagKeys.deviceOS, extOs[_DYN_NAME /* @min:%2ename */]);
+        _setValueIf(envTags, CtxTagKeys.deviceOSVersion, extOs.osVer);
+    }
+    // No support for mapping Trace.traceState to 2.0 as it is currently empty
+    var extTrace = itmExt.trace;
+    if (extTrace) {
+        _setValueIf(envTags, CtxTagKeys.operationParentId, extTrace.parentID);
+        _setValueIf(envTags, CtxTagKeys.operationName, dataSanitizeString(logger, extTrace[_DYN_NAME /* @min:%2ename */]));
+        _setValueIf(envTags, CtxTagKeys.operationId, extTrace[_DYN_TRACE_ID /* @min:%2etraceID */]);
+    }
+    // Sample 4.0 schema
+    //  {
+    //     "time" : "2018-09-05T22:51:22.4936Z",
+    //     "name" : "MetricWithNamespace",
+    //     "iKey" : "ABC-5a4cbd20-e601-4ef5-a3c6-5d6577e4398e",
+    //     "ext": {  "cloud": {
+    //          "role": "WATSON3",
+    //          "roleInstance": "CO4AEAP00000260"
+    //      },
+    //      "device": {}, "correlation": {} },
+    //      "tags": [
+    //        { "amazon.region" : "east2" },
+    //        { "os.expid" : "wp:02df239" }
+    //     ]
+    //   }
+    var tgs = {};
+    // deals with tags.push({object})
+    for (var i = itmTags[_DYN_LENGTH /* @min:%2elength */] - 1; i >= 0; i--) {
+        var tg = itmTags[i];
+        objForEachKey(tg, function (key, value) {
+            tgs[key] = value;
+        });
+        itmTags.splice(i, 1);
+    }
+    // deals with tags[key]=value (and handles hasOwnProperty)
+    objForEachKey(itmTags, function (tg, value) {
+        tgs[tg] = value;
+    });
+    var theTags = __assignFn(__assignFn({}, envTags), tgs);
+    if (!theTags[CtxTagKeys.internalSdkVersion]) {
+        // Append a version in case it is not already set
+        theTags[CtxTagKeys.internalSdkVersion] = dataSanitizeString(logger, "javascript:".concat(EnvelopeCreator.Version), 64);
+    }
+    env[_DYN_TAGS /* @min:%2etags */] = optimizeObject(theTags);
+}
+function _extractPropsAndMeasurements(data, properties, measurements) {
+    if (!isNullOrUndefined(data)) {
+        objForEachKey(data, function (key, value) {
+            if (isNumber(value)) {
+                measurements[key] = value;
+            }
+            else if (isString(value)) {
+                properties[key] = value;
+            }
+            else if (hasJSON()) {
+                properties[key] = getJSON()[_DYN_STRINGIFY /* @min:%2estringify */](value);
+            }
+        });
+    }
+}
+function _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue) {
+    if (!isNullOrUndefined(properties)) {
+        objForEachKey(properties, function (key, value) {
+            properties[key] = value || customUndefinedValue;
+        });
+    }
+}
+// TODO: Do we want this to take logger as arg or use this._logger as nonstatic?
+function _createEnvelope(logger, envelopeType, telemetryItem, data) {
+    var envelope = new Envelope(logger, data, envelopeType);
+    _setValueIf(envelope, "sampleRate", telemetryItem[SampleRate]);
+    if ((telemetryItem[strBaseData] || {}).startTime) {
+        // Starting from Version 3.0.3, the time property will be assigned by the startTime value,
+        // which records the loadEvent time for the pageView event.
+        envelope.time = toISOString(telemetryItem[strBaseData].startTime);
+    }
+    envelope.iKey = telemetryItem.iKey;
+    var iKeyNoDashes = telemetryItem.iKey.replace(/-/g, "");
+    envelope[_DYN_NAME /* @min:%2ename */] = envelope[_DYN_NAME /* @min:%2ename */].replace("{0}", iKeyNoDashes);
+    // extract all extensions from ctx
+    _extractPartAExtensions(logger, telemetryItem, envelope);
+    // loop through the envelope tags (extension of Part A) and pick out the ones that should go in outgoing envelope tags
+    telemetryItem[_DYN_TAGS /* @min:%2etags */] = telemetryItem[_DYN_TAGS /* @min:%2etags */] || [];
+    return optimizeObject(envelope);
+}
+function EnvelopeCreatorInit(logger, telemetryItem) {
+    if (isNullOrUndefined(telemetryItem[strBaseData])) {
+        _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 46 /* _eInternalMessageId.TelemetryEnvelopeInvalid */, "telemetryItem.baseData cannot be null.");
+    }
+}
+var EnvelopeCreator = {
+    Version: '3.3.9'
+};
+function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    var customProperties = telemetryItem[strBaseData][strProperties] || {};
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var bd = telemetryItem[strBaseData];
+    if (isNullOrUndefined(bd)) {
+        _warnToConsole(logger, "Invalid input for dependency data");
+        return null;
+    }
+    var method = bd[strProperties] && bd[strProperties][HttpMethod] ? bd[strProperties][HttpMethod] : "GET";
+    var remoteDepData = new RemoteDependencyData(logger, bd.id, bd.target, bd[_DYN_NAME /* @min:%2ename */], bd[STR_DURATION /* @min:%2eduration */], bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
+    var data = new Data(RemoteDependencyData[_DYN_DATA_TYPE /* @min:%2edataType */], remoteDepData);
+    return _createEnvelope(logger, RemoteDependencyData[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function EventEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var customProperties = {};
+    var customMeasurements = {};
+    if (telemetryItem[strBaseType] !== Event[_DYN_DATA_TYPE /* @min:%2edataType */]) {
+        customProperties["baseTypeSource"] = telemetryItem[strBaseType]; // save the passed in base type as a property
+    }
+    if (telemetryItem[strBaseType] === Event[_DYN_DATA_TYPE /* @min:%2edataType */]) { // take collection
+        customProperties = telemetryItem[strBaseData][strProperties] || {};
+        customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    }
+    else { // if its not a known type, convert to custom event
+        if (telemetryItem[strBaseData]) {
+            _extractPropsAndMeasurements(telemetryItem[strBaseData], customProperties, customMeasurements);
+        }
+    }
+    // Extract root level properties from part C telemetryItem.data
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var eventName = telemetryItem[strBaseData][_DYN_NAME /* @min:%2ename */];
+    var eventData = new Event(logger, eventName, customProperties, customMeasurements);
+    var data = new Data(Event[_DYN_DATA_TYPE /* @min:%2edataType */], eventData);
+    return _createEnvelope(logger, Event[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function ExceptionEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    // Extract root level properties from part C telemetryItem.data
+    var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    var customProperties = telemetryItem[strBaseData][strProperties] || {};
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], customProperties, customMeasurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
+    }
+    var bd = telemetryItem[strBaseData];
+    var exData = Exception.CreateFromInterface(logger, bd, customProperties, customMeasurements);
+    var data = new Data(Exception[_DYN_DATA_TYPE /* @min:%2edataType */], exData);
+    return _createEnvelope(logger, Exception[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function MetricEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var baseData = telemetryItem[strBaseData];
+    var props = baseData[strProperties] || {};
+    var measurements = baseData[_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], props, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
+    }
+    var baseMetricData = new Metric(logger, baseData[_DYN_NAME /* @min:%2ename */], baseData.average, baseData.sampleCount, baseData.min, baseData.max, baseData.stdDev, props, measurements);
+    var data = new Data(Metric[_DYN_DATA_TYPE /* @min:%2edataType */], baseMetricData);
+    return _createEnvelope(logger, Metric[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function PageViewEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    // Since duration is not part of the domain properties in Common Schema, extract it from part C
+    var duration;
+    var baseData = telemetryItem[strBaseData];
+    if (!isNullOrUndefined(baseData) &&
+        !isNullOrUndefined(baseData[strProperties]) &&
+        !isNullOrUndefined(baseData[strProperties][STR_DURATION])) { // from part B properties
+        duration = baseData[strProperties][STR_DURATION];
+        delete baseData[strProperties][STR_DURATION];
+    }
+    else if (!isNullOrUndefined(telemetryItem[_DYN_DATA /* @min:%2edata */]) &&
+        !isNullOrUndefined(telemetryItem[_DYN_DATA /* @min:%2edata */][STR_DURATION])) { // from custom properties
+        duration = telemetryItem[_DYN_DATA /* @min:%2edata */][STR_DURATION];
+        delete telemetryItem[_DYN_DATA /* @min:%2edata */][STR_DURATION];
+    }
+    var bd = telemetryItem[strBaseData];
+    // special case: pageview.id is grabbed from current operation id. Analytics plugin is decoupled from properties plugin, so this is done here instead. This can be made a default telemetry intializer instead if needed to be decoupled from channel
+    var currentContextId;
+    if (((telemetryItem.ext || {}).trace || {})[_DYN_TRACE_ID /* @min:%2etraceID */]) {
+        currentContextId = telemetryItem.ext.trace[_DYN_TRACE_ID /* @min:%2etraceID */];
+    }
+    var id = bd.id || currentContextId;
+    var name = bd[_DYN_NAME /* @min:%2ename */];
+    var url = bd.uri;
+    var properties = bd[strProperties] || {};
+    var measurements = bd[_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    // refUri is a field that Breeze still does not recognize as part of Part B. For now, put it in Part C until it supports it as a domain property
+    if (!isNullOrUndefined(bd.refUri)) {
+        properties["refUri"] = bd.refUri;
+    }
+    // pageType is a field that Breeze still does not recognize as part of Part B. For now, put it in Part C until it supports it as a domain property
+    if (!isNullOrUndefined(bd.pageType)) {
+        properties["pageType"] = bd.pageType;
+    }
+    // isLoggedIn is a field that Breeze still does not recognize as part of Part B. For now, put it in Part C until it supports it as a domain property
+    if (!isNullOrUndefined(bd.isLoggedIn)) {
+        properties["isLoggedIn"] = bd.isLoggedIn[_DYN_TO_STRING /* @min:%2etoString */]();
+    }
+    // pageTags is a field that Breeze still does not recognize as part of Part B. For now, put it in Part C until it supports it as a domain property
+    if (!isNullOrUndefined(bd[strProperties])) {
+        var pageTags = bd[strProperties];
+        objForEachKey(pageTags, function (key, value) {
+            properties[key] = value;
+        });
+    }
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], properties, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
+    }
+    var pageViewData = new PageView(logger, name, url, duration, properties, measurements, id);
+    var data = new Data(PageView[_DYN_DATA_TYPE /* @min:%2edataType */], pageViewData);
+    return _createEnvelope(logger, PageView[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function PageViewPerformanceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var bd = telemetryItem[strBaseData];
+    var name = bd[_DYN_NAME /* @min:%2ename */];
+    var url = bd.uri || bd.url;
+    var properties = bd[strProperties] || {};
+    var measurements = bd[_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], properties, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
+    }
+    var baseData = new PageViewPerformance(logger, name, url, undefined, properties, measurements, bd);
+    var data = new Data(PageViewPerformance[_DYN_DATA_TYPE /* @min:%2edataType */], baseData);
+    return _createEnvelope(logger, PageViewPerformance[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+function TraceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
+    EnvelopeCreatorInit(logger, telemetryItem);
+    var message = telemetryItem[strBaseData].message;
+    var severityLevel = telemetryItem[strBaseData].severityLevel;
+    var props = telemetryItem[strBaseData][strProperties] || {};
+    var measurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS /* @min:%2emeasurements */] || {};
+    _extractPropsAndMeasurements(telemetryItem[_DYN_DATA /* @min:%2edata */], props, measurements);
+    if (!isNullOrUndefined(customUndefinedValue)) {
+        _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
+    }
+    var baseData = new Trace(logger, message, severityLevel, props, measurements);
+    var data = new Data(Trace[_DYN_DATA_TYPE /* @min:%2edataType */], baseData);
+    return _createEnvelope(logger, Trace[_DYN_ENVELOPE_TYPE /* @min:%2eenvelopeType */], telemetryItem, data);
+}
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+var BaseSendBuffer = /** @class */ (function () {
+    function BaseSendBuffer(logger, config) {
+        var _buffer = [];
+        var _bufferFullMessageSent = false;
+        var _maxRetryCnt = config.maxRetryCnt;
+        this._get = function () {
+            return _buffer;
+        };
+        this._set = function (buffer) {
+            _buffer = buffer;
+            return _buffer;
+        };
+        dynamicProto(BaseSendBuffer, this, function (_self) {
+            _self[_DYN_ENQUEUE /* @min:%2eenqueue */] = function (payload) {
+                if (_self[_DYN_COUNT /* @min:%2ecount */]() >= config.eventsLimitInMem) {
+                    // sent internal log only once per page view
+                    if (!_bufferFullMessageSent) {
+                        _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 105 /* _eInternalMessageId.InMemoryStorageBufferFull */, "Maximum in-memory buffer size reached: " + _self[_DYN_COUNT /* @min:%2ecount */](), true);
+                        _bufferFullMessageSent = true;
+                    }
+                    return;
+                }
+                payload.cnt = payload.cnt || 0;
+                // max retry is defined, and max retry is reached, do not add the payload to buffer
+                if (!isNullOrUndefined(_maxRetryCnt)) {
+                    if (payload.cnt > _maxRetryCnt) {
+                        // TODO: add log here on dropping payloads
+                        // will log statsbeat exception later here
+                        return;
+                    }
+                }
+                _buffer[_DYN_PUSH /* @min:%2epush */](payload);
+                return;
+            };
+            _self[_DYN_COUNT /* @min:%2ecount */] = function () {
+                return _buffer[_DYN_LENGTH /* @min:%2elength */];
+            };
+            _self.size = function () {
+                var size = _buffer[_DYN_LENGTH /* @min:%2elength */];
+                for (var lp = 0; lp < _buffer[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                    size += (_buffer[lp].item)[_DYN_LENGTH /* @min:%2elength */];
+                }
+                if (!config[_DYN_EMIT_LINE_DELIMITED_0 /* @min:%2eemitLineDelimitedJson */]) {
+                    size += 2;
+                }
+                return size;
+            };
+            _self[_DYN_CLEAR /* @min:%2eclear */] = function () {
+                _buffer = [];
+                _bufferFullMessageSent = false;
+            };
+            _self.getItems = function () {
+                return _buffer.slice(0);
+            };
+            _self.batchPayloads = function (payloads) {
+                if (payloads && payloads[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var payloadStr_1 = [];
+                    arrForEach(payloads, function (payload) {
+                        payloadStr_1[_DYN_PUSH /* @min:%2epush */](payload.item);
+                    });
+                    var batch = config[_DYN_EMIT_LINE_DELIMITED_0 /* @min:%2eemitLineDelimitedJson */] ?
+                        payloadStr_1.join("\n") :
+                        "[" + payloadStr_1.join(",") + "]";
+                    return batch;
+                }
+                return null;
+            };
+            _self.createNew = function (newLogger, newConfig, canUseSessionStorage) {
+                var items = _buffer.slice(0);
+                newLogger = newLogger || logger;
+                newConfig = newConfig || {};
+                var newBuffer = !!canUseSessionStorage ? new SessionStorageSendBuffer(newLogger, newConfig) : new ArraySendBuffer(newLogger, newConfig);
+                arrForEach(items, function (payload) {
+                    newBuffer[_DYN_ENQUEUE /* @min:%2eenqueue */](payload);
+                });
+                return newBuffer;
+            };
+        });
+    }
+// Removed Stub for BaseSendBuffer.prototype.enqueue.
+// Removed Stub for BaseSendBuffer.prototype.count.
+// Removed Stub for BaseSendBuffer.prototype.size.
+// Removed Stub for BaseSendBuffer.prototype.clear.
+// Removed Stub for BaseSendBuffer.prototype.getItems.
+// Removed Stub for BaseSendBuffer.prototype.batchPayloads.
+// Removed Stub for BaseSendBuffer.prototype.createNew.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    BaseSendBuffer.__ieDyn=1;
+
+    return BaseSendBuffer;
+}());
+/*
+ * An array based send buffer.
+ */
+var ArraySendBuffer = /** @class */ (function (_super) {
+    __extendsFn(ArraySendBuffer, _super);
+    function ArraySendBuffer(logger, config) {
+        var _this = _super.call(this, logger, config) || this;
+        dynamicProto(ArraySendBuffer, _this, function (_self, _base) {
+            _self[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */] = function (payload) {
+                _base[_DYN_CLEAR /* @min:%2eclear */]();
+            };
+            _self[_DYN_CLEAR_SENT /* @min:%2eclearSent */] = function (payload) {
+                // not supported
+            };
+        });
+        return _this;
+    }
+// Removed Stub for ArraySendBuffer.prototype.markAsSent.
+// Removed Stub for ArraySendBuffer.prototype.clearSent.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    ArraySendBuffer.__ieDyn=1;
+
+    return ArraySendBuffer;
+}(BaseSendBuffer));
+var PREVIOUS_KEYS = ["AI_buffer", "AI_sentBuffer"];
+/*
+ * Session storage buffer holds a copy of all unsent items in the browser session storage.
+ */
+var SessionStorageSendBuffer = /** @class */ (function (_super) {
+    __extendsFn(SessionStorageSendBuffer, _super);
+    function SessionStorageSendBuffer(logger, config) {
+        var _this = _super.call(this, logger, config) || this;
+        var _bufferFullMessageSent = false;
+        //Note: should not use config.namePrefix directly, because it will always refers to the latest namePrefix
+        var _namePrefix = config === null || config === void 0 ? void 0 : config.namePrefix;
+        // TODO: add remove buffer override as well
+        var _b = config[_DYN_BUFFER_OVERRIDE /* @min:%2ebufferOverride */] || { getItem: utlGetSessionStorage, setItem: utlSetSessionStorage }, getItem = _b.getItem, setItem = _b.setItem;
+        var _maxRetryCnt = config.maxRetryCnt;
+        dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
+            var bufferItems = _getBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY /* @min:%2eBUFFER_KEY */]);
+            var itemsInSentBuffer = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */]);
+            var previousItems = _getPreviousEvents();
+            var notDeliveredItems = itemsInSentBuffer[_DYN_CONCAT /* @min:%2econcat */](previousItems);
+            var buffer = _self._set(bufferItems[_DYN_CONCAT /* @min:%2econcat */](notDeliveredItems));
+            // If the buffer has too many items, drop items from the end.
+            if (buffer[_DYN_LENGTH /* @min:%2elength */] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE /* @min:%2eMAX_BUFFER_SIZE */]) {
+                buffer[_DYN_LENGTH /* @min:%2elength */] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE /* @min:%2eMAX_BUFFER_SIZE */];
+            }
+            _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */], []);
+            _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY /* @min:%2eBUFFER_KEY */], buffer);
+            _self[_DYN_ENQUEUE /* @min:%2eenqueue */] = function (payload) {
+                if (_self[_DYN_COUNT /* @min:%2ecount */]() >= SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE /* @min:%2eMAX_BUFFER_SIZE */]) {
+                    // sent internal log only once per page view
+                    if (!_bufferFullMessageSent) {
+                        _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 67 /* _eInternalMessageId.SessionStorageBufferFull */, "Maximum buffer size reached: " + _self[_DYN_COUNT /* @min:%2ecount */](), true);
+                        _bufferFullMessageSent = true;
+                    }
+                    return;
+                }
+                payload.cnt = payload.cnt || 0;
+                // max retry is defined, and max retry is reached, do not add the payload to buffer
+                if (!isNullOrUndefined(_maxRetryCnt)) {
+                    if (payload.cnt > _maxRetryCnt) {
+                        // TODO: add log here on dropping payloads
+                        return;
+                    }
+                }
+                _base[_DYN_ENQUEUE /* @min:%2eenqueue */](payload);
+                _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY /* @min:%2eBUFFER_KEY */], _self._get());
+            };
+            _self[_DYN_CLEAR /* @min:%2eclear */] = function () {
+                _base[_DYN_CLEAR /* @min:%2eclear */]();
+                _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY /* @min:%2eBUFFER_KEY */], _self._get());
+                _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */], []);
+                _bufferFullMessageSent = false;
+            };
+            _self[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */] = function (payload) {
+                _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY /* @min:%2eBUFFER_KEY */], _self._set(_removePayloadsFromBuffer(payload, _self._get())));
+                var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */]);
+                if (sentElements instanceof Array && payload instanceof Array) {
+                    sentElements = sentElements[_DYN_CONCAT /* @min:%2econcat */](payload);
+                    if (sentElements[_DYN_LENGTH /* @min:%2elength */] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE /* @min:%2eMAX_BUFFER_SIZE */]) {
+                        // We send telemetry normally. If the SENT_BUFFER is too big we don't add new elements
+                        // until we receive a response from the backend and the buffer has free space again (see clearSent method)
+                        _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 67 /* _eInternalMessageId.SessionStorageBufferFull */, "Sent buffer reached its maximum size: " + sentElements[_DYN_LENGTH /* @min:%2elength */], true);
+                        sentElements[_DYN_LENGTH /* @min:%2elength */] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE /* @min:%2eMAX_BUFFER_SIZE */];
+                    }
+                    _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */], sentElements);
+                }
+            };
+            _self[_DYN_CLEAR_SENT /* @min:%2eclearSent */] = function (payload) {
+                var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */]);
+                sentElements = _removePayloadsFromBuffer(payload, sentElements);
+                _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */], sentElements);
+            };
+            _self.createNew = function (newLogger, newConfig, canUseSessionStorage) {
+                canUseSessionStorage = !!canUseSessionStorage;
+                var unsentItems = _self._get().slice(0);
+                var sentItems = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY /* @min:%2eSENT_BUFFER_KEY */]).slice(0);
+                newLogger = newLogger || logger;
+                newConfig = newConfig || {};
+                // to make sure that we do not send duplicated payloads when it is switched back to previous one
+                _self[_DYN_CLEAR /* @min:%2eclear */]();
+                var newBuffer = canUseSessionStorage ? new SessionStorageSendBuffer(newLogger, newConfig) : new ArraySendBuffer(newLogger, newConfig);
+                arrForEach(unsentItems, function (payload) {
+                    newBuffer[_DYN_ENQUEUE /* @min:%2eenqueue */](payload);
+                });
+                if (canUseSessionStorage) {
+                    // arr buffer will clear all payloads if markAsSent() is called
+                    newBuffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](sentItems);
+                }
+                return newBuffer;
+            };
+            function _removePayloadsFromBuffer(payloads, buffer) {
+                var remaining = [];
+                var payloadStr = [];
+                arrForEach(payloads, function (payload) {
+                    payloadStr[_DYN_PUSH /* @min:%2epush */](payload.item);
+                });
+                arrForEach(buffer, function (value) {
+                    if (!isFunction(value) && arrIndexOf(payloadStr, value.item) === -1) {
+                        remaining[_DYN_PUSH /* @min:%2epush */](value);
+                    }
+                });
+                return remaining;
+            }
+            function _getBuffer(key) {
+                var prefixedKey = key;
+                prefixedKey = _namePrefix ? _namePrefix + "_" + prefixedKey : prefixedKey;
+                return _getBufferBase(prefixedKey);
+            }
+            function _getBufferBase(key) {
+                try {
+                    var bufferJson = getItem(logger, key);
+                    if (bufferJson) {
+                        var buffer_1 = getJSON().parse(bufferJson);
+                        if (isString(buffer_1)) {
+                            // When using some version prototype.js the stringify / parse cycle does not decode array's correctly
+                            buffer_1 = getJSON().parse(buffer_1);
+                        }
+                        if (buffer_1 && isArray(buffer_1)) {
+                            return buffer_1;
+                        }
+                    }
+                }
+                catch (e) {
+                    _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 42 /* _eInternalMessageId.FailedToRestoreStorageBuffer */, " storage key: " + key + ", " + getExceptionName(e), { exception: dumpObj(e) });
+                }
+                return [];
+            }
+            function _setBuffer(key, buffer) {
+                var prefixedKey = key;
+                try {
+                    prefixedKey = _namePrefix ? _namePrefix + "_" + prefixedKey : prefixedKey;
+                    var bufferJson = JSON[_DYN_STRINGIFY /* @min:%2estringify */](buffer);
+                    setItem(logger, prefixedKey, bufferJson);
+                }
+                catch (e) {
+                    // if there was an error, clear the buffer
+                    // telemetry is stored in the _buffer array so we won't loose any items
+                    setItem(logger, prefixedKey, JSON[_DYN_STRINGIFY /* @min:%2estringify */]([]));
+                    _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 41 /* _eInternalMessageId.FailedToSetStorageBuffer */, " storage key: " + prefixedKey + ", " + getExceptionName(e) + ". Buffer cleared", { exception: dumpObj(e) });
+                }
+            }
+            // this removes buffer with prefix+key
+            function _getPreviousEvents() {
+                var items = [];
+                try {
+                    arrForEach(PREVIOUS_KEYS, function (key) {
+                        var events = _getItemsFromPreviousKey(key);
+                        items = items[_DYN_CONCAT /* @min:%2econcat */](events);
+                        // to make sure that we also transfer items from old prefixed + key buffer
+                        if (_namePrefix) {
+                            var prefixedKey = _namePrefix + "_" + key;
+                            var prefixEvents = _getItemsFromPreviousKey(prefixedKey);
+                            items = items[_DYN_CONCAT /* @min:%2econcat */](prefixEvents);
+                        }
+                    });
+                    return items;
+                }
+                catch (e) {
+                    _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 41 /* _eInternalMessageId.FailedToSetStorageBuffer */, "Transfer events from previous buffers: " + getExceptionName(e) + ". previous Buffer items can not be removed", { exception: dumpObj(e) });
+                }
+                return [];
+            }
+            // transform string[] to IInternalStorageItem[]
+            function _getItemsFromPreviousKey(key) {
+                try {
+                    var items = _getBufferBase(key);
+                    var transFormedItems_1 = [];
+                    arrForEach(items, function (item) {
+                        var internalItem = {
+                            item: item,
+                            cnt: 0 // previous events will be default to 0 count
+                        };
+                        transFormedItems_1[_DYN_PUSH /* @min:%2epush */](internalItem);
+                    });
+                    // remove the session storage if we can add events back
+                    utlRemoveSessionStorage(logger, key);
+                    return transFormedItems_1;
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+                return [];
+            }
+        });
+        return _this;
+    }
+// Removed Stub for SessionStorageSendBuffer.prototype.enqueue.
+// Removed Stub for SessionStorageSendBuffer.prototype.clear.
+// Removed Stub for SessionStorageSendBuffer.prototype.markAsSent.
+// Removed Stub for SessionStorageSendBuffer.prototype.clearSent.
+// Removed Stub for SessionStorageSendBuffer.prototype.createNew.
+    var _a;
+    _a = SessionStorageSendBuffer;
+    SessionStorageSendBuffer.VERSION = "_1";
+    SessionStorageSendBuffer.BUFFER_KEY = "AI_buffer" + _a.VERSION;
+    SessionStorageSendBuffer.SENT_BUFFER_KEY = "AI_sentBuffer" + _a.VERSION;
+    // Maximum number of payloads stored in the buffer. If the buffer is full, new elements will be dropped.
+    SessionStorageSendBuffer.MAX_BUFFER_SIZE = 2000;
+    return SessionStorageSendBuffer;
+}(BaseSendBuffer));
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+var Serializer = /** @class */ (function () {
+    function Serializer(logger) {
+        dynamicProto(Serializer, this, function (_self) {
+            /**
+             * Serializes the current object to a JSON string.
+             */
+            _self.serialize = function (input) {
+                var output = _serializeObject(input, "root");
+                try {
+                    return getJSON()[_DYN_STRINGIFY /* @min:%2estringify */](output);
+                }
+                catch (e) {
+                    // if serialization fails return an empty string
+                    _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 48 /* _eInternalMessageId.CannotSerializeObject */, (e && isFunction(e[_DYN_TO_STRING /* @min:%2etoString */])) ? e[_DYN_TO_STRING /* @min:%2etoString */]() : "Error serializing object", null, true);
+                }
+            };
+            function _serializeObject(source, name) {
+                var circularReferenceCheck = "__aiCircularRefCheck";
+                var output = {};
+                if (!source) {
+                    _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 48 /* _eInternalMessageId.CannotSerializeObject */, "cannot serialize object because it is null or undefined", { name: name }, true);
+                    return output;
+                }
+                if (source[circularReferenceCheck]) {
+                    _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 50 /* _eInternalMessageId.CircularReferenceDetected */, "Circular reference detected while serializing object", { name: name }, true);
+                    return output;
+                }
+                if (!source.aiDataContract) {
+                    // special case for measurements/properties/tags
+                    if (name === "measurements") {
+                        output = _serializeStringMap(source, "number", name);
+                    }
+                    else if (name === "properties") {
+                        output = _serializeStringMap(source, "string", name);
+                    }
+                    else if (name === "tags") {
+                        output = _serializeStringMap(source, "string", name);
+                    }
+                    else if (isArray(source)) {
+                        output = _serializeArray(source, name);
+                    }
+                    else {
+                        _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 49 /* _eInternalMessageId.CannotSerializeObjectNonSerializable */, "Attempting to serialize an object which does not implement ISerializable", { name: name }, true);
+                        try {
+                            // verify that the object can be stringified
+                            getJSON()[_DYN_STRINGIFY /* @min:%2estringify */](source);
+                            output = source;
+                        }
+                        catch (e) {
+                            // if serialization fails return an empty string
+                            _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 48 /* _eInternalMessageId.CannotSerializeObject */, (e && isFunction(e[_DYN_TO_STRING /* @min:%2etoString */])) ? e[_DYN_TO_STRING /* @min:%2etoString */]() : "Error serializing object", null, true);
+                        }
+                    }
+                    return output;
+                }
+                source[circularReferenceCheck] = true;
+                objForEachKey(source.aiDataContract, function (field, contract) {
+                    var isRequired = (isFunction(contract)) ? (contract() & 1 /* FieldType.Required */) : (contract & 1 /* FieldType.Required */);
+                    var isHidden = (isFunction(contract)) ? (contract() & 4 /* FieldType.Hidden */) : (contract & 4 /* FieldType.Hidden */);
+                    var isArray = contract & 2 /* FieldType.Array */;
+                    var isPresent = source[field] !== undefined;
+                    var isObj = isObject(source[field]) && source[field] !== null;
+                    if (isRequired && !isPresent && !isArray) {
+                        _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 24 /* _eInternalMessageId.MissingRequiredFieldSpecification */, "Missing required field specification. The field is required but not present on source", { field: field, name: name });
+                        // If not in debug mode, continue and hope the error is permissible
+                    }
+                    else if (!isHidden) { // Don't serialize hidden fields
+                        var value = void 0;
+                        if (isObj) {
+                            if (isArray) {
+                                // special case; recurse on each object in the source array
+                                value = _serializeArray(source[field], field);
+                            }
+                            else {
+                                // recurse on the source object in this field
+                                value = _serializeObject(source[field], field);
+                            }
+                        }
+                        else {
+                            // assign the source field to the output even if undefined or required
+                            value = source[field];
+                        }
+                        // only emit this field if the value is defined
+                        if (value !== undefined) {
+                            output[field] = value;
+                        }
+                    }
+                });
+                delete source[circularReferenceCheck];
+                return output;
+            }
+            function _serializeArray(sources, name) {
+                var output;
+                if (!!sources) {
+                    if (!isArray(sources)) {
+                        _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, 54 /* _eInternalMessageId.ItemNotInArray */, "This field was specified as an array in the contract but the item is not an array.\r\n", { name: name }, true);
+                    }
+                    else {
+                        output = [];
+                        for (var i = 0; i < sources[_DYN_LENGTH /* @min:%2elength */]; i++) {
+                            var source = sources[i];
+                            var item = _serializeObject(source, name + "[" + i + "]");
+                            output[_DYN_PUSH /* @min:%2epush */](item);
+                        }
+                    }
+                }
+                return output;
+            }
+            function _serializeStringMap(map, expectedType, name) {
+                var output;
+                if (map) {
+                    output = {};
+                    objForEachKey(map, function (field, value) {
+                        if (expectedType === "string") {
+                            if (value === undefined) {
+                                output[field] = "undefined";
+                            }
+                            else if (value === null) {
+                                output[field] = "null";
+                            }
+                            else if (!value[_DYN_TO_STRING /* @min:%2etoString */]) {
+                                output[field] = "invalid field: toString() is not defined.";
+                            }
+                            else {
+                                output[field] = value[_DYN_TO_STRING /* @min:%2etoString */]();
+                            }
+                        }
+                        else if (expectedType === "number") {
+                            if (value === undefined) {
+                                output[field] = "undefined";
+                            }
+                            else if (value === null) {
+                                output[field] = "null";
+                            }
+                            else {
+                                var num = parseFloat(value);
+                                output[field] = num;
+                            }
+                        }
+                        else {
+                            output[field] = "invalid field: " + name + " is of unknown type.";
+                            _throwInternal(logger, 1 /* eLoggingSeverity.CRITICAL */, output[field], null, true);
+                        }
+                    });
+                }
+                return output;
+            }
+        });
+    }
+// Removed Stub for Serializer.prototype.serialize.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    Serializer.__ieDyn=1;
+
+    return Serializer;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+// (Magic number) DJB algorithm can't work on shorter strings (results in poor distribution
+var MIN_INPUT_LENGTH = 8;
+var HashCodeScoreGenerator = /** @class */ (function () {
+    function HashCodeScoreGenerator() {
+    }
+    HashCodeScoreGenerator.prototype.getHashCodeScore = function (key) {
+        var score = this.getHashCode(key) / HashCodeScoreGenerator.INT_MAX_VALUE;
+        return score * 100;
+    };
+    HashCodeScoreGenerator.prototype.getHashCode = function (input) {
+        if (input === "") {
+            return 0;
+        }
+        while (input[_DYN_LENGTH /* @min:%2elength */] < MIN_INPUT_LENGTH) {
+            input = input[_DYN_CONCAT /* @min:%2econcat */](input);
+        }
+        // 5381 is a magic number: http://stackoverflow.com/questions/10696223/reason-for-5381-number-in-djb-hash-function
+        var hash = 5381;
+        for (var i = 0; i < input[_DYN_LENGTH /* @min:%2elength */]; ++i) {
+            hash = ((hash << 5) + hash) + input.charCodeAt(i);
+            // 'hash' is of number type which means 53 bit integer (http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types-number-type)
+            // 'hash & hash' will keep it 32 bit integer - just to make it clearer what the result is.
+            hash = hash & hash;
+        }
+        return Math.abs(hash);
+    };
+    // We're using 32 bit math, hence max value is (2^31 - 1)
+    HashCodeScoreGenerator.INT_MAX_VALUE = 2147483647;
+    return HashCodeScoreGenerator;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+var SamplingScoreGenerator = /** @class */ (function () {
+    function SamplingScoreGenerator() {
+        var _self = this;
+        var hashCodeGenerator = new HashCodeScoreGenerator();
+        var keys = new ContextTagKeys();
+        _self.getSamplingScore = function (item) {
+            var score = 0;
+            if (item[_DYN_TAGS /* @min:%2etags */] && item[_DYN_TAGS /* @min:%2etags */][keys.userId]) { // search in tags first, then ext
+                score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS /* @min:%2etags */][keys.userId]);
+            }
+            else if (item.ext && item.ext.user && item.ext.user.id) {
+                score = hashCodeGenerator[_DYN_GET_HASH_CODE_SCORE /* @min:%2egetHashCodeScore */](item.ext.user.id);
+            }
+            else if (item[_DYN_TAGS /* @min:%2etags */] && item[_DYN_TAGS /* @min:%2etags */][keys.operationId]) { // search in tags first, then ext
+                score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS /* @min:%2etags */][keys.operationId]);
+            }
+            else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace[_DYN_TRACE_ID /* @min:%2etraceID */]) {
+                score = hashCodeGenerator.getHashCodeScore(item.ext.telemetryTrace[_DYN_TRACE_ID /* @min:%2etraceID */]);
+            }
+            else {
+                // tslint:disable-next-line:insecure-random
+                score = (Math.random() * 100);
+            }
+            return score;
+        };
+    }
+    return SamplingScoreGenerator;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+var Sample = /** @class */ (function () {
+    function Sample(sampleRate, logger) {
+        // We're using 32 bit math, hence max value is (2^31 - 1)
+        this.INT_MAX_VALUE = 2147483647;
+        var _logger = logger || safeGetLogger(null);
+        if (sampleRate > 100 || sampleRate < 0) {
+            _logger.throwInternal(2 /* eLoggingSeverity.WARNING */, 58 /* _eInternalMessageId.SampleRateOutOfRange */, "Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.", { samplingRate: sampleRate }, true);
+            sampleRate = 100;
+        }
+        this[_DYN_SAMPLE_RATE /* @min:%2esampleRate */] = sampleRate;
+        this.samplingScoreGenerator = new SamplingScoreGenerator();
+    }
+    /**
+    * Determines if an envelope is sampled in (i.e. will be sent) or not (i.e. will be dropped).
+    */
+    Sample.prototype.isSampledIn = function (envelope) {
+        var samplingPercentage = this[_DYN_SAMPLE_RATE /* @min:%2esampleRate */]; // 0 - 100
+        var isSampledIn = false;
+        if (samplingPercentage === null || samplingPercentage === undefined || samplingPercentage >= 100) {
+            return true;
+        }
+        else if (envelope.baseType === Metric[_DYN_DATA_TYPE /* @min:%2edataType */]) {
+            // exclude MetricData telemetry from sampling
+            return true;
+        }
+        isSampledIn = this.samplingScoreGenerator.getSamplingScore(envelope) < samplingPercentage;
+        return isSampledIn;
+    };
+    return Sample;
+}());
+
+/*
+ * Application Insights JavaScript SDK - Channel, 3.3.9
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+var _a, _b;
+var UNDEFINED_VALUE = undefined;
+var EMPTY_STR = "";
+var FetchSyncRequestSizeLimitBytes = 65000; // approx 64kb (the current Edge, Firefox and Chrome max limit)
+function _getResponseText(xhr) {
+    try {
+        return xhr.responseText;
+    }
+    catch (e) {
+        // Best effort, as XHR may throw while XDR wont so just ignore
+    }
+    return null;
+}
+function isOverrideFn(httpXHROverride) {
+    return httpXHROverride && httpXHROverride.sendPOST;
+}
+var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
+        // Use the default value (handles empty string in the configuration)
+        endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
+    },
+    _a[_DYN_EMIT_LINE_DELIMITED_0 /* @min:emitLineDelimitedJson */] = cfgDfBoolean(),
+    _a.maxBatchInterval = 15000,
+    _a[_DYN_MAX_BATCH_SIZE_IN_BY1 /* @min:maxBatchSizeInBytes */] = 102400,
+    _a.disableTelemetry = cfgDfBoolean(),
+    _a[_DYN_ENABLE_SESSION_STORA5 /* @min:enableSessionStorageBuffer */] = cfgDfBoolean(true),
+    _a.isRetryDisabled = cfgDfBoolean(),
+    _a[_DYN_IS_BEACON_API_DISABL3 /* @min:isBeaconApiDisabled */] = cfgDfBoolean(true),
+    _a[_DYN_DISABLE_SEND_BEACON_7 /* @min:disableSendBeaconSplit */] = cfgDfBoolean(true),
+    _a.disableXhr = cfgDfBoolean(),
+    _a[_DYN_ONUNLOAD_DISABLE_FET6 /* @min:onunloadDisableFetch */] = cfgDfBoolean(),
+    _a[_DYN_ONUNLOAD_DISABLE_BEA2 /* @min:onunloadDisableBeacon */] = cfgDfBoolean(),
+    _a[_DYN_INSTRUMENTATION_KEY /* @min:instrumentationKey */] = UNDEFINED_VALUE,
+    _a.namePrefix = UNDEFINED_VALUE,
+    _a.samplingPercentage = cfgDfValidate(_chkSampling, 100),
+    _a[_DYN_CUSTOM_HEADERS /* @min:customHeaders */] = UNDEFINED_VALUE,
+    _a.convertUndefined = UNDEFINED_VALUE,
+    _a.eventsLimitInMem = 10000,
+    _a[_DYN_BUFFER_OVERRIDE /* @min:bufferOverride */] = false,
+    _a.httpXHROverride = { isVal: isOverrideFn, v: UNDEFINED_VALUE },
+    _a[_DYN_ALWAYS_USE_XHR_OVERR4 /* @min:alwaysUseXhrOverride */] = cfgDfBoolean(),
+    _a.transports = UNDEFINED_VALUE,
+    _a.retryCodes = UNDEFINED_VALUE,
+    _a.corsPolicy = UNDEFINED_VALUE,
+    _a.maxRetryCnt = { isVal: isNumber, v: 10 },
+    _a));
+var CrossOriginResourcePolicyHeader = "X-Set-Cross-Origin-Resource-Policy";
+function _chkSampling(value) {
+    return !isNaN(value) && value > 0 && value <= 100;
+}
+var EnvelopeTypeCreator = (_b = {},
+    _b[Event.dataType] = EventEnvelopeCreator,
+    _b[Trace.dataType] = TraceEnvelopeCreator,
+    _b[PageView.dataType] = PageViewEnvelopeCreator,
+    _b[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator,
+    _b[Exception.dataType] = ExceptionEnvelopeCreator,
+    _b[Metric.dataType] = MetricEnvelopeCreator,
+    _b[RemoteDependencyData.dataType] = DependencyEnvelopeCreator,
+    _b);
+var Sender = /** @class */ (function (_super) {
+    __extendsFn(Sender, _super);
+    function Sender() {
+        var _this = _super.call(this) || this;
+        _this.priority = 1001;
+        _this.identifier = BreezeChannelIdentifier;
+        // Don't set the defaults here, set them in the _initDefaults() as this is also called during unload
+        var _consecutiveErrors; // How many times in a row a retryable error condition has occurred.
+        var _retryAt; // The time to retry at in milliseconds from 1970/01/01 (this makes the timer calculation easy).
+        var _lastSend; // The time of the last send operation.
+        var _paused; // Flag indicating that the sending should be paused
+        var _timeoutHandle; // Handle to the timer for delayed sending of batches of data.
+        var _serializer;
+        var _stamp_specific_redirects;
+        var _headers;
+        var _syncFetchPayload = 0; // Keep track of the outstanding sync fetch payload total (as sync fetch has limits)
+        var _syncUnloadSender; // The identified sender to use for the synchronous unload stage
+        var _offlineListener;
+        var _evtNamespace;
+        var _endpointUrl;
+        var _orgEndpointUrl;
+        var _maxBatchSizeInBytes;
+        var _beaconSupported;
+        var _beaconOnUnloadSupported;
+        var _beaconNormalSupported;
+        var _customHeaders;
+        var _disableTelemetry;
+        var _instrumentationKey;
+        var _convertUndefined;
+        var _isRetryDisabled;
+        var _maxBatchInterval;
+        var _sessionStorageUsed;
+        var _bufferOverrideUsed;
+        var _namePrefix;
+        var _enableSendPromise;
+        var _alwaysUseCustomSend;
+        var _disableXhr;
+        var _fetchKeepAlive;
+        var _xhrSend;
+        var _fallbackSend;
+        var _disableBeaconSplit;
+        var _sendPostMgr;
+        var _retryCodes;
+        var _zipPayload;
+        dynamicProto(Sender, _this, function (_self, _base) {
+            _initDefaults();
+            _self.pause = function () {
+                _clearScheduledTimer();
+                _paused = true;
+            };
+            _self.resume = function () {
+                if (_paused) {
+                    _paused = false;
+                    _retryAt = null;
+                    // flush if we have exceeded the max-size already
+                    _checkMaxSize();
+                    _setupTimer();
+                }
+            };
+            _self.flush = function (isAsync, callBack, sendReason) {
+                if (isAsync === void 0) { isAsync = true; }
+                if (!_paused) {
+                    // Clear the normal schedule timer as we are going to try and flush ASAP
+                    _clearScheduledTimer();
+                    try {
+                        return _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */](isAsync, null, sendReason || 1 /* SendRequestReason.ManualFlush */);
+                    }
+                    catch (e) {
+                        _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 22 /* _eInternalMessageId.FlushFailed */, "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                }
+            };
+            _self.onunloadFlush = function () {
+                if (!_paused) {
+                    if (_beaconSupported || _alwaysUseCustomSend) {
+                        try {
+                            return _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */](true, _doUnloadSend, 2 /* SendRequestReason.Unload */);
+                        }
+                        catch (e) {
+                            _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 20 /* _eInternalMessageId.FailedToSendQueuedTelemetry */, "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+                        }
+                    }
+                    else {
+                        _self.flush(false);
+                    }
+                }
+            };
+            _self.addHeader = function (name, value) {
+                _headers[name] = value;
+            };
+            _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (config, core, extensions, pluginChain) {
+                if (_self.isInitialized()) {
+                    _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 28 /* _eInternalMessageId.SenderNotInitialized */, "Sender is already initialized");
+                }
+                _base[_DYN_INITIALIZE /* @min:%2einitialize */](config, core, extensions, pluginChain);
+                var identifier = _self.identifier;
+                _serializer = new Serializer(core.logger);
+                _consecutiveErrors = 0;
+                _retryAt = null;
+                _lastSend = 0;
+                _self[_DYN__SENDER /* @min:%2e_sender */] = null;
+                _stamp_specific_redirects = 0;
+                var diagLog = _self[_DYN_DIAG_LOG /* @min:%2ediagLog */]();
+                _evtNamespace = mergeEvtNamespace(createUniqueNamespace("Sender"), core.evtNamespace && core.evtNamespace());
+                _offlineListener = createOfflineListener(_evtNamespace);
+                // This function will be re-called whenever any referenced configuration is changed
+                _self._addHook(onConfigChange(config, function (details) {
+                    var config = details.cfg;
+                    if (config.storagePrefix) {
+                        utlSetStoragePrefix(config.storagePrefix);
+                    }
+                    var ctx = createProcessTelemetryContext(null, config, core);
+                    // getExtCfg only finds undefined values from core
+                    var senderConfig = ctx.getExtCfg(identifier, defaultAppInsightsChannelConfig);
+                    var curExtUrl = senderConfig[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */];
+                    // if it is not inital change (_endpointUrl has value)
+                    // if current sender endpoint url is not changed directly
+                    // means ExtCfg is not changed directly
+                    // then we need to monitor endpoint url changes from core
+                    if (_endpointUrl && curExtUrl === _endpointUrl) {
+                        var coreUrl = config[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */];
+                        // if core endpoint url is changed
+                        if (coreUrl && coreUrl !== curExtUrl) {
+                            // and endpoint promise changes is handled by this as well
+                            senderConfig[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */] = coreUrl;
+                        }
+                    }
+                    var csStream = getInst("CompressionStream");
+                    // Determine whether to enable payload compression (zipping).
+                    _zipPayload = isFeatureEnabled("zipPayload", config, false);
+                    if (!isFunction(csStream)) {
+                        _zipPayload = false;
+                    }
+                    var corsPolicy = senderConfig.corsPolicy;
+                    if (corsPolicy) {
+                        if (corsPolicy === "same-origin" || corsPolicy === "same-site" || corsPolicy === "cross-origin") {
+                            _this.addHeader(CrossOriginResourcePolicyHeader, corsPolicy);
+                        }
+                    }
+                    else {
+                        delete _headers[CrossOriginResourcePolicyHeader];
+                    }
+                    if (isPromiseLike(senderConfig[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */])) {
+                        // if it is promise, means the endpoint url is from core.endpointurl
+                        senderConfig[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */] = config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */];
+                    }
+                    objDefine(_self, "_senderConfig", {
+                        g: function () {
+                            return senderConfig;
+                        }
+                    });
+                    // Only update the endpoint if the original config !== the current config
+                    // This is so any redirect endpointUrl is not overwritten
+                    if (_orgEndpointUrl !== senderConfig[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */]) {
+                        _endpointUrl = _orgEndpointUrl = senderConfig[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */];
+                    }
+                    // or is not string
+                    if (core.activeStatus() === ActiveStatus.PENDING) {
+                        // waiting for core promises to be resolved
+                        // NOTE: if active status is set to pending, stop sending, clear timer here
+                        _self.pause();
+                    }
+                    else if (core.activeStatus() === ActiveStatus.ACTIVE) {
+                        // core status changed from pending to other status
+                        _self.resume();
+                    }
+                    if (_customHeaders && _customHeaders !== senderConfig[_DYN_CUSTOM_HEADERS /* @min:%2ecustomHeaders */]) {
+                        // Removing any previously defined custom headers as they have changed
+                        arrForEach(_customHeaders, function (customHeader) {
+                            delete _headers[customHeader.header];
+                        });
+                    }
+                    _maxBatchSizeInBytes = senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 /* @min:%2emaxBatchSizeInBytes */];
+                    _beaconSupported = (senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 /* @min:%2eonunloadDisableBeacon */] === false || senderConfig[_DYN_IS_BEACON_API_DISABL3 /* @min:%2eisBeaconApiDisabled */] === false) && isBeaconsSupported();
+                    _beaconOnUnloadSupported = senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 /* @min:%2eonunloadDisableBeacon */] === false && isBeaconsSupported();
+                    _beaconNormalSupported = senderConfig[_DYN_IS_BEACON_API_DISABL3 /* @min:%2eisBeaconApiDisabled */] === false && isBeaconsSupported();
+                    _alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4 /* @min:%2ealwaysUseXhrOverride */];
+                    _disableXhr = !!senderConfig.disableXhr;
+                    _retryCodes = senderConfig.retryCodes;
+                    var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE /* @min:%2ebufferOverride */];
+                    var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5 /* @min:%2eenableSessionStorageBuffer */] &&
+                        (!!bufferOverride || utlCanUseSessionStorage());
+                    var namePrefix = senderConfig.namePrefix;
+                    //Note: emitLineDelimitedJson and eventsLimitInMem is directly accessed via config in senderBuffer
+                    //Therefore, if canUseSessionStorage is not changed, we do not need to re initialize a new one
+                    var shouldUpdate = (canUseSessionStorage !== _sessionStorageUsed)
+                        || (canUseSessionStorage && (_namePrefix !== namePrefix)) // prefixName is only used in session storage
+                        || (canUseSessionStorage && (_bufferOverrideUsed !== bufferOverride));
+                    if (_self[_DYN__BUFFER /* @min:%2e_buffer */]) {
+                        // case1 (Pre and Now enableSessionStorageBuffer settings are same)
+                        // if namePrefix changes, transfer current buffer to new buffer
+                        // else no action needed
+                        //case2 (Pre and Now enableSessionStorageBuffer settings are changed)
+                        // transfer current buffer to new buffer
+                        if (shouldUpdate) {
+                            try {
+                                _self[_DYN__BUFFER /* @min:%2e_buffer */] = _self[_DYN__BUFFER /* @min:%2e_buffer */].createNew(diagLog, senderConfig, canUseSessionStorage);
+                            }
+                            catch (e) {
+                                _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 12 /* _eInternalMessageId.FailedAddingTelemetryToBuffer */, "failed to transfer telemetry to different buffer storage, telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
+                            }
+                        }
+                        _checkMaxSize();
+                    }
+                    else {
+                        _self[_DYN__BUFFER /* @min:%2e_buffer */] = canUseSessionStorage
+                            ? new SessionStorageSendBuffer(diagLog, senderConfig) : new ArraySendBuffer(diagLog, senderConfig);
+                    }
+                    _namePrefix = namePrefix;
+                    _sessionStorageUsed = canUseSessionStorage;
+                    _bufferOverrideUsed = bufferOverride;
+                    _fetchKeepAlive = !senderConfig[_DYN_ONUNLOAD_DISABLE_FET6 /* @min:%2eonunloadDisableFetch */] && isFetchSupported(true);
+                    _disableBeaconSplit = !!senderConfig[_DYN_DISABLE_SEND_BEACON_7 /* @min:%2edisableSendBeaconSplit */];
+                    _self._sample = new Sample(senderConfig.samplingPercentage, diagLog);
+                    _instrumentationKey = senderConfig[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */];
+                    if (!isPromiseLike(_instrumentationKey) && !_validateInstrumentationKey(_instrumentationKey, config)) {
+                        _throwInternal(diagLog, 1 /* eLoggingSeverity.CRITICAL */, 100 /* _eInternalMessageId.InvalidInstrumentationKey */, "Invalid Instrumentation key " + _instrumentationKey);
+                    }
+                    _customHeaders = senderConfig[_DYN_CUSTOM_HEADERS /* @min:%2ecustomHeaders */];
+                    if (isString(_endpointUrl) && !isInternalApplicationInsightsEndpoint(_endpointUrl) && _customHeaders && _customHeaders[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                        arrForEach(_customHeaders, function (customHeader) {
+                            _this.addHeader(customHeader.header, customHeader.value);
+                        });
+                    }
+                    else {
+                        _customHeaders = null;
+                    }
+                    _enableSendPromise = senderConfig.enableSendPromise;
+                    var sendPostConfig = _getSendPostMgrConfig();
+                    // only init it once
+                    if (!_sendPostMgr) {
+                        _sendPostMgr = new SenderPostManager();
+                        _sendPostMgr[_DYN_INITIALIZE /* @min:%2einitialize */](sendPostConfig, diagLog);
+                    }
+                    else {
+                        _sendPostMgr.SetConfig(sendPostConfig);
+                    }
+                    var customInterface = senderConfig.httpXHROverride;
+                    var httpInterface = null;
+                    var syncInterface = null;
+                    // User requested transport(s) values > Beacon > Fetch > XHR
+                    // Beacon would be filtered out if user has set disableBeaconApi to true at _getSenderInterface
+                    var theTransports = prependTransports([3 /* TransportType.Beacon */, 1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */], senderConfig.transports);
+                    httpInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST /* @min:%2egetSenderInst */](theTransports, false);
+                    var xhrInterface = _sendPostMgr && _sendPostMgr.getFallbackInst();
+                    _xhrSend = function (payload, isAsync) {
+                        return _doSend(xhrInterface, payload, isAsync);
+                    };
+                    _fallbackSend = function (payload, isAsync) {
+                        return _doSend(xhrInterface, payload, isAsync, false);
+                    };
+                    httpInterface = _alwaysUseCustomSend ? customInterface : (httpInterface || customInterface || xhrInterface);
+                    _self[_DYN__SENDER /* @min:%2e_sender */] = function (payload, isAsync) {
+                        return _doSend(httpInterface, payload, isAsync);
+                    };
+                    if (_fetchKeepAlive) {
+                        // Try and use the fetch with keepalive
+                        _syncUnloadSender = _fetchKeepAliveSender;
+                    }
+                    var syncTransports = prependTransports([3 /* TransportType.Beacon */, 1 /* TransportType.Xhr */], senderConfig.unloadTransports);
+                    if (!_fetchKeepAlive) {
+                        // remove fetch from theTransports
+                        syncTransports = syncTransports.filter(function (transport) { return transport !== 2 /* TransportType.Fetch */; });
+                    }
+                    syncInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST /* @min:%2egetSenderInst */](syncTransports, true);
+                    syncInterface = _alwaysUseCustomSend ? customInterface : (syncInterface || customInterface);
+                    if ((_alwaysUseCustomSend || senderConfig.unloadTransports || !_syncUnloadSender) && syncInterface) {
+                        _syncUnloadSender = function (payload, isAsync) {
+                            return _doSend(syncInterface, payload, isAsync);
+                        };
+                    }
+                    if (!_syncUnloadSender) {
+                        _syncUnloadSender = _xhrSend;
+                    }
+                    _disableTelemetry = senderConfig.disableTelemetry;
+                    _convertUndefined = senderConfig.convertUndefined || UNDEFINED_VALUE;
+                    _isRetryDisabled = senderConfig.isRetryDisabled;
+                    _maxBatchInterval = senderConfig.maxBatchInterval;
+                }));
+            };
+            _self.processTelemetry = function (telemetryItem, itemCtx) {
+                itemCtx = _self._getTelCtx(itemCtx);
+                var diagLogger = itemCtx[_DYN_DIAG_LOG /* @min:%2ediagLog */]();
+                try {
+                    var isValidate = _validate(telemetryItem, diagLogger);
+                    if (!isValidate) {
+                        return;
+                    }
+                    var aiEnvelope = _getEnvelope(telemetryItem, diagLogger);
+                    if (!aiEnvelope) {
+                        return;
+                    }
+                    // check if the incoming payload is too large, truncate if necessary
+                    var payload = _serializer.serialize(aiEnvelope);
+                    // flush if we would exceed the max-size limit by adding this item
+                    var buffer = _self[_DYN__BUFFER /* @min:%2e_buffer */];
+                    _checkMaxSize(payload);
+                    var payloadItem = {
+                        item: payload,
+                        cnt: 0 // inital cnt will always be 0
+                    };
+                    // enqueue the payload
+                    buffer[_DYN_ENQUEUE /* @min:%2eenqueue */](payloadItem);
+                    // ensure an invocation timeout is set
+                    _setupTimer();
+                }
+                catch (e) {
+                    _throwInternal(diagLogger, 2 /* eLoggingSeverity.WARNING */, 12 /* _eInternalMessageId.FailedAddingTelemetryToBuffer */, "Failed adding telemetry to the sender's buffer, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
+                }
+                // hand off the telemetry item to the next plugin
+                _self.processNext(telemetryItem, itemCtx);
+            };
+            _self.isCompletelyIdle = function () {
+                return !_paused && _syncFetchPayload === 0 && _self._buffer[_DYN_COUNT /* @min:%2ecount */]() === 0;
+            };
+            _self.getOfflineListener = function () {
+                return _offlineListener;
+            };
+            /**
+             * xhr state changes
+             */
+            _self._xhrReadyStateChange = function (xhr, payload, countOfItemsInPayload) {
+                // since version 3.2.0, this function is no-op
+                if (_isStringArr(payload)) {
+                    return;
+                }
+                return _xhrReadyStateChange(xhr, payload, countOfItemsInPayload);
+            };
+            /**
+             * Immediately send buffered data
+             * @param async - Indicates if the events should be sent asynchronously
+             * @param forcedSender - Indicates the forcedSender, undefined if not passed
+             */
+            _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */] = function (async, forcedSender, sendReason) {
+                if (async === void 0) { async = true; }
+                var result;
+                if (!_paused) {
+                    try {
+                        var buffer = _self[_DYN__BUFFER /* @min:%2e_buffer */];
+                        // Send data only if disableTelemetry is false
+                        if (!_disableTelemetry) {
+                            if (buffer[_DYN_COUNT /* @min:%2ecount */]() > 0) {
+                                var payload = buffer.getItems();
+                                _notifySendRequest(sendReason || 0 /* SendRequestReason.Undefined */, async);
+                                // invoke send
+                                if (forcedSender) {
+                                    result = forcedSender.call(_self, payload, async);
+                                }
+                                else {
+                                    result = _self[_DYN__SENDER /* @min:%2e_sender */](payload, async);
+                                }
+                            }
+                            // update lastSend time to enable throttling
+                            _lastSend = +new Date;
+                        }
+                        else {
+                            buffer[_DYN_CLEAR /* @min:%2eclear */]();
+                        }
+                        _clearScheduledTimer();
+                    }
+                    catch (e) {
+                        /* Ignore this error for IE under v10 */
+                        var ieVer = getIEVersion();
+                        if (!ieVer || ieVer > 9) {
+                            _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 40 /* _eInternalMessageId.TransmissionFailed */, "Telemetry transmission failed, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
+                        }
+                        // potential place to call countException q3
+                    }
+                }
+                return result;
+            };
+            _self.getOfflineSupport = function () {
+                return {
+                    getUrl: function () {
+                        return _endpointUrl;
+                    },
+                    createPayload: _createPayload,
+                    serialize: _serialize,
+                    batch: _batch,
+                    shouldProcess: function (evt) {
+                        return !!_validate(evt);
+                    }
+                };
+            };
+            _self._doTeardown = function (unloadCtx, unloadState) {
+                _self.onunloadFlush();
+                runTargetUnload(_offlineListener, false);
+                _initDefaults();
+            };
+            /**
+             * error handler
+             */
+            _self[_DYN__ON_ERROR /* @min:%2e_onError */] = function (payload, message, event) {
+                // since version 3.1.3, string[] is no-op
+                if (_isStringArr(payload)) {
+                    return;
+                }
+                return _onError(payload, message);
+            };
+            /**
+             * partial success handler
+             */
+            _self[_DYN__ON_PARTIAL_SUCCESS /* @min:%2e_onPartialSuccess */] = function (payload, results) {
+                // since version 3.1.3, string[] is no-op
+                if (_isStringArr(payload)) {
+                    return;
+                }
+                return _onPartialSuccess(payload, results);
+            };
+            /**
+             * success handler
+             */
+            _self[_DYN__ON_SUCCESS /* @min:%2e_onSuccess */] = function (payload, countOfItemsInPayload) {
+                // since version 3.1.3, string[] is no-op
+                if (_isStringArr(payload)) {
+                    return;
+                }
+                return _onSuccess(payload);
+                //_self._buffer && _self._buffer.clearSent(payload);
+            };
+            /**
+             * xdr state changes
+             */
+            _self._xdrOnLoad = function (xdr, payload) {
+                // since version 3.1.3, string[] is no-op
+                if (_isStringArr(payload)) {
+                    return;
+                }
+                return _xdrOnLoad(xdr, payload);
+            };
+            // function _getStatsBeat() {
+            //     let statsBeatConfig: IStatsBeatState = {
+            //         cKey: _self._senderConfig.instrumentationKey,
+            //         endpoint: _endpointUrl,
+            //         sdkVer: EnvelopeCreator.Version,
+            //         type: eStatsType.SDK
+            //     };
+            //     let core = _self.core;
+            //     // During page unload the core may have been cleared and some async events may not have been sent yet
+            //     // resulting in the core being null. In this case we don't want to create a statsbeat instance
+            //     return core ? core.getStatsBeat(statsBeatConfig) : null;
+            // }
+            function _xdrOnLoad(xdr, payload) {
+                var responseText = _getResponseText(xdr);
+                if (xdr && (responseText + "" === "200" || responseText === "")) {
+                    _consecutiveErrors = 0;
+                    _self[_DYN__ON_SUCCESS /* @min:%2e_onSuccess */](payload, 0);
+                }
+                else {
+                    var results = parseResponse(responseText);
+                    if (results && results[_DYN_ITEMS_RECEIVED /* @min:%2eitemsReceived */] && results[_DYN_ITEMS_RECEIVED /* @min:%2eitemsReceived */] > results[_DYN_ITEMS_ACCEPTED /* @min:%2eitemsAccepted */]
+                        && !_isRetryDisabled) {
+                        _self[_DYN__ON_PARTIAL_SUCCESS /* @min:%2e_onPartialSuccess */](payload, results);
+                    }
+                    else {
+                        _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, formatErrorMessageXdr(xdr));
+                    }
+                }
+            }
+            function _getSendPostMgrConfig() {
+                try {
+                    var onCompleteFuncs = {
+                        xdrOnComplete: function (xdr, oncomplete, payload) {
+                            var payloadArr = _getPayloadArr(payload);
+                            if (!payloadArr) {
+                                return;
+                            }
+                            //const responseText = _getResponseText(xdr);
+                            // let statsbeat = _getStatsBeat();
+                            // if (statsbeat) {
+                            //     if (xdr && (responseText + "" === "200" || responseText === "")) {
+                            //         _consecutiveErrors = 0;
+                            //         statsbeat.count(200, payload, _endpointUrl);
+                            //     } else {
+                            //         const results = parseResponse(responseText);
+                            //         if (results && results.itemsReceived && results.itemsReceived > results.itemsAccepted
+                            //             && !_isRetryDisabled) {
+                            //             statsbeat.count(206, payload, _endpointUrl);
+                            //         } else {
+                            //             statsbeat.count(499, payload, _endpointUrl);
+                            //         }
+                            //     }
+                            // }
+                            return _xdrOnLoad(xdr, payloadArr);
+                        },
+                        fetchOnComplete: function (response, onComplete, resValue, payload) {
+                            var payloadArr = _getPayloadArr(payload);
+                            if (!payloadArr) {
+                                return;
+                            }
+                            // let statsbeat = _getStatsBeat();
+                            // if (statsbeat) {
+                            //     statsbeat.count(response.status, payload, _endpointUrl);
+                            // }
+                            return _checkResponsStatus(response.status, payloadArr, response.url, payloadArr[_DYN_LENGTH /* @min:%2elength */], response.statusText, resValue || "");
+                        },
+                        xhrOnComplete: function (request, oncomplete, payload) {
+                            var payloadArr = _getPayloadArr(payload);
+                            if (!payloadArr) {
+                                return;
+                            }
+                            // let statsbeat = _getStatsBeat();
+                            // if (statsbeat && request.readyState === 4) {
+                            //     statsbeat.count(request.status, payload, _endpointUrl);
+                            // }
+                            return _xhrReadyStateChange(request, payloadArr, payloadArr[_DYN_LENGTH /* @min:%2elength */]);
+                        },
+                        beaconOnRetry: function (data, onComplete, canSend) {
+                            // let statsbeat = _getStatsBeat();
+                            // if (statsbeat) {
+                            //     statsbeat.count(499, data, _endpointUrl);
+                            // }
+                            return _onBeaconRetry(data, onComplete, canSend);
+                        }
+                    };
+                    var config = {
+                        enableSendPromise: _enableSendPromise,
+                        isOneDs: false,
+                        disableCredentials: false,
+                        disableXhr: _disableXhr,
+                        disableBeacon: !_beaconNormalSupported,
+                        disableBeaconSync: !_beaconOnUnloadSupported,
+                        senderOnCompleteCallBack: onCompleteFuncs
+                    };
+                    return config;
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+                return null;
+            }
+            /**
+             * xhr state changes
+             */
+            function _xhrReadyStateChange(xhr, payload, countOfItemsInPayload) {
+                if (xhr.readyState === 4) {
+                    _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
+                }
+            }
+            /**
+             * error handler
+             */
+            function _onError(payload, message, event) {
+                _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 26 /* _eInternalMessageId.OnError */, "Failed to send telemetry.", { message: message });
+                _self._buffer && _self._buffer[_DYN_CLEAR_SENT /* @min:%2eclearSent */](payload);
+            }
+            /**
+             * partial success handler
+             */
+            function _onPartialSuccess(payload, results) {
+                var failed = [];
+                var retry = [];
+                // Iterate through the reversed array of errors so that splicing doesn't have invalid indexes after the first item.
+                var errors = results.errors.reverse();
+                for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+                    var error = errors_1[_i];
+                    var extracted = payload.splice(error.index, 1)[0];
+                    if (_isRetriable(error.statusCode)) {
+                        retry[_DYN_PUSH /* @min:%2epush */](extracted);
+                    }
+                    else {
+                        // All other errors, including: 402 (Monthly quota exceeded) and 439 (Too many requests and refresh cache).
+                        failed[_DYN_PUSH /* @min:%2epush */](extracted);
+                    }
+                }
+                if (payload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    _self[_DYN__ON_SUCCESS /* @min:%2e_onSuccess */](payload, results[_DYN_ITEMS_ACCEPTED /* @min:%2eitemsAccepted */]);
+                }
+                if (failed[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    _self[_DYN__ON_ERROR /* @min:%2e_onError */](failed, formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED /* @min:%2eitemsAccepted */], "of", results.itemsReceived].join(" ")));
+                }
+                if (retry[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    _resendPayload(retry);
+                    _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, "Partial success. " +
+                        "Delivered: " + payload[_DYN_LENGTH /* @min:%2elength */] + ", Failed: " + failed[_DYN_LENGTH /* @min:%2elength */] +
+                        ". Will retry to send " + retry[_DYN_LENGTH /* @min:%2elength */] + " our of " + results[_DYN_ITEMS_RECEIVED /* @min:%2eitemsReceived */] + " items");
+                }
+            }
+            /**
+             * success handler
+             */
+            function _onSuccess(payload, countOfItemsInPayload) {
+                _self._buffer && _self._buffer[_DYN_CLEAR_SENT /* @min:%2eclearSent */](payload);
+            }
+            function _getPayloadArr(payload) {
+                try {
+                    if (payload) {
+                        var internalPayload = payload;
+                        var arr = internalPayload.oriPayload;
+                        if (arr && arr[_DYN_LENGTH /* @min:%2elength */]) {
+                            return arr;
+                        }
+                        return null;
+                    }
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+                return null;
+            }
+            function _validate(telemetryItem, diagLogger) {
+                if (_disableTelemetry) {
+                    // Do not send/save data
+                    return false;
+                }
+                // validate input
+                if (!telemetryItem) {
+                    diagLogger && _throwInternal(diagLogger, 1 /* eLoggingSeverity.CRITICAL */, 7 /* _eInternalMessageId.CannotSendEmptyTelemetry */, "Cannot send empty telemetry");
+                    return false;
+                }
+                // validate event
+                if (telemetryItem.baseData && !telemetryItem[_DYN_BASE_TYPE /* @min:%2ebaseType */]) {
+                    diagLogger && _throwInternal(diagLogger, 1 /* eLoggingSeverity.CRITICAL */, 70 /* _eInternalMessageId.InvalidEvent */, "Cannot send telemetry without baseData and baseType");
+                    return false;
+                }
+                if (!telemetryItem[_DYN_BASE_TYPE /* @min:%2ebaseType */]) {
+                    // Default
+                    telemetryItem[_DYN_BASE_TYPE /* @min:%2ebaseType */] = "EventData";
+                }
+                // ensure a sender was constructed
+                if (!_self[_DYN__SENDER /* @min:%2e_sender */]) {
+                    diagLogger && _throwInternal(diagLogger, 1 /* eLoggingSeverity.CRITICAL */, 28 /* _eInternalMessageId.SenderNotInitialized */, "Sender was not initialized");
+                    return false;
+                }
+                // check if this item should be sampled in, else add sampleRate tag
+                if (!_isSampledIn(telemetryItem)) {
+                    // Item is sampled out, do not send it
+                    diagLogger && _throwInternal(diagLogger, 2 /* eLoggingSeverity.WARNING */, 33 /* _eInternalMessageId.TelemetrySampledAndNotSent */, "Telemetry item was sampled out and not sent", { SampleRate: _self._sample[_DYN_SAMPLE_RATE /* @min:%2esampleRate */] });
+                    return false;
+                }
+                else {
+                    telemetryItem[SampleRate] = _self._sample[_DYN_SAMPLE_RATE /* @min:%2esampleRate */];
+                }
+                return true;
+            }
+            function _getEnvelope(telemetryItem, diagLogger) {
+                // construct an envelope that Application Insights endpoint can understand
+                // if ikey of telemetry is provided and not empty, envelope will use this iKey instead of senderConfig iKey
+                var defaultEnvelopeIkey = telemetryItem.iKey || _instrumentationKey;
+                var aiEnvelope = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, diagLogger, _convertUndefined);
+                if (!aiEnvelope) {
+                    _throwInternal(diagLogger, 1 /* eLoggingSeverity.CRITICAL */, 47 /* _eInternalMessageId.CreateEnvelopeError */, "Unable to create an AppInsights envelope");
+                    return;
+                }
+                var doNotSendItem = false;
+                // this is for running in legacy mode, where customer may already have a custom initializer present
+                if (telemetryItem[_DYN_TAGS /* @min:%2etags */] && telemetryItem[_DYN_TAGS /* @min:%2etags */][ProcessLegacy]) {
+                    arrForEach(telemetryItem[_DYN_TAGS /* @min:%2etags */][ProcessLegacy], function (callBack) {
+                        try {
+                            if (callBack && callBack(aiEnvelope) === false) {
+                                doNotSendItem = true;
+                                _warnToConsole(diagLogger, "Telemetry processor check returns false");
+                            }
+                        }
+                        catch (e) {
+                            // log error but dont stop executing rest of the telemetry initializers
+                            // doNotSendItem = true;
+                            _throwInternal(diagLogger, 1 /* eLoggingSeverity.CRITICAL */, 64 /* _eInternalMessageId.TelemetryInitializerFailed */, "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: dumpObj(e) }, true);
+                        }
+                    });
+                    delete telemetryItem[_DYN_TAGS /* @min:%2etags */][ProcessLegacy];
+                }
+                if (doNotSendItem) {
+                    return; // do not send, no need to execute next plugin
+                }
+                return aiEnvelope;
+            }
+            function _serialize(item) {
+                var rlt = EMPTY_STR;
+                var diagLogger = _self[_DYN_DIAG_LOG /* @min:%2ediagLog */]();
+                try {
+                    var valid = _validate(item, diagLogger);
+                    var envelope = null;
+                    if (valid) {
+                        envelope = _getEnvelope(item, diagLogger);
+                    }
+                    if (envelope) {
+                        rlt = _serializer.serialize(envelope);
+                    }
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+                return rlt;
+            }
+            function _batch(arr) {
+                var rlt = EMPTY_STR;
+                if (arr && arr[_DYN_LENGTH /* @min:%2elength */]) {
+                    rlt = "[" + arr.join(",") + "]";
+                }
+                return rlt;
+            }
+            function _createPayload(data) {
+                var headers = _getHeaders();
+                return {
+                    urlString: _endpointUrl,
+                    data: data,
+                    headers: headers
+                };
+            }
+            function _isSampledIn(envelope) {
+                return _self._sample.isSampledIn(envelope);
+            }
+            function _getOnComplete(payload, status, headers, response) {
+                // ***********************************************************************************************
+                //TODO: handle other status codes
+                if (status === 200 && payload) {
+                    _self._onSuccess(payload, payload[_DYN_LENGTH /* @min:%2elength */]);
+                }
+                else {
+                    response && _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, response);
+                }
+            }
+            function _doSend(sendInterface, payload, isAsync, markAsSent) {
+                if (markAsSent === void 0) { markAsSent = true; }
+                var onComplete = function (status, headers, response) {
+                    // let statsbeat = _getStatsBeat();
+                    // if (statsbeat) {
+                    //     statsbeat.count(status, payloadData, _endpointUrl);
+                    // }
+                    return _getOnComplete(payload, status, headers, response);
+                };
+                var payloadData = _getPayload(payload);
+                // if (payloadData) {
+                //     payloadData.statsBeatData = {startTime: dateNow()};
+                // }
+                var sendPostFunc = sendInterface && sendInterface.sendPOST;
+                if (sendPostFunc && payloadData) {
+                    // ***********************************************************************************************
+                    // mark payload as sent at the beginning of calling each send function
+                    if (markAsSent) {
+                        _self._buffer[_DYN_MARK_AS_SENT /* @min:%2emarkAsSent */](payload);
+                    }
+                    _sendPostMgr.preparePayload(function (processedPayload) {
+                        return sendPostFunc(processedPayload, onComplete, !isAsync);
+                    }, _zipPayload, payloadData, !isAsync);
+                }
+                return null;
+            }
+            function _getPayload(payload) {
+                if (isArray(payload) && payload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var batch = _self[_DYN__BUFFER /* @min:%2e_buffer */].batchPayloads(payload);
+                    var headers = _getHeaders();
+                    var payloadData = {
+                        data: batch,
+                        urlString: _endpointUrl,
+                        headers: headers,
+                        disableXhrSync: _disableXhr,
+                        disableFetchKeepAlive: !_fetchKeepAlive,
+                        oriPayload: payload
+                    };
+                    return payloadData;
+                }
+                return null;
+            }
+            function _getHeaders() {
+                try {
+                    var headers = _headers || {};
+                    if (isInternalApplicationInsightsEndpoint(_endpointUrl)) {
+                        headers[RequestHeaders[6 /* eRequestHeaders.sdkContextHeader */]] = RequestHeaders[7 /* eRequestHeaders.sdkContextHeaderAppIdRequest */];
+                    }
+                    return headers;
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-empty
+                }
+                return null;
+            }
+            function _checkMaxSize(incomingPayload) {
+                var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH /* @min:%2elength */] : 0;
+                if ((_self[_DYN__BUFFER /* @min:%2e_buffer */].size() + incomingSize) > _maxBatchSizeInBytes) {
+                    if (!_offlineListener || _offlineListener.isOnline()) { // only trigger send when currently online
+                        _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */](true, null, 10 /* SendRequestReason.MaxBatchSize */);
+                    }
+                    return true;
+                }
+                return false;
+            }
+            function _checkResponsStatus(status, payload, responseUrl, countOfItemsInPayload, errorMessage, res) {
+                var response = null;
+                if (!_self._appId) {
+                    response = parseResponse(res);
+                    if (response && response.appId) {
+                        _self._appId = response.appId;
+                    }
+                }
+                if ((status < 200 || status >= 300) && status !== 0) {
+                    // Update End Point url if permanent redirect or moved permanently
+                    // Updates the end point url before retry
+                    if (status === 301 || status === 307 || status === 308) {
+                        if (!_checkAndUpdateEndPointUrl(responseUrl)) {
+                            _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, errorMessage);
+                            return;
+                        }
+                    }
+                    if (_offlineListener && !_offlineListener.isOnline()) { // offline
+                        // Note: Don't check for status == 0, since adblock gives this code
+                        if (!_isRetryDisabled) {
+                            var offlineBackOffMultiplier = 10; // arbritrary number
+                            _resendPayload(payload, offlineBackOffMultiplier);
+                            _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". Offline - Response Code: ".concat(status, ". Offline status: ").concat(!_offlineListener.isOnline(), ". Will retry to send ").concat(payload.length, " items."));
+                        }
+                        return;
+                    }
+                    if (!_isRetryDisabled && _isRetriable(status)) {
+                        _resendPayload(payload);
+                        _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " +
+                            "Response code " + status + ". Will retry to send " + payload[_DYN_LENGTH /* @min:%2elength */] + " items.");
+                    }
+                    else {
+                        _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, errorMessage);
+                    }
+                }
+                else {
+                    // check if the xhr's responseURL or fetch's response.url is same as endpoint url
+                    // TODO after 10 redirects force send telemetry with 'redirect=false' as query parameter.
+                    _checkAndUpdateEndPointUrl(responseUrl);
+                    if (status === 206) {
+                        if (!response) {
+                            response = parseResponse(res);
+                        }
+                        if (response && !_isRetryDisabled) {
+                            _self[_DYN__ON_PARTIAL_SUCCESS /* @min:%2e_onPartialSuccess */](payload, response);
+                        }
+                        else {
+                            _self[_DYN__ON_ERROR /* @min:%2e_onError */](payload, errorMessage);
+                        }
+                    }
+                    else {
+                        _consecutiveErrors = 0;
+                        _self[_DYN__ON_SUCCESS /* @min:%2e_onSuccess */](payload, countOfItemsInPayload);
+                    }
+                }
+            }
+            function _checkAndUpdateEndPointUrl(responseUrl) {
+                // Maximum stamp specific redirects allowed(uncomment this when breeze is ready with not allowing redirects feature)
+                if (_stamp_specific_redirects >= 10) {
+                    //  _self._senderConfig.endpointUrl = () => Sender._getDefaultAppInsightsChannelConfig().endpointUrl()+"/?redirect=false";
+                    //  _stamp_specific_redirects = 0;
+                    return false;
+                }
+                if (!isNullOrUndefined(responseUrl) && responseUrl !== "") {
+                    if (responseUrl !== _endpointUrl) {
+                        _endpointUrl = responseUrl;
+                        ++_stamp_specific_redirects;
+                        return true;
+                    }
+                }
+                return false;
+            }
+            function _doUnloadSend(payload, isAsync) {
+                if (_syncUnloadSender) {
+                    // We are unloading so always call the sender with sync set to false
+                    _syncUnloadSender(payload, false);
+                }
+                else {
+                    // Fallback to the previous beacon Sender (which causes a CORB warning on chrome now)
+                    var beaconInst = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST /* @min:%2egetSenderInst */]([3 /* TransportType.Beacon */], true);
+                    return _doSend(beaconInst, payload, isAsync);
+                }
+            }
+            function _onBeaconRetry(payload, onComplete, canSend) {
+                var internalPayload = payload;
+                var data = internalPayload && internalPayload.oriPayload;
+                if (!_disableBeaconSplit) {
+                    // Failed to send entire payload so try and split data and try to send as much events as possible
+                    var droppedPayload = [];
+                    for (var lp = 0; lp < data[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                        var thePayload = data[lp];
+                        var arr = [thePayload];
+                        var item = _getPayload(arr);
+                        if (!canSend(item, onComplete)) {
+                            // Can't send anymore, so split the batch and drop the rest
+                            droppedPayload[_DYN_PUSH /* @min:%2epush */](thePayload);
+                        }
+                        else {
+                            _self._onSuccess(arr, arr[_DYN_LENGTH /* @min:%2elength */]);
+                        }
+                    }
+                    if (droppedPayload[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                        _fallbackSend && _fallbackSend(droppedPayload, true);
+                        _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                    }
+                }
+                else {
+                    _fallbackSend && _fallbackSend(data, true);
+                    _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                }
+            }
+            function _isStringArr(arr) {
+                try {
+                    if (arr && arr[_DYN_LENGTH /* @min:%2elength */]) {
+                        return (isString(arr[0]));
+                    }
+                }
+                catch (e) {
+                    //TODO: log, sender use IInternalStorageItem instead of string since 3.1.3
+                }
+                return null;
+            }
+            function _fetchKeepAliveSender(payload, isAsync) {
+                var transport = null;
+                if (isArray(payload)) {
+                    var payloadSize = payload[_DYN_LENGTH /* @min:%2elength */];
+                    for (var lp = 0; lp < payload[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                        payloadSize += payload[lp].item[_DYN_LENGTH /* @min:%2elength */];
+                    }
+                    var syncFetchPayload = _sendPostMgr.getSyncFetchPayload();
+                    if ((syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
+                        transport = 2 /* TransportType.Fetch */;
+                    }
+                    else if (isBeaconsSupported()) {
+                        // Fallback to beacon sender as we at least get told which events can't be scheduled
+                        transport = 3 /* TransportType.Beacon */;
+                    }
+                    else {
+                        // Payload is going to be too big so just try and send via XHR
+                        transport = 1 /* TransportType.Xhr */;
+                        _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 40 /* _eInternalMessageId.TransmissionFailed */, ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
+                    }
+                    var inst = _sendPostMgr && _sendPostMgr[_DYN_GET_SENDER_INST /* @min:%2egetSenderInst */]([transport], true);
+                    return _doSend(inst, payload, isAsync);
+                }
+                return null;
+            }
+            /**
+             * Resend payload. Adds payload back to the send buffer and setup a send timer (with exponential backoff).
+             * @param payload
+             */
+            function _resendPayload(payload, linearFactor) {
+                if (linearFactor === void 0) { linearFactor = 1; }
+                if (!payload || payload[_DYN_LENGTH /* @min:%2elength */] === 0) {
+                    return;
+                }
+                var buffer = _self[_DYN__BUFFER /* @min:%2e_buffer */];
+                buffer[_DYN_CLEAR_SENT /* @min:%2eclearSent */](payload);
+                _consecutiveErrors++;
+                for (var _i = 0, payload_1 = payload; _i < payload_1.length; _i++) {
+                    var item = payload_1[_i];
+                    item.cnt = item.cnt || 0; // to make sure we have cnt for each payload
+                    item.cnt++; // when resend, increase cnt
+                    buffer[_DYN_ENQUEUE /* @min:%2eenqueue */](item);
+                }
+                // setup timer
+                _setRetryTime(linearFactor);
+                _setupTimer();
+            }
+            /**
+             * Calculates the time to wait before retrying in case of an error based on
+             * http://en.wikipedia.org/wiki/Exponential_backoff
+             */
+            function _setRetryTime(linearFactor) {
+                var SlotDelayInSeconds = 10;
+                var delayInSeconds;
+                if (_consecutiveErrors <= 1) {
+                    delayInSeconds = SlotDelayInSeconds;
+                }
+                else {
+                    var backOffSlot = (Math.pow(2, _consecutiveErrors) - 1) / 2;
+                    // tslint:disable-next-line:insecure-random
+                    var backOffDelay = mathFloor(Math.random() * backOffSlot * SlotDelayInSeconds) + 1;
+                    backOffDelay = linearFactor * backOffDelay;
+                    delayInSeconds = mathMax(mathMin(backOffDelay, 3600), SlotDelayInSeconds);
+                }
+                // TODO: Log the backoff time like the C# version does.
+                var retryAfterTimeSpan = utcNow() + (delayInSeconds * 1000);
+                // TODO: Log the retry at time like the C# version does.
+                _retryAt = retryAfterTimeSpan;
+            }
+            /**
+             * Sets up the timer which triggers actually sending the data.
+             */
+            function _setupTimer() {
+                if (!_timeoutHandle && !_paused) {
+                    var retryInterval = _retryAt ? mathMax(0, _retryAt - utcNow()) : 0;
+                    var timerValue = mathMax(_maxBatchInterval, retryInterval);
+                    _timeoutHandle = scheduleTimeout(function () {
+                        _timeoutHandle = null;
+                        _self[_DYN_TRIGGER_SEND /* @min:%2etriggerSend */](true, null, 1 /* SendRequestReason.NormalSchedule */);
+                    }, timerValue);
+                }
+            }
+            function _clearScheduledTimer() {
+                _timeoutHandle && _timeoutHandle.cancel();
+                _timeoutHandle = null;
+                _retryAt = null;
+            }
+            /**
+             * Checks if the SDK should resend the payload after receiving this status code from the backend.
+             * @param statusCode
+             */
+            function _isRetriable(statusCode) {
+                // retryCodes = [] means should not retry
+                if (!isNullOrUndefined(_retryCodes)) {
+                    return _retryCodes[_DYN_LENGTH /* @min:%2elength */] && _retryCodes.indexOf(statusCode) > -1;
+                }
+                return statusCode === 401 // Unauthorized
+                    // Removing as private links can return a 403 which causes excessive retries and session storage usage
+                    // || statusCode === 403 // Forbidden
+                    || statusCode === 408 // Timeout
+                    || statusCode === 429 // Too many requests.
+                    || statusCode === 500 // Internal server error.
+                    || statusCode === 502 // Bad Gateway.
+                    || statusCode === 503 // Service unavailable.
+                    || statusCode === 504; // Gateway timeout.
+            }
+            // Using function lookups for backward compatibility as the getNotifyMgr() did not exist until after v2.5.6
+            function _getNotifyMgr() {
+                var func = "getNotifyMgr";
+                var result;
+                var core = _self.core;
+                if (core) {
+                    // During page unload the core may have been cleared and some async events may not have been sent yet
+                    // resulting in the core being null. In this case we don't want to create a statsbeat instance
+                    if (core[func]) {
+                        result = core[func]();
+                    }
+                    else {
+                        // using _self.core['_notificationManager'] for backward compatibility
+                        result = core["_notificationManager"];
+                    }
+                }
+                return result;
+            }
+            function _notifySendRequest(sendRequest, isAsync) {
+                var manager = _getNotifyMgr();
+                if (manager && manager.eventsSendRequest) {
+                    try {
+                        manager.eventsSendRequest(sendRequest, isAsync);
+                    }
+                    catch (e) {
+                        _throwInternal(_self[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 74 /* _eInternalMessageId.NotificationException */, "send request notification failed: " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                }
+            }
+            /**
+             * Validate UUID Format
+             * Specs taken from https://tools.ietf.org/html/rfc4122 and breeze repo
+             */
+            function _validateInstrumentationKey(instrumentationKey, config) {
+                var disableValidation = config.disableInstrumentationKeyValidation;
+                var disableIKeyValidationFlag = isNullOrUndefined(disableValidation) ? false : disableValidation;
+                if (disableIKeyValidationFlag) {
+                    return true;
+                }
+                var UUID_Regex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+                var regexp = new RegExp(UUID_Regex);
+                return regexp.test(instrumentationKey);
+            }
+            function _initDefaults() {
+                _self[_DYN__SENDER /* @min:%2e_sender */] = null;
+                _self[_DYN__BUFFER /* @min:%2e_buffer */] = null;
+                _self._appId = null;
+                _self._sample = null;
+                _headers = {};
+                _offlineListener = null;
+                _consecutiveErrors = 0;
+                _retryAt = null;
+                _lastSend = null;
+                _paused = false;
+                _timeoutHandle = null;
+                _serializer = null;
+                _stamp_specific_redirects = 0;
+                _syncFetchPayload = 0;
+                _syncUnloadSender = null;
+                _evtNamespace = null;
+                _endpointUrl = null;
+                _orgEndpointUrl = null;
+                _maxBatchSizeInBytes = 0;
+                _beaconSupported = false;
+                _customHeaders = null;
+                _disableTelemetry = false;
+                _instrumentationKey = null;
+                _convertUndefined = UNDEFINED_VALUE;
+                _isRetryDisabled = false;
+                _sessionStorageUsed = null;
+                _namePrefix = UNDEFINED_VALUE;
+                _disableXhr = false;
+                _fetchKeepAlive = false;
+                _disableBeaconSplit = false;
+                _xhrSend = null;
+                _fallbackSend = null;
+                _sendPostMgr = null;
+                objDefine(_self, "_senderConfig", {
+                    g: function () {
+                        return objExtend({}, defaultAppInsightsChannelConfig);
+                    }
+                });
+            }
+        });
+        return _this;
+    }
+    Sender.constructEnvelope = function (orig, iKey, logger, convertUndefined) {
+        var envelope;
+        if (iKey !== orig.iKey && !isNullOrUndefined(iKey)) {
+            envelope = __assignFn(__assignFn({}, orig), { iKey: iKey });
+        }
+        else {
+            envelope = orig;
+        }
+        var creator = EnvelopeTypeCreator[envelope.baseType] || EventEnvelopeCreator;
+        return creator(logger, envelope, convertUndefined);
+    };
+// Removed Stub for Sender.prototype.pause.
+// Removed Stub for Sender.prototype.resume.
+// Removed Stub for Sender.prototype.flush.
+// Removed Stub for Sender.prototype.onunloadFlush.
+// Removed Stub for Sender.prototype.initialize.
+// Removed Stub for Sender.prototype.processTelemetry.
+// Removed Stub for Sender.prototype._xhrReadyStateChange.
+// Removed Stub for Sender.prototype.triggerSend.
+// Removed Stub for Sender.prototype._onError.
+// Removed Stub for Sender.prototype._onPartialSuccess.
+// Removed Stub for Sender.prototype._onSuccess.
+// Removed Stub for Sender.prototype._xdrOnLoad.
+// Removed Stub for Sender.prototype.addHeader.
+// Removed Stub for Sender.prototype.isCompletelyIdle.
+// Removed Stub for Sender.prototype.getOfflineSupport.
+// Removed Stub for Sender.prototype.getOfflineListener.
+    return Sender;
+}(BaseTelemetryPlugin));
+
+export { Sender as S };