@microsoft/1ds-post-js 4.0.1 → 4.0.2-nightly3.2307-25

package/bundle/es5/{ms.post-4.0.1.gbl.js → ms.post-4.0.2-nightly3.2307-25.gbl.js}

@@ -1,12 +1,12 @@
 /*!
- * 1DS JS SDK POST plugin, 4.0.1
+ * 1DS JS SDK POST plugin, 4.0.2-nightly3.2307-25
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
 (function (global, factory) {
     var undef = "undefined";
-    var nsKey, key, nm, theExports = {}, modName = "es5_ms_post_4_0_1", msMod="__ms$mod__";
-    var mods={}, modDetail=mods[modName]={}, ver="4.0.1";
+    var nsKey, key, nm, theExports = {}, modName = "es5_ms_post_4_0_2_nightly3_2307_25", msMod="__ms$mod__";
+    var mods={}, modDetail=mods[modName]={}, ver="4.0.2-nightly3.2307-25";
     // Versioned namespace "oneDS4"
     var exportNs=global, nsKey="oneDS4", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
     // Global namespace "oneDS"
@@ -26,6 +26,10 @@
 'use strict';
 
 
+var RT_PROFILE = "REAL_TIME";
+var NRT_PROFILE = "NEAR_REAL_TIME";
+var BE_PROFILE = "BEST_EFFORT";
+
 var strShimFunction = "function";
 var strShimObject = "object";
 var strShimUndefined = "undefined";
@@ -239,23 +243,43 @@ function dumpObj(object, format) {
     return objToString(object) + ": " + propertyValueDump;
 }
 
-function _unwrapFunction(funcName, target, polyFunc) {
+var _arrSlice = ArrProto[SLICE];
+var _throwMissingFunction = function (funcName, thisArg) {
+    throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+};
+var _unwrapInstFunction = function (funcName) {
+    return function (thisArg) {
+        return thisArg[funcName].apply(thisArg, _arrSlice.call(arguments, 1));
+    };
+};
+var _unwrapFunction = function (funcName, clsProto) {
+    var clsFn = clsProto && clsProto[funcName];
+    return function (thisArg) {
+        var theFunc = (thisArg && thisArg[funcName]) || clsFn;
+        if (theFunc) {
+            return theFunc.apply(thisArg, _arrSlice.call(arguments, 1));
+        }
+        _throwMissingFunction(funcName, thisArg);
+    };
+};
+var _unwrapFunctionWithPoly = function (funcName, clsProto, polyFunc) {
+    var clsFn = clsProto && clsProto[funcName];
     return function (thisArg) {
-        var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
+        var theFunc = (thisArg && thisArg[funcName]) || clsFn;
         if (theFunc || polyFunc) {
             var theArgs = arguments;
-            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
+            return (theFunc || polyFunc).apply(thisArg, theFunc ? _arrSlice.call(theArgs, 1) : theArgs);
         }
-        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+        _throwMissingFunction(funcName, thisArg);
     };
-}
+};
 
 var mathMax = MathCls.max;
 
 var strSlice = _unwrapFunction(SLICE, StrProto);
 
 var strSubstring = _unwrapFunction("substring", StrProto);
-var strSubstr = _unwrapFunction("substr", StrProto, polyStrSubstr);
+var strSubstr = _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
 function polyStrSubstr(value, start, length) {
     if (isNullOrUndefined(value)) {
         throwTypeError("'polyStrSubstr called with invalid " + dumpObj(value));
@@ -276,7 +300,7 @@ function strLeft(value, count) {
     return strSubstring(value, 0, count);
 }
 
-var strStartsWith = _unwrapFunction("startsWith", StrProto, polyStrStartsWith);
+var strStartsWith = _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith);
 function polyStrStartsWith(value, searchString, position) {
     if (!isString(value)) {
         throwTypeError("'" + dumpObj(value) + "' is not a string");
@@ -393,15 +417,13 @@ var _cachedWindow;
 var _cachedDocument;
 var _cachedNavigator;
 var _isNode;
-function lazySafeGetInst(name) {
-    return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
-}
-function getGlobal(useCached) {
-    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, NULL_VALUE));
+var lazySafeGetInst = function (name) { return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE); };
+var getGlobal = function (useCached) {
+    (!_cachedGlobal || useCached === false || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, NULL_VALUE));
     return _cachedGlobal.v;
-}
-function getInst(name, useCached) {
-    var gbl = getGlobal(useCached);
+};
+var getInst = function (name, useCached) {
+    var gbl = (!_cachedGlobal || useCached === false) ? getGlobal(useCached) : _cachedGlobal.v;
     if (gbl && gbl[name]) {
         return gbl[name];
     }
@@ -409,32 +431,26 @@ function getInst(name, useCached) {
         return _cachedWindow.v;
     }
     return NULL_VALUE;
-}
-function hasDocument() {
-    return !!getDocument();
-}
-function getDocument() {
-    (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
+};
+var hasDocument = function () { return !!getDocument(); };
+var getDocument = function () {
+    (!_cachedDocument || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
     return _cachedDocument.v;
-}
-function hasWindow() {
-    return !!getWindow();
-}
-function getWindow() {
-    (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
+};
+var hasWindow = function () { return !!getWindow(); };
+var getWindow = function () {
+    (!_cachedWindow || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
     return _cachedWindow.v;
-}
-function hasNavigator() {
-    return !!getNavigator();
-}
-function getNavigator() {
-    (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
+};
+var hasNavigator = function () { return !!getNavigator(); };
+var getNavigator = function () {
+    (!_cachedNavigator || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
     return _cachedNavigator.v;
-}
-function isNode() {
+};
+var isNode = function () {
     !_isNode && (_isNode = safeGetLazy(function () { return !!(process && (process.versions || {}).node); }, false));
     return _isNode.v;
-}
+};
 
 var _symbol;
 var _symbolFor;
@@ -475,36 +491,54 @@ function isIterable(value) {
     return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
 }
 
+var _iterSymbol;
 function iterForOf(iter, callbackfn, thisArg) {
     if (iter) {
         if (!isIterator(iter)) {
-            var itSymbol = getKnownSymbol(3 );
-            iter = iter[itSymbol] ? iter[itSymbol]() : null;
+            !_iterSymbol && (_iterSymbol = getLazy(function () { return getKnownSymbol(3 ); }));
+            iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;
         }
         if (isIterator(iter)) {
+            var err = void 0;
+            var iterResult = void 0;
             try {
                 var count = 0;
-                var value = iter.next();
-                while (!value[DONE]) {
-                    if (callbackfn.call(thisArg || iter, value[VALUE], count, iter) === -1) {
+                while (!(iterResult = iter.next())[DONE]) {
+                    if (callbackfn.call(thisArg || iter, iterResult[VALUE], count, iter) === -1) {
                         break;
                     }
                     count++;
-                    value = iter.next();
                 }
-                iter.return && iter.return(value);
             }
-            catch (e) {
-                iter.throw && iter.throw(e);
+            catch (failed) {
+                err = { e: failed };
+                if (iter.throw) {
+                    iterResult = null;
+                    iter.throw(err);
+                }
+            }
+            finally {
+                try {
+                    if (iterResult && !iterResult[DONE]) {
+                        iter.return && iter.return(iterResult);
+                    }
+                }
+                finally {
+                    if (err) {
+                        throw err.e;
+                    }
+                }
             }
         }
     }
 }
 
+var fnApply = _unwrapInstFunction("apply");
+
 function arrAppend(target, elms) {
     if (!isUndefined(elms) && target) {
         if (isArray(elms)) {
-            target.push.apply(target, elms);
+            fnApply(target.push, target, elms);
         }
         else if (isIterator(elms) || isIterable(elms)) {
             iterForOf(elms, function (elm) {
@@ -535,6 +569,8 @@ var arrIndexOf = _unwrapFunction(INDEX_OF, ArrProto);
 
 var arrSlice = _unwrapFunction(SLICE, ArrProto);
 
+var fnCall = _unwrapInstFunction("call");
+
 var _objCreate = ObjClass["create"];
 var objCreate = _objCreate || polyObjCreate;
 function polyObjCreate(obj) {
@@ -595,7 +631,7 @@ function createCustomError(name, constructCb, errorBase) {
         var _this = this;
         try {
             _safeSetName(theBaseClass, name);
-            var _self = theBaseClass.apply(_this, arguments) || _this;
+            var _self = fnApply(theBaseClass, _this, arrSlice(arguments)) || _this;
             if (_self !== _this) {
                 var orgProto = objGetPrototypeOf(_this);
                 if (orgProto !== objGetPrototypeOf(_self)) {
@@ -632,7 +668,7 @@ function _createTrimFn(exp) {
 }
 var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
 
-var strTrim = _unwrapFunction("trim", StrProto, polyStrTrim);
+var strTrim = _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
 
 var _fnToString;
 var _objCtrFnString;
@@ -648,7 +684,7 @@ function isPlainObject(value) {
     if (value !== _gblWindow) {
         if (!_objCtrFnString) {
             _fnToString = Function[PROTOTYPE].toString;
-            _objCtrFnString = _fnToString.call(ObjClass);
+            _objCtrFnString = fnCall(_fnToString, ObjClass);
         }
         try {
             var proto = objGetPrototypeOf(value);
@@ -668,7 +704,7 @@ function isPlainObject(value) {
 
 var _perf;
 function getPerformance() {
-    (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = lazySafeGetInst("performance"));
+    (!_perf || (!_perf.b && _globalLazyTestHooks && _globalLazyTestHooks.lzy)) && (_perf = lazySafeGetInst("performance"));
     return _perf.v;
 }
 function perfNow() {
@@ -750,7 +786,7 @@ function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
     var timerFn = theArgs[0];
     theArgs[0] = function () {
         handler.dn();
-        timerFn.apply(self, arguments);
+        fnApply(timerFn, self, arrSlice(arguments));
     };
     var handler = _createTimerHandler(startTimer, function (timerId) {
         if (timerId) {
@@ -758,11 +794,11 @@ function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
                 timerId.refresh();
                 return timerId;
             }
-            clearFn.call(self, timerId);
+            fnApply(clearFn, self, [timerId]);
         }
-        return setFn.apply(self, theArgs);
+        return fnApply(setFn, self, theArgs);
     }, function (timerId) {
-        clearFn.call(self, timerId);
+        fnApply(clearFn, self, [timerId]);
     });
     return handler.h;
 }
@@ -1058,9 +1094,9 @@ var EventsDiscardedReason = createEnumStyle({
     QueueFull: 5
 });
 
-var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
 var _DYN_BLK_VAL = "blkVal";
-var _DYN_LENGTH = "length";
+var _DYN_LENGTH$2 = "length";
 var _DYN_RD_ONLY = "rdOnly";
 var _DYN_NOTIFY = "notify";
 var _DYN_WARN_TO_CONSOLE = "warnToConsole";
@@ -1069,12 +1105,12 @@ var _DYN_SET_DF = "setDf";
 var _DYN_WATCH = "watch";
 var _DYN_LOGGER = "logger";
 var _DYN_APPLY = "apply";
-var _DYN_PUSH = "push";
-var _DYN_SPLICE = "splice";
+var _DYN_PUSH$1 = "push";
+var _DYN_SPLICE$1 = "splice";
 var _DYN_HDLR = "hdlr";
 var _DYN_CANCEL = "cancel";
-var _DYN_INITIALIZE = "initialize";
-var _DYN_IDENTIFIER = "identifier";
+var _DYN_INITIALIZE$1 = "initialize";
+var _DYN_IDENTIFIER$1 = "identifier";
 var _DYN_IS_INITIALIZED = "isInitialized";
 var _DYN_GET_PLUGIN = "getPlugin";
 var _DYN_NAME = "name";
@@ -1094,7 +1130,7 @@ var _DYN_UPDATE = "update";
 var _DYN_GET_NEXT = "getNext";
 var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
 var _DYN_USER_AGENT = "userAgent";
-var _DYN_SPLIT = "split";
+var _DYN_SPLIT$1 = "split";
 var _DYN_NODE_TYPE = "nodeType";
 var _DYN_REPLACE = "replace";
 var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
@@ -1109,7 +1145,7 @@ var aggregationErrorType;
 function throwAggregationError(message, sourceErrors) {
     if (!aggregationErrorType) {
         aggregationErrorType = createCustomError("AggregationError", function (self, args) {
-            if (args[_DYN_LENGTH ] > 1) {
+            if (args[_DYN_LENGTH$2 ] > 1) {
                 self.errors = args[1];
             }
         });
@@ -1121,13 +1157,6 @@ function throwAggregationError(message, sourceErrors) {
     throw new aggregationErrorType(theMessage, sourceErrors || []);
 }
 
-var _theLogger = null;
-function _debugLog(id, message) {
-    if (_theLogger) {
-        _theLogger(id, message);
-    }
-}
-
 var STRING_STATES = [
     "pending", "resolving", "resolved", "rejected"
 ];
@@ -1190,14 +1219,11 @@ function _createPromise(newPromise, processor, executor) {
             _handled = true;
             _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
             _unHandledRejectionHandler = null;
-            _debugLog(_toString(), "then(" + dumpFnObj(onResolved) + ", " + dumpFnObj(onResolved) + ")");
             var thenPromise = newPromise(function (resolve, reject) {
                 _queue.push(function () {
                     try {
-                        _debugLog(_toString(), "Handling settled value " + dumpFnObj(_settledValue));
                         var handler = _state === 2  ? onResolved : onRejected;
                         var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);
-                        _debugLog(_toString(), "Handling Result " + dumpFnObj(value));
                         if (isPromiseLike(value)) {
                             value.then(resolve, reject);
                         }
@@ -1215,12 +1241,10 @@ function _createPromise(newPromise, processor, executor) {
                         reject(e);
                     }
                 });
-                _debugLog(_toString(), "Added to Queue " + _queue.length);
                 if (_hasResolved) {
                     _processQueue();
                 }
             }, additionalArgs);
-            _debugLog(_toString(), "Created -> " + thenPromise.toString());
             return thenPromise;
         }
         finally {
@@ -1251,49 +1275,37 @@ function _createPromise(newPromise, processor, executor) {
         if (_queue.length > 0) {
             var pending = _queue.slice();
             _queue = [];
-            _debugLog(_toString(), "Processing queue " + pending.length);
             _handled = true;
             processor(pending);
-            _debugLog(_toString(), "Processing done");
             _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
             _unHandledRejectionHandler = null;
         }
-        else {
-            _debugLog(_toString(), "Empty Processing queue ");
-        }
     };
     var _createSettleIfFn = function (newState, allowState) {
         return function (theValue) {
             if (_state === allowState) {
                 if (newState === 2  && isPromiseLike(theValue)) {
                     _state = 1 ;
-                    _debugLog(_toString(), "Resolving");
                     theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));
                     return;
                 }
                 _state = newState;
                 _hasResolved = true;
                 _settledValue = theValue;
-                _debugLog(_toString(), _strState());
                 _processQueue();
                 if (!_handled && newState === 3  && !_unHandledRejectionHandler) {
                     _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
                 }
             }
-            else {
-                _debugLog(_toString(), "Already " + _strState());
-            }
         };
     };
     var _notifyUnhandledRejection = function () {
         if (!_handled) {
             if (isNode()) {
-                _debugLog(_toString(), "Emitting " + NODE_UNHANDLED_REJECTION);
                 process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
             }
             else {
                 var gbl = getWindow() || getGlobal();
-                _debugLog(_toString(), "Emitting " + UNHANDLED_REJECTION);
                 emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {
                     objDefine(theEvt, "promise", { g: function () { return _thePromise; } });
                     theEvt.reason = _settledValue;
@@ -1323,14 +1335,12 @@ function _createPromise(newPromise, processor, executor) {
         }
         var _rejectFn = _createSettleIfFn(3 , 0 );
         try {
-            _debugLog(_toString(), "Executing");
             executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);
         }
         catch (e) {
             _rejectFn(e);
         }
     })();
-    _debugLog(_toString(), "Returning");
     return _thePromise;
 }
 
@@ -1554,13 +1564,13 @@ function isIE() {
     var nav = getNavigator();
     if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
         _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-        var userAgent = (_navUserAgentCheck || STR_EMPTY$2)[_DYN_TO_LOWER_CASE ]();
+        var userAgent = (_navUserAgentCheck || STR_EMPTY$2)[_DYN_TO_LOWER_CASE$1 ]();
         _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
     }
     return _isTrident;
 }
-function isBeaconsSupported() {
-    if (_beaconsSupported === null) {
+function isBeaconsSupported(useCached) {
+    if (_beaconsSupported === null || useCached === false) {
         _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
     }
     return _beaconsSupported;
@@ -1656,7 +1666,7 @@ function newId(maxLength) {
     var number = random32() >>> 0;
     var chars = 0;
     var result = STR_EMPTY$2;
-    while (result[_DYN_LENGTH ] < maxLength) {
+    while (result[_DYN_LENGTH$2 ] < maxLength) {
         chars++;
         result += base64chars.charAt(number & 0x3F);
         number >>>= 6;
@@ -1668,7 +1678,7 @@ function newId(maxLength) {
     return result;
 }
 
-var version = '3.0.2';
+var version = '3.0.3-nightly3.2307-25';
 var instanceName = "." + newId(6);
 var _dataUid = 0;
 function _canAcceptData(target) {
@@ -1736,7 +1746,7 @@ function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
         if (!isArray(fallbacks)) {
             fallbacks = [fallbacks];
         }
-        for (var lp = 0; lp < fallbacks[_DYN_LENGTH ]; lp++) {
+        for (var lp = 0; lp < fallbacks[_DYN_LENGTH$2 ]; lp++) {
             var fallback = fallbacks[lp];
             var fbValue = theConfig[fallback];
             if (isDefaultValid(fbValue)) {
@@ -1771,7 +1781,7 @@ function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
         var newValue_1;
         if (isArray(theValue)) {
             newValue_1 = [];
-            newValue_1[_DYN_LENGTH ] = theValue[_DYN_LENGTH ];
+            newValue_1[_DYN_LENGTH$2 ] = theValue[_DYN_LENGTH$2 ];
         }
         else if (isPlainObject(theValue)) {
             newValue_1 = {};
@@ -1862,7 +1872,7 @@ function _cfgDeepCopy(source) {
         var target_1;
         if (isArray(source)) {
             target_1 = [];
-            target_1[_DYN_LENGTH ] = source[_DYN_LENGTH ];
+            target_1[_DYN_LENGTH$2 ] = source[_DYN_LENGTH$2 ];
         }
         else if (isPlainObject(source)) {
             target_1 = {};
@@ -1946,7 +1956,7 @@ function _createDynamicProperty(state, theConfig, name, value) {
         trk: function (handler) {
             if (handler && handler.fn) {
                 if (arrIndexOf(detail.h, handler) === -1) {
-                    detail.h[_DYN_PUSH ](handler);
+                    detail.h[_DYN_PUSH$1 ](handler);
                 }
                 state.trk(handler, detail);
             }
@@ -1954,7 +1964,7 @@ function _createDynamicProperty(state, theConfig, name, value) {
         clr: function (handler) {
             var idx = arrIndexOf(detail.h, handler);
             if (idx !== -1) {
-                detail.h[_DYN_SPLICE ](idx, 1);
+                detail.h[_DYN_SPLICE$1 ](idx, 1);
             }
         }
     };
@@ -2158,7 +2168,7 @@ function _createState(cfgHandler) {
                             _useHandler(handler, handler.fn);
                         }
                         catch (e) {
-                            watcherFailures_1[_DYN_PUSH ](e);
+                            watcherFailures_1[_DYN_PUSH$1 ](e);
                         }
                     }
                 }
@@ -2168,16 +2178,16 @@ function _createState(cfgHandler) {
                     _notifyWatchers();
                 }
                 catch (e) {
-                    watcherFailures_1[_DYN_PUSH ](e);
+                    watcherFailures_1[_DYN_PUSH$1 ](e);
                 }
             }
-            if (watcherFailures_1[_DYN_LENGTH ] > 0) {
+            if (watcherFailures_1[_DYN_LENGTH$2 ] > 0) {
                 throwAggregationError("Watcher error(s): ", watcherFailures_1);
             }
         }
     }
     function _addWatcher(detail) {
-        if (detail && detail.h[_DYN_LENGTH ] > 0) {
+        if (detail && detail.h[_DYN_LENGTH$2 ] > 0) {
             if (!_waitingHandlers) {
                 _waitingHandlers = [];
             }
@@ -2187,10 +2197,10 @@ function _createState(cfgHandler) {
                     _notifyWatchers();
                 }, 0);
             }
-            for (var idx = 0; idx < detail.h[_DYN_LENGTH ]; idx++) {
+            for (var idx = 0; idx < detail.h[_DYN_LENGTH$2 ]; idx++) {
                 var handler = detail.h[idx];
                 if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
-                    _waitingHandlers[_DYN_PUSH ](handler);
+                    _waitingHandlers[_DYN_PUSH$1 ](handler);
                 }
             }
         }
@@ -2199,7 +2209,7 @@ function _createState(cfgHandler) {
         if (handler) {
             var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
             if (arrIndexOf(details, detail) === -1) {
-                details[_DYN_PUSH ](detail);
+                details[_DYN_PUSH$1 ](detail);
             }
         }
     }
@@ -2487,14 +2497,14 @@ var DiagnosticLogger = /** @class */ (function () {
                 }
                 if (logMessage) {
                     if (severity <= _loggingLevelTelemetry) {
-                        _self.queue[_DYN_PUSH ](message);
+                        _self.queue[_DYN_PUSH$1 ](message);
                         _messageCount++;
                         _debugExtMsg((severity === 1  ? "error" : "warn"), message);
                     }
                     if (_messageCount === _maxInternalMessageLimit) {
                         var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
                         var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                        _self.queue[_DYN_PUSH ](throttleMessage);
+                        _self.queue[_DYN_PUSH$1 ](throttleMessage);
                         if (severity === 1 ) {
                             _self.errorToConsole(throttleLimitMessage);
                         }
@@ -2590,7 +2600,7 @@ var PerfEvent = /** @class */ (function () {
             var childTime = 0;
             var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
             if (isArray(childEvts)) {
-                for (var lp = 0; lp < childEvts[_DYN_LENGTH ]; lp++) {
+                for (var lp = 0; lp < childEvts[_DYN_LENGTH$2 ]; lp++) {
                     var childEvt = childEvts[lp];
                     if (childEvt) {
                         childTime += childEvt[_DYN_TIME ];
@@ -2627,7 +2637,7 @@ function doPerf(mgrSource, getSource, func, details, isAsync) {
                                 children = [];
                                 currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
                             }
-                            children[_DYN_PUSH ](perfEvt);
+                            children[_DYN_PUSH$1 ](perfEvt);
                         }
                     }
                     perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
@@ -2710,7 +2720,7 @@ function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
             args[_i - 2] = arguments[_i];
         }
         if (onComplete) {
-            _onComplete[_DYN_PUSH ]({
+            _onComplete[_DYN_PUSH$1 ]({
                 func: onComplete,
                 self: !isUndefined(that) ? that : context.ctx,
                 args: args
@@ -2722,7 +2732,7 @@ function _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {
         _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
         if (!nextProxy) {
             var onComplete = _onComplete;
-            if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
+            if (onComplete && onComplete[_DYN_LENGTH$2 ] > 0) {
                 arrForEach(onComplete, function (completeDetails) {
                     try {
                         completeDetails.func.call(completeDetails.self, completeDetails.args);
@@ -2863,7 +2873,7 @@ function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
 function createTelemetryProxyChain(plugins, config, core, startAt) {
     var firstProxy = null;
     var add = startAt ? false : true;
-    if (isArray(plugins) && plugins[_DYN_LENGTH ] > 0) {
+    if (isArray(plugins) && plugins[_DYN_LENGTH$2 ] > 0) {
         var lastProxy_1 = null;
         arrForEach(plugins, function (thePlugin) {
             if (!add && startAt === thePlugin) {
@@ -2892,7 +2902,7 @@ function createTelemetryPluginProxy(plugin, config, core) {
     var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
     var chainId;
     if (plugin) {
-        chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
+        chainId = plugin[_DYN_IDENTIFIER$1 ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
     }
     else {
         chainId = "Unknown-0-" + _chainId++;
@@ -2924,7 +2934,7 @@ function createTelemetryPluginProxy(plugin, config, core) {
     }
     function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
         var hasRun = false;
-        var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
+        var identifier = plugin ? plugin[_DYN_IDENTIFIER$1 ] : strTelemetryPluginChain;
         var hasRunContext = itemCtx[strHasRunFlags];
         if (!hasRunContext) {
             hasRunContext = itemCtx[strHasRunFlags] = {};
@@ -3019,7 +3029,7 @@ function createUnloadHandlerContainer() {
     var handlers = [];
     function _addHandler(handler) {
         if (handler) {
-            handlers[_DYN_PUSH ](handler);
+            handlers[_DYN_PUSH$1 ](handler);
         }
     }
     function _runHandlers(unloadCtx, unloadState) {
@@ -3079,7 +3089,7 @@ var BaseTelemetryPlugin = /** @class */ (function () {
         var _hookContainer;
         _initDefaults();
         dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-            _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
+            _self[_DYN_INITIALIZE$1 ] = function (config, core, extensions, pluginChain) {
                 _setDefaults(config, core, pluginChain);
                 _isinitialized = true;
             };
@@ -3258,7 +3268,7 @@ function _getEvtNamespace(eventName, evtNamespace) {
     var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$2) || []);
     return _a = {},
         _a[_DYN_TYPE ] = parsedEvent[1],
-        _a.ns = ((parsedEvent[2] || STR_EMPTY$2).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$2)[_DYN_SPLIT ](".").sort()).join("."),
+        _a.ns = ((parsedEvent[2] || STR_EMPTY$2).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$2)[_DYN_SPLIT$1 ](".").sort()).join("."),
         _a;
 }
 function _getRegisteredEvents(target, evtName, addDefault) {
@@ -3295,14 +3305,14 @@ function _doAttach(obj, evtName, handlerRef, useCapture) {
     return result;
 }
 function _doUnregister(target, events, evtName, unRegFn) {
-    var idx = events[_DYN_LENGTH ];
+    var idx = events[_DYN_LENGTH$2 ];
     while (idx--) {
         var theEvent = events[idx];
         if (theEvent) {
             if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
                 if (!unRegFn || unRegFn(theEvent)) {
                     _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER ], theEvent.capture);
-                    events[_DYN_SPLICE ](idx, 1);
+                    events[_DYN_SPLICE$1 ](idx, 1);
                 }
             }
         }
@@ -3317,7 +3327,7 @@ function _unregisterEvents(target, evtName, unRegFn) {
         objForEachKey(eventCache, function (evtType, events) {
             _doUnregister(target, events, evtName, unRegFn);
         });
-        if (objKeys(eventCache)[_DYN_LENGTH ] === 0) {
+        if (objKeys(eventCache)[_DYN_LENGTH$2 ] === 0) {
             elmNodeData.kill(target, strEvents);
         }
     }
@@ -3331,7 +3341,7 @@ function mergeEvtNamespace(theNamespace, namespaces) {
         else {
             newNamespaces = [theNamespace, namespaces];
         }
-        newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
+        newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
     }
     else {
         newNamespaces = theNamespace;
@@ -3354,7 +3364,7 @@ function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
                     _a[_DYN_HANDLER ] = handlerRef,
                     _a.capture = useCapture,
                     _a);
-                _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
+                _getRegisteredEvents(target, evtName.type)[_DYN_PUSH$1 ](registeredEvent);
             }
         }
         catch (e) {
@@ -3409,7 +3419,7 @@ function removeEventHandler(eventName, callback, evtNamespace) {
 }
 function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
     var added = false;
-    if (listener && events && events[_DYN_LENGTH ] > 0) {
+    if (listener && events && events[_DYN_LENGTH$2 ] > 0) {
         arrForEach(events, function (name) {
             if (name) {
                 if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
@@ -3424,7 +3434,7 @@ function addEventListeners(events, listener, excludeEvents, evtNamespace) {
     var added = false;
     if (listener && events && isArray(events)) {
         added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
-        if (!added && excludeEvents && excludeEvents[_DYN_LENGTH ] > 0) {
+        if (!added && excludeEvents && excludeEvents[_DYN_LENGTH$2 ] > 0) {
             added = _addEventListeners(events, listener, null, evtNamespace);
         }
     }
@@ -3490,8 +3500,14 @@ function removePageShowEventListener(listener, evtNamespace) {
 
 var STR_EMPTY$1 = "";
 
+var _DYN_TIMINGS$1 = "timings";
+var _DYN_VALUE = "value";
+var _DYN_KIND = "kind";
+var _DYN_LENGTH$1 = "length";
+var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
+
 var _a$1;
-var Version = '4.0.1';
+var Version = '4.0.2-nightly3.2307-25';
 var FullVersionString = "1DS-Web-JS-" + Version;
 var ObjHasOwnProperty = ObjProto$1.hasOwnProperty;
 var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
@@ -3531,21 +3547,21 @@ function sanitizeProperty(name, property, stringifyObjects) {
     else if (propType === "object" && !ObjHasOwnProperty.call(property, "value")) {
         property = { value: stringifyObjects ? JSON.stringify(property) : property };
     }
-    else if (isNullOrUndefined(property.value)
-        || property.value === STR_EMPTY$1 || (!isString(property.value)
-        && !isNumber(property.value) && !isBoolean(property.value)
-        && !isArray(property.value))) {
+    else if (isNullOrUndefined(property[_DYN_VALUE ])
+        || property[_DYN_VALUE ] === STR_EMPTY$1 || (!isString(property[_DYN_VALUE ])
+        && !isNumber(property[_DYN_VALUE ]) && !isBoolean(property[_DYN_VALUE ])
+        && !isArray(property[_DYN_VALUE ]))) {
         return null;
     }
-    if (isArray(property.value) &&
-        !isArrayValid(property.value)) {
+    if (isArray(property[_DYN_VALUE ]) &&
+        !isArrayValid(property[_DYN_VALUE ])) {
         return null;
     }
-    if (!isNullOrUndefined(property.kind)) {
-        if (isArray(property.value) || !isValueKind(property.kind)) {
+    if (!isNullOrUndefined(property[_DYN_KIND ])) {
+        if (isArray(property[_DYN_VALUE ]) || !isValueKind(property[_DYN_KIND ])) {
             return null;
         }
-        property.value = property.value.toString();
+        property[_DYN_VALUE ] = property[_DYN_VALUE ].toString();
     }
     return property;
 }
@@ -3582,7 +3598,7 @@ function extend(obj, obj2, obj3, obj4, obj5) {
     var extended = {};
     var deep = false;
     var i = 0;
-    var length = arguments.length;
+    var length = arguments[_DYN_LENGTH$1 ];
     var theArgs = arguments;
     if (isBoolean(theArgs[0])) {
         deep = theArgs[0];
@@ -3628,13 +3644,13 @@ function isDataType(value) {
     return false;
 }
 function isArrayValid(value) {
-    return value.length > 0;
+    return value[_DYN_LENGTH$1 ] > 0;
 }
 function setProcessTelemetryTimings(event, identifier) {
     var evt = event;
-    evt.timings = evt.timings || {};
-    evt.timings.processTelemetryStart = evt.timings.processTelemetryStart || {};
-    evt.timings.processTelemetryStart[identifier] = getTime();
+    evt[_DYN_TIMINGS$1 ] = evt[_DYN_TIMINGS$1 ] || {};
+    evt[_DYN_TIMINGS$1 ][_DYN_PROCESS_TELEMETRY_ST0 ] = evt[_DYN_TIMINGS$1 ][_DYN_PROCESS_TELEMETRY_ST0 ] || {};
+    evt[_DYN_TIMINGS$1 ][_DYN_PROCESS_TELEMETRY_ST0 ][identifier] = getTime();
 }
 function getFieldValueType(value) {
     var theType = 0 ;
@@ -3653,12 +3669,12 @@ function getFieldValueType(value) {
             theType = 4 ;
             if (isArray(value)) {
                 theType = 4096 ;
-                if (value.length > 0) {
+                if (value[_DYN_LENGTH$1 ] > 0) {
                     theType |= getFieldValueType(value[0]);
                 }
             }
             else if (ObjHasOwnProperty.call(value, "value")) {
-                theType = 8192  | getFieldValueType(value.value);
+                theType = 8192  | getFieldValueType(value[_DYN_VALUE ]);
             }
         }
     }
@@ -3697,10 +3713,6 @@ function isGreaterThanZero(value) {
     return value > 0;
 }
 
-var RT_PROFILE = "REAL_TIME";
-var NRT_PROFILE = "NEAR_REAL_TIME";
-var BE_PROFILE = "BEST_EFFORT";
-
 var STR_EMPTY = "";
 var STR_POST_METHOD = "POST";
 var STR_DISABLED_PROPERTY_NAME = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
@@ -3729,6 +3741,75 @@ var STR_MSFPC = "msfpc";
 var STR_TRACE = "trace";
 var STR_USER = "user";
 
+var _DYN_ALLOW_REQUEST_SENDIN0 = "allowRequestSending";
+var _DYN_FIRST_REQUEST_SENT = "firstRequestSent";
+var _DYN_SHOULD_ADD_CLOCK_SKE1 = "shouldAddClockSkewHeaders";
+var _DYN_GET_CLOCK_SKEW_HEADE2 = "getClockSkewHeaderValue";
+var _DYN_SET_CLOCK_SKEW = "setClockSkew";
+var _DYN_DATA = "data";
+var _DYN_LENGTH = "length";
+var _DYN_CONCAT = "concat";
+var _DYN_I_KEY = "iKey";
+var _DYN_COUNT = "count";
+var _DYN_EVENTS = "events";
+var _DYN_PUSH = "push";
+var _DYN_SPLIT = "split";
+var _DYN_SPLICE = "splice";
+var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_HDRS = "hdrs";
+var _DYN_USE_HDRS = "useHdrs";
+var _DYN_INITIALIZE = "initialize";
+var _DYN_SET_TIMEOUT_OVERRIDE = "setTimeoutOverride";
+var _DYN_CLEAR_TIMEOUT_OVERRI3 = "clearTimeoutOverride";
+var _DYN_PAYLOAD_PREPROCESSOR = "payloadPreprocessor";
+var _DYN_OVERRIDE_ENDPOINT_UR4 = "overrideEndpointUrl";
+var _DYN_AVOID_OPTIONS = "avoidOptions";
+var _DYN_DISABLE_EVENT_TIMING5 = "disableEventTimings";
+var _DYN_STRINGIFY_OBJECTS = "stringifyObjects";
+var _DYN_ENABLE_COMPOUND_KEY = "enableCompoundKey";
+var _DYN_DISABLE_XHR_SYNC = "disableXhrSync";
+var _DYN_DISABLE_FETCH_KEEP_A6 = "disableFetchKeepAlive";
+var _DYN_USE_SEND_BEACON = "useSendBeacon";
+var _DYN_ALWAYS_USE_XHR_OVERR7 = "alwaysUseXhrOverride";
+var _DYN_UNLOAD_TRANSPORTS = "unloadTransports";
+var _DYN_URL_STRING = "urlString";
+var _DYN_TIMEOUT = "timeout";
+var _DYN_ONTIMEOUT = "ontimeout";
+var _DYN__SEND_REASON = "_sendReason";
+var _DYN_HEADERS = "headers";
+var _DYN_GET_RESPONSE_HEADER = "getResponseHeader";
+var _DYN_GET_ALL_RESPONSE_HEA8 = "getAllResponseHeaders";
+var _DYN__THE_PAYLOAD = "_thePayload";
+var _DYN_BATCHES = "batches";
+var _DYN_SEND_TYPE = "sendType";
+var _DYN_CAN_SEND_REQUEST = "canSendRequest";
+var _DYN_SEND_QUEUED_REQUESTS = "sendQueuedRequests";
+var _DYN_IS_COMPLETELY_IDLE = "isCompletelyIdle";
+var _DYN_SET_UNLOADING = "setUnloading";
+var _DYN_IS_TENANT_KILLED = "isTenantKilled";
+var _DYN_SEND_SYNCHRONOUS_BAT9 = "sendSynchronousBatch";
+var _DYN__TRANSPORT = "_transport";
+var _DYN_GET_WPARAM = "getWParam";
+var _DYN_IS_BEACON = "isBeacon";
+var _DYN_TIMINGS = "timings";
+var _DYN_IS_TEARDOWN = "isTeardown";
+var _DYN_IS_SYNC = "isSync";
+var _DYN_SEND_POST = "sendPOST";
+var _DYN_SET_KILL_SWITCH_TENA10 = "setKillSwitchTenants";
+var _DYN__BACK_OFF_TRANSMISSI11 = "_backOffTransmission";
+var _DYN_IDENTIFIER = "identifier";
+var _DYN_DISABLE_OPTIMIZE_OBJ = "disableOptimizeObj";
+var _DYN_IGNORE_MC1_MS0_COOKI12 = "ignoreMc1Ms0CookieProcessing";
+var _DYN_EVENTS_LIMIT_IN_MEM = "eventsLimitInMem";
+var _DYN_AUTO_FLUSH_EVENTS_LI13 = "autoFlushEventsLimit";
+var _DYN_DISABLE_AUTO_BATCH_F14 = "disableAutoBatchFlushLimit";
+var _DYN_OVERRIDE_INSTRUMENTA15 = "overrideInstrumentationKey";
+var _DYN_DISABLE_TELEMETRY = "disableTelemetry";
+var _DYN_SEND_ATTEMPT = "sendAttempt";
+var _DYN_LATENCY = "latency";
+var _DYN_BASE_DATA = "baseData";
+var _DYN_SYNC = "sync";
+
 function _getEventMsfpc(theEvent) {
     var intWeb = ((theEvent.ext || {})["intweb"]);
     if (intWeb && isValueAssigned(intWeb[STR_MSFPC])) {
@@ -3738,31 +3819,31 @@ function _getEventMsfpc(theEvent) {
 }
 function _getMsfpc(theEvents) {
     var msfpc = null;
-    for (var lp = 0; msfpc === null && lp < theEvents.length; lp++) {
+    for (var lp = 0; msfpc === null && lp < theEvents[_DYN_LENGTH ]; lp++) {
         msfpc = _getEventMsfpc(theEvents[lp]);
     }
     return msfpc;
 }
 var EventBatch = /** @class */ (function () {
     function EventBatch(iKey, addEvents) {
-        var events = addEvents ? [].concat(addEvents) : [];
+        var events = addEvents ? [][_DYN_CONCAT ](addEvents) : [];
         var _self = this;
         var _msfpc = _getMsfpc(events);
-        _self.iKey = function () {
+        _self[_DYN_I_KEY ] = function () {
             return iKey;
         };
         _self.Msfpc = function () {
             return _msfpc || STR_EMPTY;
         };
-        _self.count = function () {
-            return events.length;
+        _self[_DYN_COUNT ] = function () {
+            return events[_DYN_LENGTH ];
         };
-        _self.events = function () {
+        _self[_DYN_EVENTS ] = function () {
             return events;
         };
         _self.addEvent = function (theEvent) {
             if (theEvent) {
-                events.push(theEvent);
+                events[_DYN_PUSH ](theEvent);
                 if (!_msfpc) {
                     _msfpc = _getEventMsfpc(theEvent);
                 }
@@ -3770,14 +3851,14 @@ var EventBatch = /** @class */ (function () {
             }
             return false;
         };
-        _self.split = function (fromEvent, numEvents) {
+        _self[_DYN_SPLIT ] = function (fromEvent, numEvents) {
             var theEvents;
-            if (fromEvent < events.length) {
-                var cnt = events.length - fromEvent;
+            if (fromEvent < events[_DYN_LENGTH ]) {
+                var cnt = events[_DYN_LENGTH ] - fromEvent;
                 if (!isNullOrUndefined(numEvents)) {
                     cnt = numEvents < cnt ? numEvents : cnt;
                 }
-                theEvents = events.splice(fromEvent, cnt);
+                theEvents = events[_DYN_SPLICE ](fromEvent, cnt);
                 _msfpc = _getMsfpc(events);
             }
             return new EventBatch(iKey, theEvents);
@@ -3797,10 +3878,10 @@ var ClockSkewManager = /** @class */ (function () {
         var _clockSkewHeaderValue = "use-collector-delta";
         var _clockSkewSet = false;
         dynamicProto(ClockSkewManager, this, function (_self) {
-            _self.allowRequestSending = function () {
+            _self[_DYN_ALLOW_REQUEST_SENDIN0 ] = function () {
                 return _allowRequestSending;
             };
-            _self.firstRequestSent = function () {
+            _self[_DYN_FIRST_REQUEST_SENT ] = function () {
                 if (_isFirstRequest) {
                     _isFirstRequest = false;
                     if (!_clockSkewSet) {
@@ -3808,13 +3889,13 @@ var ClockSkewManager = /** @class */ (function () {
                     }
                 }
             };
-            _self.shouldAddClockSkewHeaders = function () {
+            _self[_DYN_SHOULD_ADD_CLOCK_SKE1 ] = function () {
                 return _shouldAddClockSkewHeaders;
             };
-            _self.getClockSkewHeaderValue = function () {
+            _self[_DYN_GET_CLOCK_SKEW_HEADE2 ] = function () {
                 return _clockSkewHeaderValue;
             };
-            _self.setClockSkew = function (timeDeltaInMillis) {
+            _self[_DYN_SET_CLOCK_SKEW ] = function (timeDeltaInMillis) {
                 if (!_clockSkewSet) {
                     if (timeDeltaInMillis) {
                         _clockSkewHeaderValue = timeDeltaInMillis;
@@ -3841,21 +3922,21 @@ var KillSwitch = /** @class */ (function () {
             var result = [];
             if (values) {
                 arrForEach(values, function (value) {
-                    result.push(strTrim(value));
+                    result[_DYN_PUSH ](strTrim(value));
                 });
             }
             return result;
         }
         dynamicProto(KillSwitch, this, function (_self) {
-            _self.setKillSwitchTenants = function (killTokens, killDuration) {
+            _self[_DYN_SET_KILL_SWITCH_TENA10 ] = function (killTokens, killDuration) {
                 if (killTokens && killDuration) {
                     try {
-                        var killedTokens = _normalizeTenants(killTokens.split(","));
+                        var killedTokens = _normalizeTenants(killTokens[_DYN_SPLIT ](","));
                         if (killDuration === "this-request-only") {
                             return killedTokens;
                         }
                         var durationMs = parseInt(killDuration, 10) * SecToMsMultiplier;
-                        for (var i = 0; i < killedTokens.length; ++i) {
+                        for (var i = 0; i < killedTokens[_DYN_LENGTH ]; ++i) {
                             _killedTokenDictionary[killedTokens[i]] = utcNow() + durationMs;
                         }
                     }
@@ -3865,7 +3946,7 @@ var KillSwitch = /** @class */ (function () {
                 }
                 return [];
             };
-            _self.isTenantKilled = function (tenantToken) {
+            _self[_DYN_IS_TENANT_KILLED ] = function (tenantToken) {
                 var killDictionary = _killedTokenDictionary;
                 var name = strTrim(tenantToken);
                 if (killDictionary[name] !== undefined && killDictionary[name] > utcNow()) {
@@ -3988,10 +4069,10 @@ var Serializer = /** @class */ (function () {
                             }
                             lp++;
                         }
-                        if (sizeExceeded && sizeExceeded.length > 0) {
+                        if (sizeExceeded.length > 0) {
                             payload.sizeExceed.push(EventBatch.create(theBatch.iKey(), sizeExceeded));
                         }
-                        if (failedEvts && failedEvts.length > 0) {
+                        if (failedEvts.length > 0) {
                             payload.failedEvts.push(EventBatch.create(theBatch.iKey(), failedEvts));
                         }
                         if (eventsAdded) {
@@ -4159,7 +4240,7 @@ function createTimeoutWrapper(argSetTimeout, argClearTimeout) {
 var _a;
 var strSendAttempt = "sendAttempt";
 var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
-var UrlQueryString = "?cors=true&" + STR_CONTENT_TYPE_HEADER.toLowerCase() + "=" + DEFAULT_CONTENT_TYPE;
+var UrlQueryString = "?cors=true&" + STR_CONTENT_TYPE_HEADER[_DYN_TO_LOWER_CASE ]() + "=" + DEFAULT_CONTENT_TYPE;
 var _eventActionMap = (_a = {},
     _a[1 ] = STR_REQUEUE,
     _a[100 ] = STR_REQUEUE,
@@ -4194,12 +4275,12 @@ function _hasHeader(headers, header) {
     var hasHeader = false;
     if (headers && header) {
         var keys = objKeys(headers);
-        if (keys && keys.length > 0) {
-            var lowerHeader = header.toLowerCase();
-            for (var lp = 0; lp < keys.length; lp++) {
+        if (keys && keys[_DYN_LENGTH ] > 0) {
+            var lowerHeader = header[_DYN_TO_LOWER_CASE ]();
+            for (var lp = 0; lp < keys[_DYN_LENGTH ]; lp++) {
                 var value = keys[lp];
                 if (value && objHasOwnProperty(header, value) &&
-                    value.toLowerCase() === lowerHeader) {
+                    value[_DYN_TO_LOWER_CASE ]() === lowerHeader) {
                     hasHeader = true;
                     break;
                 }
@@ -4209,10 +4290,10 @@ function _hasHeader(headers, header) {
     return hasHeader;
 }
 function _addRequestDetails(details, name, value, useHeaders) {
-    if (name && value && value.length > 0) {
+    if (name && value && value[_DYN_LENGTH ] > 0) {
         if (useHeaders && _collectorQsHeaders[name]) {
-            details.hdrs[_collectorQsHeaders[name]] = value;
-            details.useHdrs = true;
+            details[_DYN_HDRS ][_collectorQsHeaders[name]] = value;
+            details[_DYN_USE_HDRS ] = true;
         }
         else {
             details.url += "&" + name + "=" + value;
@@ -4222,27 +4303,27 @@ function _addRequestDetails(details, name, value, useHeaders) {
 function _prependTransports(theTransports, newTransports) {
     if (newTransports) {
         if (isNumber(newTransports)) {
-            theTransports = [newTransports].concat(theTransports);
+            theTransports = [newTransports][_DYN_CONCAT ](theTransports);
         }
         else if (isArray(newTransports)) {
-            theTransports = newTransports.concat(theTransports);
+            theTransports = newTransports[_DYN_CONCAT ](theTransports);
         }
     }
     return theTransports;
 }
 function _addQueryStringParameter(qsParams, name, value) {
-    for (var i = 0; i < qsParams.length; i++) {
+    for (var i = 0; i < qsParams[_DYN_LENGTH ]; i++) {
         if (qsParams[i].name === name) {
             qsParams[i].value = value;
             return;
         }
     }
-    qsParams.push({ name: name, value: value });
+    qsParams[_DYN_PUSH ]({ name: name, value: value });
 }
 function _removeQueryStringParameter(qsParams, name) {
-    for (var i = 0; i < qsParams.length; i++) {
+    for (var i = 0; i < qsParams[_DYN_LENGTH ]; i++) {
         if (qsParams[i].name === name) {
-            qsParams.splice(i, 1);
+            qsParams[_DYN_SPLICE ](i, 1);
             return;
         }
     }
@@ -4282,7 +4363,7 @@ var HttpManager = /** @class */ (function () {
         dynamicProto(HttpManager, this, function (_self) {
             _initDefaults();
             var _sendCredentials = true;
-            _self.initialize = function (theConfig, core, postChannel) {
+            _self[_DYN_INITIALIZE ] = function (theConfig, core, postChannel) {
                 if (!_isInitialized) {
                     _core = core;
                     _cookieMgr = core.getCookieMgr();
@@ -4292,43 +4373,43 @@ var HttpManager = /** @class */ (function () {
                         var _a;
                         var coreConfig = details.cfg;
                         var channelConfig = details.cfg.extensionConfig[postChannel.identifier];
-                        _timeoutWrapper = createTimeoutWrapper(channelConfig.setTimeoutOverride, channelConfig.clearTimeoutOverride);
+                        _timeoutWrapper = createTimeoutWrapper(channelConfig[_DYN_SET_TIMEOUT_OVERRIDE ], channelConfig[_DYN_CLEAR_TIMEOUT_OVERRI3 ]);
                         if (isValueAssigned(coreConfig.anonCookieName)) {
                             _addQueryStringParameter(_queryStringParameters, "anoncknm", coreConfig.anonCookieName);
                         }
                         else {
                             _removeQueryStringParameter(_queryStringParameters, "anoncknm");
                         }
-                        _sendHook = channelConfig.payloadPreprocessor;
+                        _sendHook = channelConfig[_DYN_PAYLOAD_PREPROCESSOR ];
                         _sendListener = channelConfig.payloadListener;
                         var httpInterface = channelConfig.httpXHROverride;
-                        var endpointUrl = channelConfig.overrideEndpointUrl ? channelConfig.overrideEndpointUrl : coreConfig.endpointUrl;
+                        var endpointUrl = channelConfig[_DYN_OVERRIDE_ENDPOINT_UR4 ] ? channelConfig[_DYN_OVERRIDE_ENDPOINT_UR4 ] : coreConfig.endpointUrl;
                         _urlString = endpointUrl + UrlQueryString;
-                        _useHeaders = !isUndefined(channelConfig.avoidOptions) ? !channelConfig.avoidOptions : true;
-                        _enableEventTimings = !channelConfig.disableEventTimings;
+                        _useHeaders = !isUndefined(channelConfig[_DYN_AVOID_OPTIONS ]) ? !channelConfig[_DYN_AVOID_OPTIONS ] : true;
+                        _enableEventTimings = !channelConfig[_DYN_DISABLE_EVENT_TIMING5 ];
                         var valueSanitizer = channelConfig.valueSanitizer;
-                        var stringifyObjects = channelConfig.stringifyObjects;
-                        var enableCompoundKey = !!coreConfig.enableCompoundKey;
-                        if (!isUndefined(channelConfig.enableCompoundKey)) {
-                            enableCompoundKey = !!channelConfig.enableCompoundKey;
+                        var stringifyObjects = channelConfig[_DYN_STRINGIFY_OBJECTS ];
+                        var enableCompoundKey = !!coreConfig[_DYN_ENABLE_COMPOUND_KEY ];
+                        if (!isUndefined(channelConfig[_DYN_ENABLE_COMPOUND_KEY ])) {
+                            enableCompoundKey = !!channelConfig[_DYN_ENABLE_COMPOUND_KEY ];
                         }
                         _xhrTimeout = channelConfig.xhrTimeout;
-                        _disableXhrSync = !!channelConfig.disableXhrSync;
-                        _disableFetchKeepAlive = !!channelConfig.disableFetchKeepAlive;
+                        _disableXhrSync = !!channelConfig[_DYN_DISABLE_XHR_SYNC ];
+                        _disableFetchKeepAlive = !!channelConfig[_DYN_DISABLE_FETCH_KEEP_A6 ];
                         _addNoResponse = channelConfig.addNoResponse !== false;
                         _useBeacons = !isReactNative();
                         _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
-                        if (!isNullOrUndefined(channelConfig.useSendBeacon)) {
-                            _useBeacons = !!channelConfig.useSendBeacon;
+                        if (!isNullOrUndefined(channelConfig[_DYN_USE_SEND_BEACON ])) {
+                            _useBeacons = !!channelConfig[_DYN_USE_SEND_BEACON ];
                         }
                         var syncHttpInterface = httpInterface;
-                        var beaconHttpInterface = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
-                        var fetchSyncHttpInterface = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
+                        var beaconHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7 ] ? httpInterface : null;
+                        var fetchSyncHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7 ] ? httpInterface : null;
                         var beaconUnloadTransports = [3 , 2 ];
                         if (!httpInterface) {
                             _customHttpInterface = false;
                             var location_1 = getLocation();
-                            if (location_1 && location_1.protocol && location_1.protocol.toLowerCase() === "file:") {
+                            if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE ]() === "file:") {
                                 _sendCredentials = false;
                             }
                             var theTransports = [];
@@ -4347,7 +4428,7 @@ var HttpManager = /** @class */ (function () {
                             syncHttpInterface = _getSenderInterface(theTransports, true);
                         }
                         if (!beaconHttpInterface) {
-                            beaconUnloadTransports = _prependTransports(beaconUnloadTransports, channelConfig.unloadTransports);
+                            beaconUnloadTransports = _prependTransports(beaconUnloadTransports, channelConfig[_DYN_UNLOAD_TRANSPORTS ]);
                             beaconHttpInterface = _getSenderInterface(beaconUnloadTransports, true);
                         }
                         _canHaveReducedPayload = !_customHttpInterface && ((_useBeacons && isBeaconsSupported()) || (!_disableFetchKeepAlive && isFetchSupported(true)));
@@ -4362,12 +4443,12 @@ var HttpManager = /** @class */ (function () {
                 }
             };
             _self.addResponseHandler = function (responseHandler) {
-                _responseHandlers.push(responseHandler);
+                _responseHandlers[_DYN_PUSH ](responseHandler);
                 return {
                     rm: function () {
                         var index = _responseHandlers.indexOf(responseHandler);
                         if (index >= 0) {
-                            _responseHandlers.splice(index, 1);
+                            _responseHandlers[_DYN_SPLICE ](index, 1);
                         }
                     }
                 };
@@ -4376,7 +4457,7 @@ var HttpManager = /** @class */ (function () {
                 var transportType = 0 ;
                 var sendPostFunc = null;
                 var lp = 0;
-                while (sendPostFunc == null && lp < transports.length) {
+                while (sendPostFunc == null && lp < transports[_DYN_LENGTH ]) {
                     transportType = transports[lp];
                     if (transportType === 1 ) {
                         if (useXDomainRequest()) {
@@ -4408,9 +4489,9 @@ var HttpManager = /** @class */ (function () {
             };
             function _xdrSendPost(payload, oncomplete, sync) {
                 var xdr = new XDomainRequest();
-                xdr.open(STR_POST_METHOD, payload.urlString);
-                if (payload.timeout) {
-                    xdr.timeout = payload.timeout;
+                xdr.open(STR_POST_METHOD, payload[_DYN_URL_STRING ]);
+                if (payload[_DYN_TIMEOUT ]) {
+                    xdr[_DYN_TIMEOUT ] = payload[_DYN_TIMEOUT ];
                 }
                 xdr.onload = function () {
                     var response = _getResponseText(xdr);
@@ -4420,16 +4501,16 @@ var HttpManager = /** @class */ (function () {
                 xdr.onerror = function () {
                     _doOnComplete(oncomplete, 400, {});
                 };
-                xdr.ontimeout = function () {
+                xdr[_DYN_ONTIMEOUT ] = function () {
                     _doOnComplete(oncomplete, 500, {});
                 };
                 xdr.onprogress = function () { };
                 if (sync) {
-                    xdr.send(payload.data);
+                    xdr.send(payload[_DYN_DATA ]);
                 }
                 else {
                     _timeoutWrapper.set(function () {
-                        xdr.send(payload.data);
+                        xdr.send(payload[_DYN_DATA ]);
                     }, 0);
                 }
             }
@@ -4468,18 +4549,18 @@ var HttpManager = /** @class */ (function () {
             }
             function _fetchSendPost(payload, oncomplete, sync) {
                 var _a;
-                var theUrl = payload.urlString;
+                var theUrl = payload[_DYN_URL_STRING ];
                 var ignoreResponse = false;
                 var responseHandled = false;
                 var requestInit = (_a = {
-                        body: payload.data,
+                        body: payload[_DYN_DATA ],
                         method: STR_POST_METHOD
                     },
                     _a[STR_DISABLED_PROPERTY_NAME] = true,
                     _a);
                 if (sync) {
                     requestInit.keepalive = true;
-                    if (payload._sendReason === 2 ) {
+                    if (payload[_DYN__SEND_REASON ] === 2 ) {
                         ignoreResponse = true;
                         if (_addNoResponse) {
                             theUrl += _noResponseQs;
@@ -4489,13 +4570,13 @@ var HttpManager = /** @class */ (function () {
                 if (_sendCredentials) {
                     requestInit.credentials = "include";
                 }
-                if (payload.headers && objKeys(payload.headers).length > 0) {
-                    requestInit.headers = payload.headers;
+                if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH ] > 0) {
+                    requestInit[_DYN_HEADERS ] = payload[_DYN_HEADERS ];
                 }
                 fetch(theUrl, requestInit).then(function (response) {
                     var headerMap = {};
                     var responseText = STR_EMPTY;
-                    var headers = response.headers;
+                    var headers = response[_DYN_HEADERS ];
                     if (headers) {
                         headers["forEach"](function (value, name) {
                             headerMap[name] = value;
@@ -4521,20 +4602,20 @@ var HttpManager = /** @class */ (function () {
                     responseHandled = true;
                     _doOnComplete(oncomplete, 200, {});
                 }
-                if (!responseHandled && payload.timeout > 0) {
+                if (!responseHandled && payload[_DYN_TIMEOUT ] > 0) {
                     _timeoutWrapper.set(function () {
                         if (!responseHandled) {
                             responseHandled = true;
                             _doOnComplete(oncomplete, 500, {});
                         }
-                    }, payload.timeout);
+                    }, payload[_DYN_TIMEOUT ]);
                 }
             }
             function _xhrSendPost(payload, oncomplete, sync) {
-                var theUrl = payload.urlString;
+                var theUrl = payload[_DYN_URL_STRING ];
                 function _appendHeader(theHeaders, xhr, name) {
-                    if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
-                        var value = xhr.getResponseHeader(name);
+                    if (!theHeaders[name] && xhr && xhr[_DYN_GET_RESPONSE_HEADER ]) {
+                        var value = xhr[_DYN_GET_RESPONSE_HEADER ](name);
                         if (value) {
                             theHeaders[name] = strTrim(value);
                         }
@@ -4543,24 +4624,24 @@ var HttpManager = /** @class */ (function () {
                 }
                 function _getAllResponseHeaders(xhr) {
                     var theHeaders = {};
-                    if (!xhr.getAllResponseHeaders) {
+                    if (!xhr[_DYN_GET_ALL_RESPONSE_HEA8 ]) {
                         theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
                         theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
                         theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
                     }
                     else {
-                        theHeaders = _convertAllHeadersToMap(xhr.getAllResponseHeaders());
+                        theHeaders = _convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA8 ]());
                     }
                     return theHeaders;
                 }
                 function xhrComplete(xhr, responseTxt) {
                     _doOnComplete(oncomplete, xhr.status, _getAllResponseHeaders(xhr), responseTxt);
                 }
-                if (sync && payload.disableXhrSync) {
+                if (sync && payload[_DYN_DISABLE_XHR_SYNC ]) {
                     sync = false;
                 }
-                var xhrRequest = openXhr(STR_POST_METHOD, theUrl, _sendCredentials, true, sync, payload.timeout);
-                objForEachKey(payload.headers, function (name, value) {
+                var xhrRequest = openXhr(STR_POST_METHOD, theUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT ]);
+                objForEachKey(payload[_DYN_HEADERS ], function (name, value) {
                     xhrRequest.setRequestHeader(name, value);
                 });
                 xhrRequest.onload = function () {
@@ -4571,10 +4652,10 @@ var HttpManager = /** @class */ (function () {
                 xhrRequest.onerror = function () {
                     xhrComplete(xhrRequest);
                 };
-                xhrRequest.ontimeout = function () {
+                xhrRequest[_DYN_ONTIMEOUT ] = function () {
                     xhrComplete(xhrRequest);
                 };
-                xhrRequest.send(payload.data);
+                xhrRequest.send(payload[_DYN_DATA ]);
             }
             function _doOnComplete(oncomplete, status, headers, response) {
                 try {
@@ -4587,28 +4668,28 @@ var HttpManager = /** @class */ (function () {
             function _beaconSendPost(payload, oncomplete, sync) {
                 var internalPayloadData = payload;
                 var status = 200;
-                var thePayload = internalPayloadData._thePayload;
-                var theUrl = payload.urlString + (_addNoResponse ? _noResponseQs : STR_EMPTY);
+                var thePayload = internalPayloadData[_DYN__THE_PAYLOAD ];
+                var theUrl = payload[_DYN_URL_STRING ] + (_addNoResponse ? _noResponseQs : STR_EMPTY);
                 try {
                     var nav_1 = getNavigator();
-                    if (!nav_1.sendBeacon(theUrl, payload.data)) {
+                    if (!nav_1.sendBeacon(theUrl, payload[_DYN_DATA ])) {
                         if (thePayload) {
                             var droppedBatches_1 = [];
-                            arrForEach(thePayload.batches, function (theBatch) {
-                                if (droppedBatches_1 && theBatch && theBatch.count() > 0) {
-                                    var theEvents = theBatch.events();
-                                    for (var lp = 0; lp < theEvents.length; lp++) {
+                            arrForEach(thePayload[_DYN_BATCHES ], function (theBatch) {
+                                if (droppedBatches_1 && theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                                    var theEvents = theBatch[_DYN_EVENTS ]();
+                                    for (var lp = 0; lp < theEvents[_DYN_LENGTH ]; lp++) {
                                         if (!nav_1.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
-                                            droppedBatches_1.push(theBatch.split(lp));
+                                            droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](lp));
                                             break;
                                         }
                                     }
                                 }
                                 else {
-                                    droppedBatches_1.push(theBatch.split(0));
+                                    droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](0));
                                 }
                             });
-                            _sendBatchesNotification(droppedBatches_1, 8003 , thePayload.sendType, true);
+                            _sendBatchesNotification(droppedBatches_1, 8003 , thePayload[_DYN_SEND_TYPE ], true);
                         }
                         else {
                             status = 0;
@@ -4635,10 +4716,10 @@ var HttpManager = /** @class */ (function () {
             _self.addHeader = function (name, value) {
                 _headers[name] = value;
             };
-            _self.canSendRequest = function () {
-                return _hasIdleConnection() && _clockSkewManager.allowRequestSending();
+            _self[_DYN_CAN_SEND_REQUEST ] = function () {
+                return _hasIdleConnection() && _clockSkewManager[_DYN_ALLOW_REQUEST_SENDIN0 ]();
             };
-            _self.sendQueuedRequests = function (sendType, sendReason) {
+            _self[_DYN_SEND_QUEUED_REQUESTS ] = function (sendType, sendReason) {
                 if (isUndefined(sendType)) {
                     sendType = 0 ;
                 }
@@ -4650,23 +4731,23 @@ var HttpManager = /** @class */ (function () {
                     _sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0 );
                 }
             };
-            _self.isCompletelyIdle = function () {
-                return !_paused && _outstandingRequests === 0 && _batchQueue.length === 0;
+            _self[_DYN_IS_COMPLETELY_IDLE ] = function () {
+                return !_paused && _outstandingRequests === 0 && _batchQueue[_DYN_LENGTH ] === 0;
             };
-            _self.setUnloading = function (value) {
+            _self[_DYN_SET_UNLOADING ] = function (value) {
                 _isUnloading = value;
             };
             _self.addBatch = function (theBatch) {
-                if (theBatch && theBatch.count() > 0) {
-                    if (_killSwitch.isTenantKilled(theBatch.iKey())) {
+                if (theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                    if (_killSwitch.isTenantKilled(theBatch[_DYN_I_KEY ]())) {
                         return false;
                     }
-                    _batchQueue.push(theBatch);
+                    _batchQueue[_DYN_PUSH ](theBatch);
                 }
                 return true;
             };
             _self.teardown = function () {
-                if (_batchQueue.length > 0) {
+                if (_batchQueue[_DYN_LENGTH ] > 0) {
                     _sendBatches(_clearQueue(), 0, true, 2 , 2 );
                 }
                 arrForEach(_unloadHooks, function (hook) {
@@ -4679,10 +4760,10 @@ var HttpManager = /** @class */ (function () {
             };
             _self.resume = function () {
                 _paused = false;
-                _self.sendQueuedRequests(0 , 4 );
+                _self[_DYN_SEND_QUEUED_REQUESTS ](0 , 4 );
             };
-            _self.sendSynchronousBatch = function (batch, sendType, sendReason) {
-                if (batch && batch.count() > 0) {
+            _self[_DYN_SEND_SYNCHRONOUS_BAT9 ] = function (batch, sendType, sendReason) {
+                if (batch && batch[_DYN_COUNT ]() > 0) {
                     if (isNullOrUndefined(sendType)) {
                         sendType = 1 ;
                     }
@@ -4703,8 +4784,8 @@ var HttpManager = /** @class */ (function () {
             }
             function _canSendPayload(theBatches, sendType, retryCnt) {
                 var result = false;
-                if (theBatches && theBatches.length > 0 && !_paused && _sendInterfaces[sendType] && _serializer) {
-                    result = (sendType !== 0 ) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager.allowRequestSending()));
+                if (theBatches && theBatches[_DYN_LENGTH ] > 0 && !_paused && _sendInterfaces[sendType] && _serializer) {
+                    result = (sendType !== 0 ) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager[_DYN_ALLOW_REQUEST_SENDIN0 ]()));
                 }
                 return result;
             }
@@ -4713,15 +4794,15 @@ var HttpManager = /** @class */ (function () {
                 if (theBatches) {
                     arrForEach(theBatches, function (theBatch, idx) {
                         values[idx] = {
-                            iKey: theBatch.iKey(),
-                            evts: theBatch.events()
+                            iKey: theBatch[_DYN_I_KEY ](),
+                            evts: theBatch[_DYN_EVENTS ]()
                         };
                     });
                 }
                 return values;
             }
             function _sendBatches(theBatches, retryCount, isTeardown, sendType, sendReason) {
-                if (!theBatches || theBatches.length === 0) {
+                if (!theBatches || theBatches[_DYN_LENGTH ] === 0) {
                     return;
                 }
                 if (_paused) {
@@ -4740,21 +4821,21 @@ var HttpManager = /** @class */ (function () {
                         var thePayload = null;
                         var serializationStart = getTime();
                         var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1 ] : _sendInterfaces[0 ]);
-                        var sendTransport = sendInterface && sendInterface._transport;
+                        var sendTransport = sendInterface && sendInterface[_DYN__TRANSPORT ];
                         var isReducedPayload = _canHaveReducedPayload && (_isUnloading || _isBeaconPayload(sendType) || (sendTransport === 3  || (sendInterface._isSync && sendTransport === 2 )));
                         while (_canSendPayload(theBatches, sendType, retryCount)) {
                             var theBatch = theBatches.shift();
-                            if (theBatch && theBatch.count() > 0) {
-                                if (!_killSwitch.isTenantKilled(theBatch.iKey())) {
+                            if (theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                                if (!_killSwitch.isTenantKilled(theBatch[_DYN_I_KEY ]())) {
                                     thePayload = thePayload || _serializer.createPayload(retryCount, isTeardown, isSynchronous_1, isReducedPayload, sendReason, sendType);
                                     if (!_serializer.appendPayload(thePayload, theBatch, maxEventsPerBatch)) {
                                         _doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
                                         serializationStart = getTime();
-                                        theBatches = [theBatch].concat(theBatches);
+                                        theBatches = [theBatch][_DYN_CONCAT ](theBatches);
                                         thePayload = null;
                                     }
                                     else if (thePayload.overflow !== null) {
-                                        theBatches = [thePayload.overflow].concat(theBatches);
+                                        theBatches = [thePayload.overflow][_DYN_CONCAT ](theBatches);
                                         thePayload.overflow = null;
                                         _doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
                                         serializationStart = getTime();
@@ -4762,15 +4843,15 @@ var HttpManager = /** @class */ (function () {
                                     }
                                 }
                                 else {
-                                    droppedBatches.push(theBatch);
+                                    droppedBatches[_DYN_PUSH ](theBatch);
                                 }
                             }
                         }
                         if (thePayload) {
                             _doPayloadSend(thePayload, serializationStart, getTime(), sendReason);
                         }
-                        if (theBatches.length > 0) {
-                            _batchQueue = theBatches.concat(_batchQueue);
+                        if (theBatches[_DYN_LENGTH ] > 0) {
+                            _batchQueue = theBatches[_DYN_CONCAT ](_batchQueue);
                         }
                         _sendBatchesNotification(droppedBatches, 8004 , sendType);
                     }, function () { return ({ batches: _createDebugBatches(orgBatches_1), retryCount: retryCount, isTeardown: isTeardown, isSynchronous: isSynchronous_1, sendReason: sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType: sendType }); }, !isSynchronous_1);
@@ -4791,20 +4872,20 @@ var HttpManager = /** @class */ (function () {
                             _addRequestDetails(requestDetails, _collectorHeaderToQs[name], value, false);
                         }
                         else {
-                            requestDetails.hdrs[name] = value;
-                            requestDetails.useHdrs = true;
+                            requestDetails[_DYN_HDRS ][name] = value;
+                            requestDetails[_DYN_USE_HDRS ] = true;
                         }
                     });
                 }
                 else {
-                    requestDetails.hdrs = extend(requestDetails.hdrs, _headers);
-                    requestDetails.useHdrs = (objKeys(requestDetails.hdrs).length > 0);
+                    requestDetails[_DYN_HDRS ] = extend(requestDetails[_DYN_HDRS ], _headers);
+                    requestDetails.useHdrs = (objKeys(requestDetails.hdrs)[_DYN_LENGTH ] > 0);
                 }
                 _addRequestDetails(requestDetails, STR_CLIENT_ID, "NO_AUTH", useHeaders);
                 _addRequestDetails(requestDetails, STR_CLIENT_VERSION, FullVersionString, useHeaders);
                 var apiQsKeys = STR_EMPTY;
                 arrForEach(thePayload.apiKeys, function (apiKey) {
-                    if (apiQsKeys.length > 0) {
+                    if (apiQsKeys[_DYN_LENGTH ] > 0) {
                         apiQsKeys += ",";
                     }
                     apiQsKeys += apiKey;
@@ -4815,16 +4896,16 @@ var HttpManager = /** @class */ (function () {
                 if (isValueAssigned(msfpc)) {
                     requestDetails.url += "&ext.intweb.msfpc=" + msfpc;
                 }
-                if (_clockSkewManager.shouldAddClockSkewHeaders()) {
-                    _addRequestDetails(requestDetails, STR_TIME_DELTA_TO_APPLY, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
+                if (_clockSkewManager[_DYN_SHOULD_ADD_CLOCK_SKE1 ]()) {
+                    _addRequestDetails(requestDetails, STR_TIME_DELTA_TO_APPLY, _clockSkewManager[_DYN_GET_CLOCK_SKEW_HEADE2 ](), useHeaders);
                 }
-                if (_core.getWParam) {
-                    var wParam = _core.getWParam();
+                if (_core[_DYN_GET_WPARAM ]) {
+                    var wParam = _core[_DYN_GET_WPARAM ]();
                     if (wParam >= 0) {
                         requestDetails.url += "&w=" + wParam;
                     }
                 }
-                for (var i = 0; i < _queryStringParameters.length; i++) {
+                for (var i = 0; i < _queryStringParameters[_DYN_LENGTH ]; i++) {
                     requestDetails.url += "&" + _queryStringParameters[i].name + "=" + _queryStringParameters[i].value;
                 }
                 return requestDetails;
@@ -4834,27 +4915,27 @@ var HttpManager = /** @class */ (function () {
                 timings[name][_postManager.identifier] = value;
             }
             function _doPayloadSend(thePayload, serializationStart, serializationCompleted, sendReason) {
-                if (thePayload && thePayload.payloadBlob && thePayload.payloadBlob.length > 0) {
+                if (thePayload && thePayload.payloadBlob && thePayload.payloadBlob[_DYN_LENGTH ] > 0) {
                     var useSendHook_1 = !!_sendHook;
                     var sendInterface_1 = _sendInterfaces[thePayload.sendType];
-                    if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 ) {
+                    if (!_isBeaconPayload(thePayload[_DYN_SEND_TYPE ]) && thePayload[_DYN_IS_BEACON ] && thePayload.sendReason === 2 ) {
                         sendInterface_1 = _sendInterfaces[2 ] || _sendInterfaces[3 ] || sendInterface_1;
                     }
                     var useHeaders_1 = _useHeaders;
-                    if (thePayload.isBeacon || sendInterface_1._transport === 3 ) {
+                    if (thePayload.isBeacon || sendInterface_1[_DYN__TRANSPORT ] === 3 ) {
                         useHeaders_1 = false;
                     }
                     var requestDetails_1 = _buildRequestDetails(thePayload, useHeaders_1);
-                    useHeaders_1 = useHeaders_1 || requestDetails_1.useHdrs;
+                    useHeaders_1 = useHeaders_1 || requestDetails_1[_DYN_USE_HDRS ];
                     var sendEventStart_1 = getTime();
                     doPerf(_core, function () { return "HttpManager:_doPayloadSend"; }, function () {
-                        for (var batchLp = 0; batchLp < thePayload.batches.length; batchLp++) {
-                            var theBatch = thePayload.batches[batchLp];
-                            var theEvents = theBatch.events();
-                            for (var evtLp = 0; evtLp < theEvents.length; evtLp++) {
+                        for (var batchLp = 0; batchLp < thePayload.batches[_DYN_LENGTH ]; batchLp++) {
+                            var theBatch = thePayload[_DYN_BATCHES ][batchLp];
+                            var theEvents = theBatch[_DYN_EVENTS ]();
+                            for (var evtLp = 0; evtLp < theEvents[_DYN_LENGTH ]; evtLp++) {
                                 var telemetryItem = theEvents[evtLp];
                                 if (_enableEventTimings) {
-                                    var timings = telemetryItem.timings = telemetryItem.timings || {};
+                                    var timings = telemetryItem[_DYN_TIMINGS ] = telemetryItem[_DYN_TIMINGS ] || {};
                                     _setTimingValue(timings, "sendEventStart", sendEventStart_1);
                                     _setTimingValue(timings, "serializationStart", serializationStart);
                                     _setTimingValue(timings, "serializationCompleted", serializationCompleted);
@@ -4862,11 +4943,11 @@ var HttpManager = /** @class */ (function () {
                                 telemetryItem[strSendAttempt] > 0 ? telemetryItem[strSendAttempt]++ : telemetryItem[strSendAttempt] = 1;
                             }
                         }
-                        _sendBatchesNotification(thePayload.batches, (1000  + (sendReason || 0 )), thePayload.sendType, true);
+                        _sendBatchesNotification(thePayload[_DYN_BATCHES ], (1000  + (sendReason || 0 )), thePayload[_DYN_SEND_TYPE ], true);
                         var orgPayloadData = {
                             data: thePayload.payloadBlob,
                             urlString: requestDetails_1.url,
-                            headers: requestDetails_1.hdrs,
+                            headers: requestDetails_1[_DYN_HDRS ],
                             _thePayload: thePayload,
                             _sendReason: sendReason,
                             timeout: _xhrTimeout,
@@ -4874,25 +4955,25 @@ var HttpManager = /** @class */ (function () {
                             disableFetchKeepAlive: _disableFetchKeepAlive
                         };
                         if (useHeaders_1) {
-                            if (!_hasHeader(orgPayloadData.headers, STR_CACHE_CONTROL)) {
-                                orgPayloadData.headers[STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
+                            if (!_hasHeader(orgPayloadData[_DYN_HEADERS ], STR_CACHE_CONTROL)) {
+                                orgPayloadData[_DYN_HEADERS ][STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
                             }
-                            if (!_hasHeader(orgPayloadData.headers, STR_CONTENT_TYPE_HEADER)) {
-                                orgPayloadData.headers[STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
+                            if (!_hasHeader(orgPayloadData[_DYN_HEADERS ], STR_CONTENT_TYPE_HEADER)) {
+                                orgPayloadData[_DYN_HEADERS ][STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
                             }
                         }
                         var sender = null;
                         if (sendInterface_1) {
                             sender = function (payload) {
-                                _clockSkewManager.firstRequestSent();
+                                _clockSkewManager[_DYN_FIRST_REQUEST_SENT ]();
                                 var onComplete = function (status, headers) {
                                     _retryRequestIfNeeded(status, headers, thePayload, sendReason);
                                 };
-                                var isSync = thePayload.isTeardown || thePayload.isSync;
+                                var isSync = thePayload[_DYN_IS_TEARDOWN ] || thePayload[_DYN_IS_SYNC ];
                                 try {
-                                    sendInterface_1.sendPOST(payload, onComplete, isSync);
+                                    sendInterface_1[_DYN_SEND_POST ](payload, onComplete, isSync);
                                     if (_sendListener) {
-                                        _sendListener(orgPayloadData, payload, isSync, thePayload.isBeacon);
+                                        _sendListener(orgPayloadData, payload, isSync, thePayload[_DYN_IS_BEACON ]);
                                     }
                                 }
                                 catch (ex) {
@@ -4903,29 +4984,29 @@ var HttpManager = /** @class */ (function () {
                         }
                         doPerf(_core, function () { return "HttpManager:_doPayloadSend.sender"; }, function () {
                             if (sender) {
-                                if (thePayload.sendType === 0 ) {
+                                if (thePayload[_DYN_SEND_TYPE ] === 0 ) {
                                     _outstandingRequests++;
                                 }
-                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 ) {
+                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1[_DYN__TRANSPORT ] !== 3 ) {
                                     var hookData_1 = {
-                                        data: orgPayloadData.data,
-                                        urlString: orgPayloadData.urlString,
-                                        headers: extend({}, orgPayloadData.headers),
-                                        timeout: orgPayloadData.timeout,
-                                        disableXhrSync: orgPayloadData.disableXhrSync,
-                                        disableFetchKeepAlive: orgPayloadData.disableFetchKeepAlive
+                                        data: orgPayloadData[_DYN_DATA ],
+                                        urlString: orgPayloadData[_DYN_URL_STRING ],
+                                        headers: extend({}, orgPayloadData[_DYN_HEADERS ]),
+                                        timeout: orgPayloadData[_DYN_TIMEOUT ],
+                                        disableXhrSync: orgPayloadData[_DYN_DISABLE_XHR_SYNC ],
+                                        disableFetchKeepAlive: orgPayloadData[_DYN_DISABLE_FETCH_KEEP_A6 ]
                                     };
                                     var senderCalled_1 = false;
                                     doPerf(_core, function () { return "HttpManager:_doPayloadSend.sendHook"; }, function () {
                                         try {
                                             _sendHook(hookData_1, function (payload) {
                                                 senderCalled_1 = true;
-                                                if (!_customHttpInterface && !payload._thePayload) {
-                                                    payload._thePayload = payload._thePayload || orgPayloadData._thePayload;
-                                                    payload._sendReason = payload._sendReason || orgPayloadData._sendReason;
+                                                if (!_customHttpInterface && !payload[_DYN__THE_PAYLOAD ]) {
+                                                    payload[_DYN__THE_PAYLOAD ] = payload[_DYN__THE_PAYLOAD ] || orgPayloadData[_DYN__THE_PAYLOAD ];
+                                                    payload[_DYN__SEND_REASON ] = payload[_DYN__SEND_REASON ] || orgPayloadData[_DYN__SEND_REASON ];
                                                 }
                                                 sender(payload);
-                                            }, thePayload.isSync || thePayload.isTeardown);
+                                            }, thePayload.isSync || thePayload[_DYN_IS_TEARDOWN ]);
                                         }
                                         catch (ex) {
                                             if (!senderCalled_1) {
@@ -4939,19 +5020,19 @@ var HttpManager = /** @class */ (function () {
                                 }
                             }
                         });
-                    }, function () { return ({ thePayload: thePayload, serializationStart: serializationStart, serializationCompleted: serializationCompleted, sendReason: sendReason }); }, thePayload.isSync);
+                    }, function () { return ({ thePayload: thePayload, serializationStart: serializationStart, serializationCompleted: serializationCompleted, sendReason: sendReason }); }, thePayload[_DYN_IS_SYNC ]);
                 }
-                if (thePayload.sizeExceed && thePayload.sizeExceed.length > 0) {
-                    _sendBatchesNotification(thePayload.sizeExceed, 8003 , thePayload.sendType);
+                if (thePayload.sizeExceed && thePayload.sizeExceed[_DYN_LENGTH ] > 0) {
+                    _sendBatchesNotification(thePayload.sizeExceed, 8003 , thePayload[_DYN_SEND_TYPE ]);
                 }
-                if (thePayload.failedEvts && thePayload.failedEvts.length > 0) {
-                    _sendBatchesNotification(thePayload.failedEvts, 8002 , thePayload.sendType);
+                if (thePayload.failedEvts && thePayload.failedEvts[_DYN_LENGTH ] > 0) {
+                    _sendBatchesNotification(thePayload.failedEvts, 8002 , thePayload[_DYN_SEND_TYPE ]);
                 }
             }
             function _addEventCompletedTimings(theEvents, sendEventCompleted) {
                 if (_enableEventTimings) {
                     arrForEach(theEvents, function (theEvent) {
-                        var timings = theEvent.timings = theEvent.timings || {};
+                        var timings = theEvent[_DYN_TIMINGS ] = theEvent[_DYN_TIMINGS ] || {};
                         _setTimingValue(timings, "sendEventCompleted", sendEventCompleted);
                     });
                 }
@@ -4965,15 +5046,15 @@ var HttpManager = /** @class */ (function () {
                     var shouldRetry = true;
                     if (typeof status !== strShimUndefined) {
                         if (headers) {
-                            _clockSkewManager.setClockSkew(headers[STR_TIME_DELTA_HEADER]);
+                            _clockSkewManager[_DYN_SET_CLOCK_SKEW ](headers[STR_TIME_DELTA_HEADER]);
                             var killDuration = headers[STR_KILL_DURATION_HEADER] || headers["kill-duration-seconds"];
-                            arrForEach(_killSwitch.setKillSwitchTenants(headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
-                                arrForEach(thePayload.batches, function (theBatch) {
-                                    if (theBatch.iKey() === killToken) {
+                            arrForEach(_killSwitch[_DYN_SET_KILL_SWITCH_TENA10 ](headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
+                                arrForEach(thePayload[_DYN_BATCHES ], function (theBatch) {
+                                    if (theBatch[_DYN_I_KEY ]() === killToken) {
                                         droppedBatches = droppedBatches || [];
-                                        var removedEvents = theBatch.split(0);
-                                        thePayload.numEvents -= removedEvents.count();
-                                        droppedBatches.push(removedEvents);
+                                        var removedEvents = theBatch[_DYN_SPLIT ](0);
+                                        thePayload.numEvents -= removedEvents[_DYN_COUNT ]();
+                                        droppedBatches[_DYN_PUSH ](removedEvents);
                                     }
                                 });
                             });
@@ -4990,14 +5071,14 @@ var HttpManager = /** @class */ (function () {
                     if (shouldRetry) {
                         reason = 100 ;
                         var retryCount_1 = thePayload.retryCnt;
-                        if (thePayload.sendType === 0 ) {
+                        if (thePayload[_DYN_SEND_TYPE ] === 0 ) {
                             if (retryCount_1 < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(function () {
-                                    if (thePayload.sendType === 0 ) {
+                                    if (thePayload[_DYN_SEND_TYPE ] === 0 ) {
                                         _outstandingRequests--;
                                     }
-                                    _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2  : thePayload.sendType, 5 );
+                                    _sendBatches(thePayload[_DYN_BATCHES ], retryCount_1 + 1, thePayload[_DYN_IS_TEARDOWN ], _isUnloading ? 2  : thePayload[_DYN_SEND_TYPE ], 5 );
                                 }, _isUnloading, retryPolicyGetMillisToBackoffForRetry(retryCount_1));
                             }
                             else {
@@ -5011,30 +5092,30 @@ var HttpManager = /** @class */ (function () {
                 }
                 finally {
                     if (!isRetrying) {
-                        _clockSkewManager.setClockSkew();
+                        _clockSkewManager[_DYN_SET_CLOCK_SKEW ]();
                         _handleRequestFinished(thePayload, reason, sendReason, backOffTrans);
                     }
-                    _sendBatchesNotification(droppedBatches, 8004 , thePayload.sendType);
+                    _sendBatchesNotification(droppedBatches, 8004 , thePayload[_DYN_SEND_TYPE ]);
                 }
             }
             function _handleRequestFinished(thePayload, batchReason, sendReason, backOffTrans) {
                 try {
                     if (backOffTrans) {
-                        _postManager._backOffTransmission();
+                        _postManager[_DYN__BACK_OFF_TRANSMISSI11 ]();
                     }
                     if (batchReason === 200 ) {
-                        if (!backOffTrans && !thePayload.isSync) {
+                        if (!backOffTrans && !thePayload[_DYN_IS_SYNC ]) {
                             _postManager._clearBackOff();
                         }
-                        _addCompleteTimings(thePayload.batches);
+                        _addCompleteTimings(thePayload[_DYN_BATCHES ]);
                     }
-                    _sendBatchesNotification(thePayload.batches, batchReason, thePayload.sendType, true);
+                    _sendBatchesNotification(thePayload[_DYN_BATCHES ], batchReason, thePayload[_DYN_SEND_TYPE ], true);
                 }
                 finally {
-                    if (thePayload.sendType === 0 ) {
+                    if (thePayload[_DYN_SEND_TYPE ] === 0 ) {
                         _outstandingRequests--;
                         if (sendReason !== 5 ) {
-                            _self.sendQueuedRequests(thePayload.sendType, sendReason);
+                            _self.sendQueuedRequests(thePayload[_DYN_SEND_TYPE ], sendReason);
                         }
                     }
                 }
@@ -5043,8 +5124,8 @@ var HttpManager = /** @class */ (function () {
                 if (_enableEventTimings) {
                     var sendEventCompleted_1 = getTime();
                     arrForEach(theBatches, function (theBatch) {
-                        if (theBatch && theBatch.count() > 0) {
-                            _addEventCompletedTimings(theBatch.events(), sendEventCompleted_1);
+                        if (theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                            _addEventCompletedTimings(theBatch[_DYN_EVENTS ](), sendEventCompleted_1);
                         }
                     });
                 }
@@ -5060,12 +5141,12 @@ var HttpManager = /** @class */ (function () {
             function _convertAllHeadersToMap(headersString) {
                 var headers = {};
                 if (isString(headersString)) {
-                    var headersArray = strTrim(headersString).split(/[\r\n]+/);
+                    var headersArray = strTrim(headersString)[_DYN_SPLIT ](/[\r\n]+/);
                     arrForEach(headersArray, function (headerEntry) {
                         if (headerEntry) {
                             var idx = headerEntry.indexOf(": ");
                             if (idx !== -1) {
-                                var header = strTrim(headerEntry.substring(0, idx)).toLowerCase();
+                                var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE ]();
                                 var value = strTrim(headerEntry.substring(idx + 1));
                                 headers[header] = value;
                             }
@@ -5078,8 +5159,8 @@ var HttpManager = /** @class */ (function () {
                 return headers;
             }
             function _getMsfpc(thePayload) {
-                for (var lp = 0; lp < thePayload.batches.length; lp++) {
-                    var msfpc = thePayload.batches[lp].Msfpc();
+                for (var lp = 0; lp < thePayload.batches[_DYN_LENGTH ]; lp++) {
+                    var msfpc = thePayload[_DYN_BATCHES ][lp].Msfpc();
                     if (msfpc) {
                         return encodeURIComponent(msfpc);
                     }
@@ -5089,7 +5170,7 @@ var HttpManager = /** @class */ (function () {
             function _handleCollectorResponse(responseText) {
                 var responseHandlers = _responseHandlers;
                 try {
-                    for (var i = 0; i < responseHandlers.length; i++) {
+                    for (var i = 0; i < responseHandlers[_DYN_LENGTH ]; i++) {
                         try {
                             responseHandlers[i](responseText);
                         }
@@ -5108,7 +5189,7 @@ var HttpManager = /** @class */ (function () {
                 }
             }
             function _sendBatchesNotification(theBatches, batchReason, sendType, sendSync) {
-                if (theBatches && theBatches.length > 0 && actions) {
+                if (theBatches && theBatches[_DYN_LENGTH ] > 0 && actions) {
                     var theAction_1 = actions[_getNotificationAction(batchReason)];
                     if (theAction_1) {
                         var isSyncRequest_1 = sendType !== 0 ;
@@ -5190,7 +5271,7 @@ var defaultPostChannelConfig = objDeepFreeze({
     addNoResponse: undefValue
 });
 function isOverrideFn(httpXHROverride) {
-    return httpXHROverride && httpXHROverride.sendPOST;
+    return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
 }
 var PostChannel = /** @class */ (function (_super) {
     __extendsFn(PostChannel, _super);
@@ -5198,7 +5279,7 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '4.0.1';
+        _this.version = '4.0.2-nightly3.2307-25';
         var _postConfig;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -5237,29 +5318,29 @@ var PostChannel = /** @class */ (function (_super) {
             _self["_getDbgPlgTargets"] = function () {
                 return [_httpManager, _postConfig];
             };
-            _self.initialize = function (theConfig, core, extensions) {
+            _self[_DYN_INITIALIZE ] = function (theConfig, core, extensions) {
                 doPerf(core, function () { return "PostChannel:initialize"; }, function () {
-                    _base.initialize(theConfig, core, extensions);
+                    _base[_DYN_INITIALIZE ](theConfig, core, extensions);
                     _notificationManager = core.getNotifyMgr();
                     try {
-                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
+                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self[_DYN_IDENTIFIER ]), core.evtNamespace && core.evtNamespace());
                         _self._addHook(onConfigChange(theConfig, function (details) {
                             var coreConfig = details.cfg;
                             var ctx = createProcessTelemetryContext(null, coreConfig, core);
-                            _postConfig = ctx.getExtCfg(_self.identifier, defaultPostChannelConfig);
-                            _timeoutWrapper = createTimeoutWrapper(_postConfig.setTimeoutOverride, _postConfig.clearTimeoutOverride);
-                            _optimizeObject = !_postConfig.disableOptimizeObj && isChromium();
-                            _ignoreMc1Ms0CookieProcessing = _postConfig.ignoreMc1Ms0CookieProcessing;
+                            _postConfig = ctx.getExtCfg(_self[_DYN_IDENTIFIER ], defaultPostChannelConfig);
+                            _timeoutWrapper = createTimeoutWrapper(_postConfig[_DYN_SET_TIMEOUT_OVERRIDE ], _postConfig[_DYN_CLEAR_TIMEOUT_OVERRI3 ]);
+                            _optimizeObject = !_postConfig[_DYN_DISABLE_OPTIMIZE_OBJ ] && isChromium();
+                            _ignoreMc1Ms0CookieProcessing = _postConfig[_DYN_IGNORE_MC1_MS0_COOKI12 ];
                             _hookWParam(core);
-                            _queueSizeLimit = _postConfig.eventsLimitInMem;
+                            _queueSizeLimit = _postConfig[_DYN_EVENTS_LIMIT_IN_MEM ];
                             _immediateQueueSizeLimit = _postConfig.immediateEventLimit;
-                            _autoFlushEventsLimit = _postConfig.autoFlushEventsLimit;
+                            _autoFlushEventsLimit = _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI13 ];
                             _maxEventSendAttempts = _postConfig.maxEventRetryAttempts;
                             _maxUnloadEventSendAttempts = _postConfig.maxUnloadEventRetryAttempts;
-                            _disableAutoBatchFlushLimit = _postConfig.disableAutoBatchFlushLimit;
+                            _disableAutoBatchFlushLimit = _postConfig[_DYN_DISABLE_AUTO_BATCH_F14 ];
                             _setAutoLimits();
-                            _overrideInstrumentationKey = _postConfig.overrideInstrumentationKey;
-                            _disableTelemetry = !!_postConfig.disableTelemetry;
+                            _overrideInstrumentationKey = _postConfig[_DYN_OVERRIDE_INSTRUMENTA15 ];
+                            _disableTelemetry = !!_postConfig[_DYN_DISABLE_TELEMETRY ];
                             if (_unloadHandlersAdded) {
                                 _removeUnloadHandlers();
                             }
@@ -5268,7 +5349,7 @@ var PostChannel = /** @class */ (function (_super) {
                             _unloadHandlersAdded = addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents, _evtNamespace) || _unloadHandlersAdded;
                             _unloadHandlersAdded = addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace) || _unloadHandlersAdded;
                         }));
-                        _httpManager.initialize(theConfig, _self.core, _self);
+                        _httpManager[_DYN_INITIALIZE ](theConfig, _self.core, _self);
                     }
                     catch (e) {
                         _self.setInitialized(false);
@@ -5277,12 +5358,12 @@ var PostChannel = /** @class */ (function (_super) {
                 }, function () { return ({ theConfig: theConfig, core: core, extensions: extensions }); });
             };
             _self.processTelemetry = function (ev, itemCtx) {
-                setProcessTelemetryTimings(ev, _self.identifier);
+                setProcessTelemetryTimings(ev, _self[_DYN_IDENTIFIER ]);
                 itemCtx = itemCtx || _self._getTelCtx(itemCtx);
                 var event = ev;
                 if (!_disableTelemetry && !_isTeardownCalled) {
                     if (_overrideInstrumentationKey) {
-                        event.iKey = _overrideInstrumentationKey;
+                        event[_DYN_I_KEY ] = _overrideInstrumentationKey;
                     }
                     _addEventToQueues(event, true);
                     if (_isPageUnloadTriggered) {
@@ -5307,8 +5388,8 @@ var PostChannel = /** @class */ (function (_super) {
                 removePageShowEventListener(null, _evtNamespace);
             }
             function _hookWParam(core) {
-                var existingGetWParamMethod = core.getWParam;
-                core.getWParam = function () {
+                var existingGetWParamMethod = core[_DYN_GET_WPARAM ];
+                core[_DYN_GET_WPARAM ] = function () {
                     var wparam = 0;
                     if (_ignoreMc1Ms0CookieProcessing) {
                         wparam = wparam | 2;
@@ -5320,20 +5401,20 @@ var PostChannel = /** @class */ (function (_super) {
                 var theEvt = evt || getWindow().event;
                 if (theEvt.type !== "beforeunload") {
                     _isPageUnloadTriggered = true;
-                    _httpManager.setUnloading(_isPageUnloadTriggered);
+                    _httpManager[_DYN_SET_UNLOADING ](_isPageUnloadTriggered);
                 }
                 _releaseAllQueues(2 , 2 );
             }
             function _handleShowEvents(evt) {
                 _isPageUnloadTriggered = false;
-                _httpManager.setUnloading(_isPageUnloadTriggered);
+                _httpManager[_DYN_SET_UNLOADING ](_isPageUnloadTriggered);
             }
             function _addEventToQueues(event, append) {
-                if (!event.sendAttempt) {
-                    event.sendAttempt = 0;
+                if (!event[_DYN_SEND_ATTEMPT ]) {
+                    event[_DYN_SEND_ATTEMPT ] = 0;
                 }
-                if (!event.latency) {
-                    event.latency = 1 ;
+                if (!event[_DYN_LATENCY ]) {
+                    event[_DYN_LATENCY ] = 1 ;
                 }
                 if (event.ext && event.ext[STR_TRACE]) {
                     delete (event.ext[STR_TRACE]);
@@ -5343,29 +5424,29 @@ var PostChannel = /** @class */ (function (_super) {
                 }
                 if (_optimizeObject) {
                     event.ext = optimizeObject(event.ext);
-                    if (event.baseData) {
-                        event.baseData = optimizeObject(event.baseData);
+                    if (event[_DYN_BASE_DATA ]) {
+                        event[_DYN_BASE_DATA ] = optimizeObject(event[_DYN_BASE_DATA ]);
                     }
-                    if (event.data) {
-                        event.data = optimizeObject(event.data);
+                    if (event[_DYN_DATA ]) {
+                        event[_DYN_DATA ] = optimizeObject(event[_DYN_DATA ]);
                     }
                 }
-                if (event.sync) {
+                if (event[_DYN_SYNC ]) {
                     if (_currentBackoffCount || _paused) {
-                        event.latency = 3 ;
-                        event.sync = false;
+                        event[_DYN_LATENCY ] = 3 ;
+                        event[_DYN_SYNC ] = false;
                     }
                     else {
                         if (_httpManager) {
                             if (_optimizeObject) {
                                 event = optimizeObject(event);
                             }
-                            _httpManager.sendSynchronousBatch(EventBatch.create(event.iKey, [event]), event.sync === true ? 1  : event.sync, 3 );
+                            _httpManager[_DYN_SEND_SYNCHRONOUS_BAT9 ](EventBatch.create(event[_DYN_I_KEY ], [event]), event[_DYN_SYNC ] === true ? 1  : event[_DYN_SYNC ], 3 );
                             return;
                         }
                     }
                 }
-                var evtLatency = event.latency;
+                var evtLatency = event[_DYN_LATENCY ];
                 var queueSize = _queueSize;
                 var queueLimit = _queueSizeLimit;
                 if (evtLatency === 4 ) {
@@ -5384,7 +5465,7 @@ var PostChannel = /** @class */ (function (_super) {
                         dropNumber = 1;
                     }
                     eventDropped = true;
-                    if (_dropEventWithLatencyOrLess(event.iKey, event.latency, dropLatency, dropNumber)) {
+                    if (_dropEventWithLatencyOrLess(event[_DYN_I_KEY ], event[_DYN_LATENCY ], dropLatency, dropNumber)) {
                         eventDropped = !_addEventToProperQueue(event, append);
                     }
                 }
@@ -5393,16 +5474,16 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             }
             _self.setEventQueueLimits = function (eventLimit, autoFlushLimit) {
-                _postConfig.eventsLimitInMem = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
-                _postConfig.autoFlushEventsLimit = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
+                _postConfig[_DYN_EVENTS_LIMIT_IN_MEM ] = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
+                _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI13 ] = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
                 _setAutoLimits();
                 var doFlush = _queueSize > eventLimit;
                 if (!doFlush && _autoFlushBatchLimit > 0) {
                     for (var latency = 1 ; !doFlush && latency <= 3 ; latency++) {
                         var batchQueue = _batchQueues[latency];
-                        if (batchQueue && batchQueue.batches) {
-                            arrForEach(batchQueue.batches, function (theBatch) {
-                                if (theBatch && theBatch.count() >= _autoFlushBatchLimit) {
+                        if (batchQueue && batchQueue[_DYN_BATCHES ]) {
+                            arrForEach(batchQueue[_DYN_BATCHES ], function (theBatch) {
+                                if (theBatch && theBatch[_DYN_COUNT ]() >= _autoFlushBatchLimit) {
                                     doFlush = true;
                                 }
                             });
@@ -5424,10 +5505,10 @@ var PostChannel = /** @class */ (function (_super) {
             _self._loadTransmitProfiles = function (profiles) {
                 _resetTransmitProfiles();
                 objForEachKey(profiles, function (profileName, profileValue) {
-                    var profLen = profileValue.length;
+                    var profLen = profileValue[_DYN_LENGTH ];
                     if (profLen >= 2) {
                         var directValue = (profLen > 2 ? profileValue[2] : 0);
-                        profileValue.splice(0, profLen - 2);
+                        profileValue[_DYN_SPLICE ](0, profLen - 2);
                         if (profileValue[1] < 0) {
                             profileValue[0] = -1;
                         }
@@ -5438,7 +5519,7 @@ var PostChannel = /** @class */ (function (_super) {
                         if (directValue >= 0 && profileValue[1] >= 0 && directValue > profileValue[1]) {
                             directValue = profileValue[1];
                         }
-                        profileValue.push(directValue);
+                        profileValue[_DYN_PUSH ](directValue);
                         _profiles[profileName] = profileValue;
                     }
                 });
@@ -5463,7 +5544,7 @@ var PostChannel = /** @class */ (function (_super) {
                             }, 0);
                         }
                         else {
-                            _flushCallbackQueue.push(callback);
+                            _flushCallbackQueue[_DYN_PUSH ](callback);
                         }
                     }
                     else {
@@ -5491,7 +5572,7 @@ var PostChannel = /** @class */ (function (_super) {
             proxyFunctions(_self, function () { return _httpManager; }, ["addResponseHandler"]);
             function _sendEventsForLatencyAndAbove(latency, sendType, sendReason) {
                 var queued = _queueBatches(latency, sendType, sendReason);
-                _httpManager.sendQueuedRequests(sendType, sendReason);
+                _httpManager[_DYN_SEND_QUEUED_REQUESTS ](sendType, sendReason);
                 return queued;
             }
             function _hasEvents() {
@@ -5499,7 +5580,7 @@ var PostChannel = /** @class */ (function (_super) {
             }
             function _scheduleTimer() {
                 if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0 , _delayedBatchReason)) {
-                    _httpManager.sendQueuedRequests(0 , _delayedBatchReason);
+                    _httpManager[_DYN_SEND_QUEUED_REQUESTS ](0 , _delayedBatchReason);
                 }
                 if (_immediateQueueSize > 0 && !_immediateTimer && !_paused) {
                     var immediateTimeOut = _profiles[_currentProfile][2];
@@ -5527,7 +5608,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                 }
             }
-            _self._backOffTransmission = function () {
+            _self[_DYN__BACK_OFF_TRANSMISSI11 ] = function () {
                 if (_currentBackoffCount < MaxBackoffCount) {
                     _currentBackoffCount++;
                     _clearScheduledTimer();
@@ -5639,13 +5720,13 @@ var PostChannel = /** @class */ (function (_super) {
                 var eventBatch = batchQueue.iKeyMap[iKey];
                 if (!eventBatch && create) {
                     eventBatch = EventBatch.create(iKey);
-                    batchQueue.batches.push(eventBatch);
+                    batchQueue.batches[_DYN_PUSH ](eventBatch);
                     batchQueue.iKeyMap[iKey] = eventBatch;
                 }
                 return eventBatch;
             }
             function _performAutoFlush(isAsync, doFlush) {
-                if (_httpManager.canSendRequest() && !_currentBackoffCount) {
+                if (_httpManager[_DYN_CAN_SEND_REQUEST ]() && !_currentBackoffCount) {
                     if (_autoFlushEventsLimit > 0 && _queueSize > _autoFlushEventsLimit) {
                         doFlush = true;
                     }
@@ -5658,13 +5739,13 @@ var PostChannel = /** @class */ (function (_super) {
                 if (_optimizeObject) {
                     event = optimizeObject(event);
                 }
-                var latency = event.latency;
-                var eventBatch = _getEventBatch(event.iKey, latency, true);
+                var latency = event[_DYN_LATENCY ];
+                var eventBatch = _getEventBatch(event[_DYN_I_KEY ], latency, true);
                 if (eventBatch.addEvent(event)) {
                     if (latency !== 4 ) {
                         _queueSize++;
-                        if (append && event.sendAttempt === 0) {
-                            _performAutoFlush(!event.sync, _autoFlushBatchLimit > 0 && eventBatch.count() >= _autoFlushBatchLimit);
+                        if (append && event[_DYN_SEND_ATTEMPT ] === 0) {
+                            _performAutoFlush(!event.sync, _autoFlushBatchLimit > 0 && eventBatch[_DYN_COUNT ]() >= _autoFlushBatchLimit);
                         }
                     }
                     else {
@@ -5677,9 +5758,9 @@ var PostChannel = /** @class */ (function (_super) {
             function _dropEventWithLatencyOrLess(iKey, latency, currentLatency, dropNumber) {
                 while (currentLatency <= latency) {
                     var eventBatch = _getEventBatch(iKey, latency, true);
-                    if (eventBatch && eventBatch.count() > 0) {
-                        var droppedEvents = eventBatch.split(0, dropNumber);
-                        var droppedCount = droppedEvents.count();
+                    if (eventBatch && eventBatch[_DYN_COUNT ]() > 0) {
+                        var droppedEvents = eventBatch[_DYN_SPLIT ](0, dropNumber);
+                        var droppedCount = droppedEvents[_DYN_COUNT ]();
                         if (droppedCount > 0) {
                             if (currentLatency === 4 ) {
                                 _immediateQueueSize -= droppedCount;
@@ -5701,13 +5782,13 @@ var PostChannel = /** @class */ (function (_super) {
                 var normalQueue = 0;
                 var _loop_1 = function (latency) {
                     var batchQueue = _batchQueues[latency];
-                    if (batchQueue && batchQueue.batches) {
-                        arrForEach(batchQueue.batches, function (theBatch) {
+                    if (batchQueue && batchQueue[_DYN_BATCHES ]) {
+                        arrForEach(batchQueue[_DYN_BATCHES ], function (theBatch) {
                             if (latency === 4 ) {
-                                immediateQueue += theBatch.count();
+                                immediateQueue += theBatch[_DYN_COUNT ]();
                             }
                             else {
-                                normalQueue += theBatch.count();
+                                normalQueue += theBatch[_DYN_COUNT ]();
                             }
                         });
                     }
@@ -5721,33 +5802,33 @@ var PostChannel = /** @class */ (function (_super) {
             function _queueBatches(latency, sendType, sendReason) {
                 var eventsQueued = false;
                 var isAsync = sendType === 0 ;
-                if (!isAsync || _httpManager.canSendRequest()) {
+                if (!isAsync || _httpManager[_DYN_CAN_SEND_REQUEST ]()) {
                     doPerf(_self.core, function () { return "PostChannel._queueBatches"; }, function () {
                         var droppedEvents = [];
                         var latencyToProcess = 4 ;
                         while (latencyToProcess >= latency) {
                             var batchQueue = _batchQueues[latencyToProcess];
-                            if (batchQueue && batchQueue.batches && batchQueue.batches.length > 0) {
-                                arrForEach(batchQueue.batches, function (theBatch) {
+                            if (batchQueue && batchQueue.batches && batchQueue.batches[_DYN_LENGTH ] > 0) {
+                                arrForEach(batchQueue[_DYN_BATCHES ], function (theBatch) {
                                     if (!_httpManager.addBatch(theBatch)) {
-                                        droppedEvents = droppedEvents.concat(theBatch.events());
+                                        droppedEvents = droppedEvents[_DYN_CONCAT ](theBatch[_DYN_EVENTS ]());
                                     }
                                     else {
-                                        eventsQueued = eventsQueued || (theBatch && theBatch.count() > 0);
+                                        eventsQueued = eventsQueued || (theBatch && theBatch[_DYN_COUNT ]() > 0);
                                     }
                                     if (latencyToProcess === 4 ) {
-                                        _immediateQueueSize -= theBatch.count();
+                                        _immediateQueueSize -= theBatch[_DYN_COUNT ]();
                                     }
                                     else {
-                                        _queueSize -= theBatch.count();
+                                        _queueSize -= theBatch[_DYN_COUNT ]();
                                     }
                                 });
-                                batchQueue.batches = [];
+                                batchQueue[_DYN_BATCHES ] = [];
                                 batchQueue.iKeyMap = {};
                             }
                             latencyToProcess--;
                         }
-                        if (droppedEvents.length > 0) {
+                        if (droppedEvents[_DYN_LENGTH ] > 0) {
                             _notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.KillSwitch);
                         }
                         if (eventsQueued && _delayedBatchSendLatency >= latency) {
@@ -5769,7 +5850,7 @@ var PostChannel = /** @class */ (function (_super) {
                     if (callback) {
                         callback();
                     }
-                    if (_flushCallbackQueue.length > 0) {
+                    if (_flushCallbackQueue[_DYN_LENGTH ] > 0) {
                         _flushCallbackTimer = _createTimer(function () {
                             _flushCallbackTimer = null;
                             _flushImpl(_flushCallbackQueue.shift(), sendReason);
@@ -5782,7 +5863,7 @@ var PostChannel = /** @class */ (function (_super) {
                 });
             }
             function _waitForIdleManager(callback) {
-                if (_httpManager.isCompletelyIdle()) {
+                if (_httpManager[_DYN_IS_COMPLETELY_IDLE ]()) {
                     callback();
                 }
                 else {
@@ -5811,25 +5892,25 @@ var PostChannel = /** @class */ (function (_super) {
                     maxSendAttempts = _maxUnloadEventSendAttempts;
                 }
                 arrForEach(batches, function (theBatch) {
-                    if (theBatch && theBatch.count() > 0) {
-                        arrForEach(theBatch.events(), function (theEvent) {
+                    if (theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                        arrForEach(theBatch[_DYN_EVENTS ](), function (theEvent) {
                             if (theEvent) {
-                                if (theEvent.sync) {
-                                    theEvent.latency = 4 ;
-                                    theEvent.sync = false;
+                                if (theEvent[_DYN_SYNC ]) {
+                                    theEvent[_DYN_LATENCY ] = 4 ;
+                                    theEvent[_DYN_SYNC ] = false;
                                 }
-                                if (theEvent.sendAttempt < maxSendAttempts) {
-                                    setProcessTelemetryTimings(theEvent, _self.identifier);
+                                if (theEvent[_DYN_SEND_ATTEMPT ] < maxSendAttempts) {
+                                    setProcessTelemetryTimings(theEvent, _self[_DYN_IDENTIFIER ]);
                                     _addEventToQueues(theEvent, false);
                                 }
                                 else {
-                                    droppedEvents.push(theEvent);
+                                    droppedEvents[_DYN_PUSH ](theEvent);
                                 }
                             }
                         });
                     }
                 });
-                if (droppedEvents.length > 0) {
+                if (droppedEvents[_DYN_LENGTH ] > 0) {
                     _notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.NonRetryableStatus);
                 }
                 if (_isPageUnloadTriggered) {
@@ -5853,8 +5934,8 @@ var PostChannel = /** @class */ (function (_super) {
                 for (var _i = 2; _i < arguments.length; _i++) {
                     extraArgs[_i - 2] = arguments[_i];
                 }
-                if (theEvents && theEvents.length > 0) {
-                    _callNotification(evtName, [theEvents].concat(extraArgs));
+                if (theEvents && theEvents[_DYN_LENGTH ] > 0) {
+                    _callNotification(evtName, [theEvents][_DYN_CONCAT ](extraArgs));
                 }
             }
             function _notifyBatchEvents(evtName, batches) {
@@ -5862,16 +5943,16 @@ var PostChannel = /** @class */ (function (_super) {
                 for (var _i = 2; _i < arguments.length; _i++) {
                     extraArgs[_i - 2] = arguments[_i];
                 }
-                if (batches && batches.length > 0) {
+                if (batches && batches[_DYN_LENGTH ] > 0) {
                     arrForEach(batches, function (theBatch) {
-                        if (theBatch && theBatch.count() > 0) {
-                            _callNotification(evtName, [theBatch.events()].concat(extraArgs));
+                        if (theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                            _callNotification(evtName, [theBatch.events()][_DYN_CONCAT ](extraArgs));
                         }
                     });
                 }
             }
             function _sendingEvent(batches, reason, isSyncRequest) {
-                if (batches && batches.length > 0) {
+                if (batches && batches[_DYN_LENGTH ] > 0) {
                     _callNotification("eventsSendRequest", [(reason >= 1000  && reason <= 1999  ?
                             reason - 1000  :
                             0 ), isSyncRequest !== true]);
@@ -5915,4 +5996,4 @@ exports.PostChannel = PostChannel;
 exports.RT_PROFILE = RT_PROFILE;
 
 }));
-//# sourceMappingURL=ms.post-4.0.1.gbl.js.map
+//# sourceMappingURL=ms.post-4.0.2-nightly3.2307-25.gbl.js.map