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

package/dist/es5/ms.post.js

@@ -1,5 +1,5 @@
 /*!
- * 1DS JS SDK POST plugin, 4.0.1
+ * 1DS JS SDK POST plugin, 4.0.2-nightly3.2307-24
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -9,6 +9,10 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.oneDS = global.oneDS || {}));
 })(this, (function (exports) { '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";
@@ -222,23 +226,43 @@
         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));
@@ -259,7 +283,7 @@
         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");
@@ -376,15 +400,13 @@
     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];
         }
@@ -392,32 +414,26 @@
             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;
@@ -458,36 +474,54 @@
         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) {
@@ -518,6 +552,8 @@
 
     var arrSlice = _unwrapFunction(SLICE, ArrProto);
 
+    var fnCall = _unwrapInstFunction("call");
+
     var _objCreate = ObjClass["create"];
     var objCreate = _objCreate || polyObjCreate;
     function polyObjCreate(obj) {
@@ -578,7 +614,7 @@
             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)) {
@@ -615,7 +651,7 @@
     }
     var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
 
-    var strTrim = _unwrapFunction("trim", StrProto, polyStrTrim);
+    var strTrim = _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
 
     var _fnToString;
     var _objCtrFnString;
@@ -631,7 +667,7 @@
         if (value !== _gblWindow) {
             if (!_objCtrFnString) {
                 _fnToString = Function[PROTOTYPE].toString;
-                _objCtrFnString = _fnToString.call(ObjClass);
+                _objCtrFnString = fnCall(_fnToString, ObjClass);
             }
             try {
                 var proto = objGetPrototypeOf(value);
@@ -651,7 +687,7 @@
 
     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() {
@@ -733,7 +769,7 @@
         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) {
@@ -741,11 +777,11 @@
                     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;
     }
@@ -1041,9 +1077,9 @@
         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";
@@ -1052,12 +1088,12 @@
     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";
@@ -1077,7 +1113,7 @@
     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";
@@ -1092,7 +1128,7 @@
     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];
                 }
             });
@@ -1104,13 +1140,6 @@
         throw new aggregationErrorType(theMessage, sourceErrors || []);
     }
 
-    var _theLogger = null;
-    function _debugLog(id, message) {
-        if (_theLogger) {
-            _theLogger(id, message);
-        }
-    }
-
     var STRING_STATES = [
         "pending", "resolving", "resolved", "rejected"
     ];
@@ -1173,14 +1202,11 @@
                 _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);
                             }
@@ -1198,12 +1224,10 @@
                             reject(e);
                         }
                     });
-                    _debugLog(_toString(), "Added to Queue " + _queue.length);
                     if (_hasResolved) {
                         _processQueue();
                     }
                 }, additionalArgs);
-                _debugLog(_toString(), "Created -> " + thenPromise.toString());
                 return thenPromise;
             }
             finally {
@@ -1234,49 +1258,37 @@
             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;
@@ -1306,14 +1318,12 @@
             }
             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;
     }
 
@@ -1537,13 +1547,13 @@
         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;
@@ -1639,7 +1649,7 @@
         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;
@@ -1651,7 +1661,7 @@
         return result;
     }
 
-    var version = '3.0.2';
+    var version = '3.0.3-nightly3.2307-24';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -1719,7 +1729,7 @@
             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)) {
@@ -1754,7 +1764,7 @@
             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 = {};
@@ -1845,7 +1855,7 @@
             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 = {};
@@ -1929,7 +1939,7 @@
             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);
                 }
@@ -1937,7 +1947,7 @@
             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);
                 }
             }
         };
@@ -2141,7 +2151,7 @@
                                 _useHandler(handler, handler.fn);
                             }
                             catch (e) {
-                                watcherFailures_1[_DYN_PUSH ](e);
+                                watcherFailures_1[_DYN_PUSH$1 ](e);
                             }
                         }
                     }
@@ -2151,16 +2161,16 @@
                         _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 = [];
                 }
@@ -2170,10 +2180,10 @@
                         _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);
                     }
                 }
             }
@@ -2182,7 +2192,7 @@
             if (handler) {
                 var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
                 if (arrIndexOf(details, detail) === -1) {
-                    details[_DYN_PUSH ](detail);
+                    details[_DYN_PUSH$1 ](detail);
                 }
             }
         }
@@ -2470,14 +2480,14 @@
                     }
                     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);
                             }
@@ -2573,7 +2583,7 @@
                 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 ];
@@ -2610,7 +2620,7 @@
                                     children = [];
                                     currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
                                 }
-                                children[_DYN_PUSH ](perfEvt);
+                                children[_DYN_PUSH$1 ](perfEvt);
                             }
                         }
                         perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
@@ -2693,7 +2703,7 @@
                 args[_i - 2] = arguments[_i];
             }
             if (onComplete) {
-                _onComplete[_DYN_PUSH ]({
+                _onComplete[_DYN_PUSH$1 ]({
                     func: onComplete,
                     self: !isUndefined(that) ? that : context.ctx,
                     args: args
@@ -2705,7 +2715,7 @@
             _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);
@@ -2846,7 +2856,7 @@
     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) {
@@ -2875,7 +2885,7 @@
         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++;
@@ -2907,7 +2917,7 @@
         }
         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] = {};
@@ -3002,7 +3012,7 @@
         var handlers = [];
         function _addHandler(handler) {
             if (handler) {
-                handlers[_DYN_PUSH ](handler);
+                handlers[_DYN_PUSH$1 ](handler);
             }
         }
         function _runHandlers(unloadCtx, unloadState) {
@@ -3062,7 +3072,7 @@
             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;
                 };
@@ -3241,7 +3251,7 @@
         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) {
@@ -3278,14 +3288,14 @@
         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);
                     }
                 }
             }
@@ -3300,7 +3310,7 @@
             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);
             }
         }
@@ -3314,7 +3324,7 @@
             else {
                 newNamespaces = [theNamespace, namespaces];
             }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
         }
         else {
             newNamespaces = theNamespace;
@@ -3337,7 +3347,7 @@
                         _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) {
@@ -3392,7 +3402,7 @@
     }
     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) {
@@ -3407,7 +3417,7 @@
         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);
             }
         }
@@ -3473,8 +3483,14 @@
 
     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-24';
     var FullVersionString = "1DS-Web-JS-" + Version;
     var ObjHasOwnProperty = ObjProto$1.hasOwnProperty;
     var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
@@ -3514,21 +3530,21 @@
         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;
     }
@@ -3565,7 +3581,7 @@
         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];
@@ -3611,13 +3627,13 @@
         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 ;
@@ -3636,12 +3652,12 @@
                 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 ]);
                 }
             }
         }
@@ -3680,10 +3696,6 @@
         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";
@@ -3712,6 +3724,75 @@
     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])) {
@@ -3721,31 +3802,31 @@
     }
     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);
                     }
@@ -3753,14 +3834,14 @@
                 }
                 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);
@@ -3780,10 +3861,10 @@
             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) {
@@ -3791,13 +3872,13 @@
                         }
                     }
                 };
-                _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;
@@ -3824,21 +3905,21 @@
                 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;
                             }
                         }
@@ -3848,7 +3929,7 @@
                     }
                     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()) {
@@ -3971,10 +4052,10 @@
                                 }
                                 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) {
@@ -4142,7 +4223,7 @@
     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,
@@ -4177,12 +4258,12 @@
         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;
                     }
@@ -4192,10 +4273,10 @@
         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;
@@ -4205,27 +4286,27 @@
     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;
             }
         }
@@ -4265,7 +4346,7 @@
             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();
@@ -4275,43 +4356,43 @@
                             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 = [];
@@ -4330,7 +4411,7 @@
                                 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)));
@@ -4345,12 +4426,12 @@
                     }
                 };
                 _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);
                             }
                         }
                     };
@@ -4359,7 +4440,7 @@
                     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()) {
@@ -4391,9 +4472,9 @@
                 };
                 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);
@@ -4403,16 +4484,16 @@
                     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);
                     }
                 }
@@ -4451,18 +4532,18 @@
                 }
                 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;
@@ -4472,13 +4553,13 @@
                     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;
@@ -4504,20 +4585,20 @@
                         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);
                             }
@@ -4526,24 +4607,24 @@
                     }
                     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 () {
@@ -4554,10 +4635,10 @@
                     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 {
@@ -4570,28 +4651,28 @@
                 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;
@@ -4618,10 +4699,10 @@
                 _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 ;
                     }
@@ -4633,23 +4714,23 @@
                         _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) {
@@ -4662,10 +4743,10 @@
                 };
                 _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 ;
                         }
@@ -4686,8 +4767,8 @@
                 }
                 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;
                 }
@@ -4696,15 +4777,15 @@
                     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) {
@@ -4723,21 +4804,21 @@
                             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();
@@ -4745,15 +4826,15 @@
                                         }
                                     }
                                     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);
@@ -4774,20 +4855,20 @@
                                 _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;
@@ -4798,16 +4879,16 @@
                     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;
@@ -4817,27 +4898,27 @@
                     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);
@@ -4845,11 +4926,11 @@
                                     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,
@@ -4857,25 +4938,25 @@
                                 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) {
@@ -4886,29 +4967,29 @@
                             }
                             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) {
@@ -4922,19 +5003,19 @@
                                     }
                                 }
                             });
-                        }, 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);
                         });
                     }
@@ -4948,15 +5029,15 @@
                         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);
                                         }
                                     });
                                 });
@@ -4973,14 +5054,14 @@
                         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 {
@@ -4994,30 +5075,30 @@
                     }
                     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);
                             }
                         }
                     }
@@ -5026,8 +5107,8 @@
                     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);
                             }
                         });
                     }
@@ -5043,12 +5124,12 @@
                 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;
                                 }
@@ -5061,8 +5142,8 @@
                     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);
                         }
@@ -5072,7 +5153,7 @@
                 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);
                             }
@@ -5091,7 +5172,7 @@
                     }
                 }
                 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 ;
@@ -5173,7 +5254,7 @@
         addNoResponse: undefValue
     });
     function isOverrideFn(httpXHROverride) {
-        return httpXHROverride && httpXHROverride.sendPOST;
+        return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
     }
     var PostChannel = /** @class */ (function (_super) {
         __extendsFn(PostChannel, _super);
@@ -5181,7 +5262,7 @@
             var _this = _super.call(this) || this;
             _this.identifier = "PostChannel";
             _this.priority = 1011;
-            _this.version = '4.0.1';
+            _this.version = '4.0.2-nightly3.2307-24';
             var _postConfig;
             var _isTeardownCalled = false;
             var _flushCallbackQueue = [];
@@ -5220,29 +5301,29 @@
                 _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();
                                 }
@@ -5251,7 +5332,7 @@
                                 _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);
@@ -5260,12 +5341,12 @@
                     }, 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) {
@@ -5290,8 +5371,8 @@
                     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;
@@ -5303,20 +5384,20 @@
                     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]);
@@ -5326,29 +5407,29 @@
                     }
                     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 ) {
@@ -5367,7 +5448,7 @@
                             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);
                         }
                     }
@@ -5376,16 +5457,16 @@
                     }
                 }
                 _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;
                                     }
                                 });
@@ -5407,10 +5488,10 @@
                 _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;
                             }
@@ -5421,7 +5502,7 @@
                             if (directValue >= 0 && profileValue[1] >= 0 && directValue > profileValue[1]) {
                                 directValue = profileValue[1];
                             }
-                            profileValue.push(directValue);
+                            profileValue[_DYN_PUSH ](directValue);
                             _profiles[profileName] = profileValue;
                         }
                     });
@@ -5446,7 +5527,7 @@
                                 }, 0);
                             }
                             else {
-                                _flushCallbackQueue.push(callback);
+                                _flushCallbackQueue[_DYN_PUSH ](callback);
                             }
                         }
                         else {
@@ -5474,7 +5555,7 @@
                 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() {
@@ -5482,7 +5563,7 @@
                 }
                 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];
@@ -5510,7 +5591,7 @@
                         }
                     }
                 }
-                _self._backOffTransmission = function () {
+                _self[_DYN__BACK_OFF_TRANSMISSI11 ] = function () {
                     if (_currentBackoffCount < MaxBackoffCount) {
                         _currentBackoffCount++;
                         _clearScheduledTimer();
@@ -5622,13 +5703,13 @@
                     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;
                         }
@@ -5641,13 +5722,13 @@
                     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 {
@@ -5660,9 +5741,9 @@
                 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;
@@ -5684,13 +5765,13 @@
                     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 ]();
                                 }
                             });
                         }
@@ -5704,33 +5785,33 @@
                 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) {
@@ -5752,7 +5833,7 @@
                         if (callback) {
                             callback();
                         }
-                        if (_flushCallbackQueue.length > 0) {
+                        if (_flushCallbackQueue[_DYN_LENGTH ] > 0) {
                             _flushCallbackTimer = _createTimer(function () {
                                 _flushCallbackTimer = null;
                                 _flushImpl(_flushCallbackQueue.shift(), sendReason);
@@ -5765,7 +5846,7 @@
                     });
                 }
                 function _waitForIdleManager(callback) {
-                    if (_httpManager.isCompletelyIdle()) {
+                    if (_httpManager[_DYN_IS_COMPLETELY_IDLE ]()) {
                         callback();
                     }
                     else {
@@ -5794,25 +5875,25 @@
                         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) {
@@ -5836,8 +5917,8 @@
                     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) {
@@ -5845,16 +5926,16 @@
                     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]);