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

package/dist-es5/PostChannel.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 4.0.1
+ * 1DS JS SDK POST plugin, 4.0.2-nightly3.2307-25
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -19,6 +19,7 @@ import { HttpManager } from "./HttpManager";
 import { STR_MSA_DEVICE_TICKET, STR_TRACE, STR_USER } from "./InternalConstants";
 import { retryPolicyGetMillisToBackoffForRetry } from "./RetryPolicy";
 import { createTimeoutWrapper } from "./TimeoutOverrideWrapper";
+import { _DYN_AUTO_FLUSH_EVENTS_LI13, _DYN_BASE_DATA, _DYN_BATCHES, _DYN_CAN_SEND_REQUEST, _DYN_CLEAR_TIMEOUT_OVERRI3, _DYN_CONCAT, _DYN_COUNT, _DYN_DATA, _DYN_DISABLE_AUTO_BATCH_F14, _DYN_DISABLE_OPTIMIZE_OBJ, _DYN_DISABLE_TELEMETRY, _DYN_EVENTS, _DYN_EVENTS_LIMIT_IN_MEM, _DYN_GET_WPARAM, _DYN_IDENTIFIER, _DYN_IGNORE_MC1_MS0_COOKI12, _DYN_INITIALIZE, _DYN_IS_COMPLETELY_IDLE, _DYN_I_KEY, _DYN_LATENCY, _DYN_LENGTH, _DYN_OVERRIDE_INSTRUMENTA15, _DYN_PUSH, _DYN_SEND_ATTEMPT, _DYN_SEND_POST, _DYN_SEND_QUEUED_REQUESTS, _DYN_SEND_SYNCHRONOUS_BAT9, _DYN_SET_TIMEOUT_OVERRIDE, _DYN_SET_UNLOADING, _DYN_SPLICE, _DYN_SPLIT, _DYN_SYNC, _DYN__BACK_OFF_TRANSMISSI11 } from "./__DynamicConstants";
 var FlushCheckTimer = 0.250; // This needs to be in seconds, so this is 250ms
 var MaxNumberEventPerBatch = 500;
 var EventsDroppedAtOneTime = 20;
@@ -68,11 +69,13 @@ var defaultPostChannelConfig = objDeepFreeze({
     addNoResponse: undefValue
 });
 function isOverrideFn(httpXHROverride) {
-    return httpXHROverride && httpXHROverride.sendPOST;
+    return httpXHROverride && httpXHROverride[_DYN_SEND_POST /* @min:%2esendPOST */];
 }
 /**
  * Class that manages adding events to inbound queues and batching of events
  * into requests.
+ * @group Classes
+ * @group Entrypoint
  */
 var PostChannel = /** @class */ (function (_super) {
     __extends(PostChannel, _super);
@@ -80,7 +83,7 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '4.0.1';
+        _this.version = '4.0.2-nightly3.2307-25';
         var _postConfig;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -121,32 +124,32 @@ var PostChannel = /** @class */ (function (_super) {
             _self["_getDbgPlgTargets"] = function () {
                 return [_httpManager, _postConfig];
             };
-            _self.initialize = function (theConfig, core, extensions) {
+            _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (theConfig, core, extensions) {
                 doPerf(core, function () { return "PostChannel:initialize"; }, function () {
-                    _base.initialize(theConfig, core, extensions);
+                    _base[_DYN_INITIALIZE /* @min:%2einitialize */](theConfig, core, extensions);
                     _notificationManager = core.getNotifyMgr();
                     try {
-                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self.identifier), core.evtNamespace && core.evtNamespace());
+                        _evtNamespace = mergeEvtNamespace(createUniqueNamespace(_self[_DYN_IDENTIFIER /* @min:%2eidentifier */]), 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);
+                            _postConfig = ctx.getExtCfg(_self[_DYN_IDENTIFIER /* @min:%2eidentifier */], defaultPostChannelConfig);
+                            _timeoutWrapper = createTimeoutWrapper(_postConfig[_DYN_SET_TIMEOUT_OVERRIDE /* @min:%2esetTimeoutOverride */], _postConfig[_DYN_CLEAR_TIMEOUT_OVERRI3 /* @min:%2eclearTimeoutOverride */]);
                             // Only try and use the optimizeObject() if this appears to be a chromium based browser and it has not been explicitly disabled
-                            _optimizeObject = !_postConfig.disableOptimizeObj && isChromium();
-                            _ignoreMc1Ms0CookieProcessing = _postConfig.ignoreMc1Ms0CookieProcessing;
-                            _hookWParam(core); // _hookWParam uses _ignoreMc1Ms0CookieProcessing 
-                            _queueSizeLimit = _postConfig.eventsLimitInMem;
+                            _optimizeObject = !_postConfig[_DYN_DISABLE_OPTIMIZE_OBJ /* @min:%2edisableOptimizeObj */] && isChromium();
+                            _ignoreMc1Ms0CookieProcessing = _postConfig[_DYN_IGNORE_MC1_MS0_COOKI12 /* @min:%2eignoreMc1Ms0CookieProcessing */];
+                            _hookWParam(core); // _hookWParam uses _ignoreMc1Ms0CookieProcessing
+                            _queueSizeLimit = _postConfig[_DYN_EVENTS_LIMIT_IN_MEM /* @min:%2eeventsLimitInMem */];
                             _immediateQueueSizeLimit = _postConfig.immediateEventLimit;
-                            _autoFlushEventsLimit = _postConfig.autoFlushEventsLimit;
+                            _autoFlushEventsLimit = _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI13 /* @min:%2eautoFlushEventsLimit */];
                             _maxEventSendAttempts = _postConfig.maxEventRetryAttempts;
                             _maxUnloadEventSendAttempts = _postConfig.maxUnloadEventRetryAttempts;
-                            _disableAutoBatchFlushLimit = _postConfig.disableAutoBatchFlushLimit;
+                            _disableAutoBatchFlushLimit = _postConfig[_DYN_DISABLE_AUTO_BATCH_F14 /* @min:%2edisableAutoBatchFlushLimit */];
                             _setAutoLimits();
                             // Override iKey if provided in Post config if provided for during initialization
-                            _overrideInstrumentationKey = _postConfig.overrideInstrumentationKey;
+                            _overrideInstrumentationKey = _postConfig[_DYN_OVERRIDE_INSTRUMENTA15 /* @min:%2eoverrideInstrumentationKey */];
                             // DisableTelemetry was defined in the config provided during initialization
-                            _disableTelemetry = !!_postConfig.disableTelemetry;
+                            _disableTelemetry = !!_postConfig[_DYN_DISABLE_TELEMETRY /* @min:%2edisableTelemetry */];
                             if (_unloadHandlersAdded) {
                                 _removeUnloadHandlers();
                             }
@@ -157,7 +160,7 @@ var PostChannel = /** @class */ (function (_super) {
                             _unloadHandlersAdded = addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents, _evtNamespace) || _unloadHandlersAdded;
                         }));
                         // only initialize the manager once
-                        _httpManager.initialize(theConfig, _self.core, _self);
+                        _httpManager[_DYN_INITIALIZE /* @min:%2einitialize */](theConfig, _self.core, _self);
                     }
                     catch (e) {
                         // resetting the initialized state because of failure
@@ -167,13 +170,13 @@ var PostChannel = /** @class */ (function (_super) {
                 }, function () { return ({ theConfig: theConfig, core: core, extensions: extensions }); });
             };
             _self.processTelemetry = function (ev, itemCtx) {
-                setProcessTelemetryTimings(ev, _self.identifier);
+                setProcessTelemetryTimings(ev, _self[_DYN_IDENTIFIER /* @min:%2eidentifier */]);
                 itemCtx = itemCtx || _self._getTelCtx(itemCtx);
                 var event = ev;
                 if (!_disableTelemetry && !_isTeardownCalled) {
                     // Override iKey if provided in Post config if provided for during initialization
                     if (_overrideInstrumentationKey) {
-                        event.iKey = _overrideInstrumentationKey;
+                        event[_DYN_I_KEY /* @min:%2eiKey */] = _overrideInstrumentationKey;
                     }
                     _addEventToQueues(event, true);
                     if (_isPageUnloadTriggered) {
@@ -200,8 +203,8 @@ var PostChannel = /** @class */ (function (_super) {
                 removePageShowEventListener(null, _evtNamespace);
             }
             function _hookWParam(core) {
-                var existingGetWParamMethod = core.getWParam;
-                core.getWParam = function () {
+                var existingGetWParamMethod = core[_DYN_GET_WPARAM /* @min:%2egetWParam */];
+                core[_DYN_GET_WPARAM /* @min:%2egetWParam */] = function () {
                     var wparam = 0;
                     if (_ignoreMc1Ms0CookieProcessing) {
                         wparam = wparam | 2;
@@ -215,23 +218,23 @@ var PostChannel = /** @class */ (function (_super) {
                 if (theEvt.type !== "beforeunload") {
                     // Only set the unload trigger if not beforeunload event as beforeunload can be cancelled while the other events can't
                     _isPageUnloadTriggered = true;
-                    _httpManager.setUnloading(_isPageUnloadTriggered);
+                    _httpManager[_DYN_SET_UNLOADING /* @min:%2esetUnloading */](_isPageUnloadTriggered);
                 }
                 _releaseAllQueues(2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
             }
             function _handleShowEvents(evt) {
                 // Handle the page becoming visible again
                 _isPageUnloadTriggered = false;
-                _httpManager.setUnloading(_isPageUnloadTriggered);
+                _httpManager[_DYN_SET_UNLOADING /* @min:%2esetUnloading */](_isPageUnloadTriggered);
             }
             function _addEventToQueues(event, append) {
                 // If send attempt field is undefined we should set it to 0.
-                if (!event.sendAttempt) {
-                    event.sendAttempt = 0;
+                if (!event[_DYN_SEND_ATTEMPT /* @min:%2esendAttempt */]) {
+                    event[_DYN_SEND_ATTEMPT /* @min:%2esendAttempt */] = 0;
                 }
                 // Add default latency
-                if (!event.latency) {
-                    event.latency = 1 /* EventLatencyValue.Normal */;
+                if (!event[_DYN_LATENCY /* @min:%2elatency */]) {
+                    event[_DYN_LATENCY /* @min:%2elatency */] = 1 /* EventLatencyValue.Normal */;
                 }
                 // Remove extra AI properties if present
                 if (event.ext && event.ext[STR_TRACE]) {
@@ -243,19 +246,19 @@ var PostChannel = /** @class */ (function (_super) {
                 // v8 performance optimization for iterating over the keys
                 if (_optimizeObject) {
                     event.ext = optimizeObject(event.ext);
-                    if (event.baseData) {
-                        event.baseData = optimizeObject(event.baseData);
+                    if (event[_DYN_BASE_DATA /* @min:%2ebaseData */]) {
+                        event[_DYN_BASE_DATA /* @min:%2ebaseData */] = optimizeObject(event[_DYN_BASE_DATA /* @min:%2ebaseData */]);
                     }
-                    if (event.data) {
-                        event.data = optimizeObject(event.data);
+                    if (event[_DYN_DATA /* @min:%2edata */]) {
+                        event[_DYN_DATA /* @min:%2edata */] = optimizeObject(event[_DYN_DATA /* @min:%2edata */]);
                     }
                 }
-                if (event.sync) {
+                if (event[_DYN_SYNC /* @min:%2esync */]) {
                     // If the transmission is backed off then do not send synchronous events.
                     // We will convert these events to Real time latency instead.
                     if (_currentBackoffCount || _paused) {
-                        event.latency = 3 /* EventLatencyValue.RealTime */;
-                        event.sync = false;
+                        event[_DYN_LATENCY /* @min:%2elatency */] = 3 /* EventLatencyValue.RealTime */;
+                        event[_DYN_SYNC /* @min:%2esync */] = false;
                     }
                     else {
                         // Log the event synchronously
@@ -264,12 +267,12 @@ var PostChannel = /** @class */ (function (_super) {
                             if (_optimizeObject) {
                                 event = optimizeObject(event);
                             }
-                            _httpManager.sendSynchronousBatch(EventBatch.create(event.iKey, [event]), event.sync === true ? 1 /* EventSendType.Synchronous */ : event.sync, 3 /* SendRequestReason.SyncEvent */);
+                            _httpManager[_DYN_SEND_SYNCHRONOUS_BAT9 /* @min:%2esendSynchronousBatch */](EventBatch.create(event[_DYN_I_KEY /* @min:%2eiKey */], [event]), event[_DYN_SYNC /* @min:%2esync */] === true ? 1 /* EventSendType.Synchronous */ : event[_DYN_SYNC /* @min:%2esync */], 3 /* SendRequestReason.SyncEvent */);
                             return;
                         }
                     }
                 }
-                var evtLatency = event.latency;
+                var evtLatency = event[_DYN_LATENCY /* @min:%2elatency */];
                 var queueSize = _queueSize;
                 var queueLimit = _queueSizeLimit;
                 if (evtLatency === 4 /* EventLatencyValue.Immediate */) {
@@ -291,7 +294,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                     // Drop old event from lower or equal latency
                     eventDropped = true;
-                    if (_dropEventWithLatencyOrLess(event.iKey, event.latency, dropLatency, dropNumber)) {
+                    if (_dropEventWithLatencyOrLess(event[_DYN_I_KEY /* @min:%2eiKey */], event[_DYN_LATENCY /* @min:%2elatency */], dropLatency, dropNumber)) {
                         eventDropped = !_addEventToProperQueue(event, append);
                     }
                 }
@@ -301,8 +304,8 @@ var PostChannel = /** @class */ (function (_super) {
                 }
             }
             _self.setEventQueueLimits = function (eventLimit, autoFlushLimit) {
-                _postConfig.eventsLimitInMem = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
-                _postConfig.autoFlushEventsLimit = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
+                _postConfig[_DYN_EVENTS_LIMIT_IN_MEM /* @min:%2eeventsLimitInMem */] = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
+                _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI13 /* @min:%2eautoFlushEventsLimit */] = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
                 _setAutoLimits();
                 // We only do this check here as during normal event addition if the queue is > then events start getting dropped
                 var doFlush = _queueSize > eventLimit;
@@ -310,9 +313,9 @@ var PostChannel = /** @class */ (function (_super) {
                     // Check the auto flush max batch size
                     for (var latency = 1 /* EventLatencyValue.Normal */; !doFlush && latency <= 3 /* EventLatencyValue.RealTime */; latency++) {
                         var batchQueue = _batchQueues[latency];
-                        if (batchQueue && batchQueue.batches) {
-                            arrForEach(batchQueue.batches, function (theBatch) {
-                                if (theBatch && theBatch.count() >= _autoFlushBatchLimit) {
+                        if (batchQueue && batchQueue[_DYN_BATCHES /* @min:%2ebatches */]) {
+                            arrForEach(batchQueue[_DYN_BATCHES /* @min:%2ebatches */], function (theBatch) {
+                                if (theBatch && theBatch[_DYN_COUNT /* @min:%2ecount */]() >= _autoFlushBatchLimit) {
                                     // If any 1 batch is > than the limit then trigger an auto flush
                                     doFlush = true;
                                 }
@@ -335,10 +338,10 @@ var PostChannel = /** @class */ (function (_super) {
             _self._loadTransmitProfiles = function (profiles) {
                 _resetTransmitProfiles();
                 objForEachKey(profiles, function (profileName, profileValue) {
-                    var profLen = profileValue.length;
+                    var profLen = profileValue[_DYN_LENGTH /* @min:%2elength */];
                     if (profLen >= 2) {
                         var directValue = (profLen > 2 ? profileValue[2] : 0);
-                        profileValue.splice(0, profLen - 2);
+                        profileValue[_DYN_SPLICE /* @min:%2esplice */](0, profLen - 2);
                         // Make sure if a higher latency is set to not send then don't send lower latency
                         if (profileValue[1] < 0) {
                             profileValue[0] = -1;
@@ -354,7 +357,7 @@ var PostChannel = /** @class */ (function (_super) {
                             // Make sure if it's not disabled (< 0) then make sure it's not larger than RealTime
                             directValue = profileValue[1];
                         }
-                        profileValue.push(directValue);
+                        profileValue[_DYN_PUSH /* @min:%2epush */](directValue);
                         _profiles[profileName] = profileValue;
                     }
                 });
@@ -384,7 +387,7 @@ var PostChannel = /** @class */ (function (_super) {
                         else {
                             // Even if null (no callback) this will ensure after the flushImpl finishes waiting
                             // for a completely idle connection it will attempt to re-flush any queued events on the next cycle
-                            _flushCallbackQueue.push(callback);
+                            _flushCallbackQueue[_DYN_PUSH /* @min:%2epush */](callback);
                         }
                     }
                     else {
@@ -420,7 +423,7 @@ var PostChannel = /** @class */ (function (_super) {
             function _sendEventsForLatencyAndAbove(latency, sendType, sendReason) {
                 var queued = _queueBatches(latency, sendType, sendReason);
                 // Always trigger the request as while the post channel may not have queued additional events, the httpManager may already have waiting events
-                _httpManager.sendQueuedRequests(sendType, sendReason);
+                _httpManager[_DYN_SEND_QUEUED_REQUESTS /* @min:%2esendQueuedRequests */](sendType, sendReason);
                 return queued;
             }
             function _hasEvents() {
@@ -435,7 +438,7 @@ var PostChannel = /** @class */ (function (_super) {
                 // If we had previously attempted to send requests, but the http manager didn't have any idle connections then the requests where delayed
                 // so try and requeue then again now
                 if (_delayedBatchSendLatency >= 0 && _queueBatches(_delayedBatchSendLatency, 0 /* EventSendType.Batched */, _delayedBatchReason)) {
-                    _httpManager.sendQueuedRequests(0 /* EventSendType.Batched */, _delayedBatchReason);
+                    _httpManager[_DYN_SEND_QUEUED_REQUESTS /* @min:%2esendQueuedRequests */](0 /* EventSendType.Batched */, _delayedBatchReason);
                 }
                 if (_immediateQueueSize > 0 && !_immediateTimer && !_paused) {
                     // During initialization _profiles enforce that the direct [2] is less than real time [1] timer value
@@ -468,7 +471,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                 }
             }
-            _self._backOffTransmission = function () {
+            _self[_DYN__BACK_OFF_TRANSMISSI11 /* @min:%2e_backOffTransmission */] = function () {
                 if (_currentBackoffCount < MaxBackoffCount) {
                     _currentBackoffCount++;
                     _clearScheduledTimer();
@@ -590,14 +593,14 @@ var PostChannel = /** @class */ (function (_super) {
                 var eventBatch = batchQueue.iKeyMap[iKey];
                 if (!eventBatch && create) {
                     eventBatch = EventBatch.create(iKey);
-                    batchQueue.batches.push(eventBatch);
+                    batchQueue.batches[_DYN_PUSH /* @min:%2epush */](eventBatch);
                     batchQueue.iKeyMap[iKey] = eventBatch;
                 }
                 return eventBatch;
             }
             function _performAutoFlush(isAsync, doFlush) {
                 // Only perform the auto flush check if the httpManager has an idle connection and we are not in a backoff situation
-                if (_httpManager.canSendRequest() && !_currentBackoffCount) {
+                if (_httpManager[_DYN_CAN_SEND_REQUEST /* @min:%2ecanSendRequest */]() && !_currentBackoffCount) {
                     if (_autoFlushEventsLimit > 0 && _queueSize > _autoFlushEventsLimit) {
                         // Force flushing
                         doFlush = true;
@@ -613,15 +616,15 @@ var PostChannel = /** @class */ (function (_super) {
                 if (_optimizeObject) {
                     event = optimizeObject(event);
                 }
-                var latency = event.latency;
-                var eventBatch = _getEventBatch(event.iKey, latency, true);
+                var latency = event[_DYN_LATENCY /* @min:%2elatency */];
+                var eventBatch = _getEventBatch(event[_DYN_I_KEY /* @min:%2eiKey */], latency, true);
                 if (eventBatch.addEvent(event)) {
                     if (latency !== 4 /* EventLatencyValue.Immediate */) {
                         _queueSize++;
                         // Check for auto flushing based on total events in the queue, but not for requeued or retry events
-                        if (append && event.sendAttempt === 0) {
+                        if (append && event[_DYN_SEND_ATTEMPT /* @min:%2esendAttempt */] === 0) {
                             // Force the flushing of the batch if the batch (specific iKey / latency combination) reaches it's auto flush limit
-                            _performAutoFlush(!event.sync, _autoFlushBatchLimit > 0 && eventBatch.count() >= _autoFlushBatchLimit);
+                            _performAutoFlush(!event.sync, _autoFlushBatchLimit > 0 && eventBatch[_DYN_COUNT /* @min:%2ecount */]() >= _autoFlushBatchLimit);
                         }
                     }
                     else {
@@ -635,10 +638,10 @@ var PostChannel = /** @class */ (function (_super) {
             function _dropEventWithLatencyOrLess(iKey, latency, currentLatency, dropNumber) {
                 while (currentLatency <= latency) {
                     var eventBatch = _getEventBatch(iKey, latency, true);
-                    if (eventBatch && eventBatch.count() > 0) {
+                    if (eventBatch && eventBatch[_DYN_COUNT /* @min:%2ecount */]() > 0) {
                         // Dropped oldest events from lowest possible latency
-                        var droppedEvents = eventBatch.split(0, dropNumber);
-                        var droppedCount = droppedEvents.count();
+                        var droppedEvents = eventBatch[_DYN_SPLIT /* @min:%2esplit */](0, dropNumber);
+                        var droppedCount = droppedEvents[_DYN_COUNT /* @min:%2ecount */]();
                         if (droppedCount > 0) {
                             if (currentLatency === 4 /* EventLatencyValue.Immediate */) {
                                 _immediateQueueSize -= droppedCount;
@@ -665,13 +668,13 @@ var PostChannel = /** @class */ (function (_super) {
                 var normalQueue = 0;
                 var _loop_1 = function (latency) {
                     var batchQueue = _batchQueues[latency];
-                    if (batchQueue && batchQueue.batches) {
-                        arrForEach(batchQueue.batches, function (theBatch) {
+                    if (batchQueue && batchQueue[_DYN_BATCHES /* @min:%2ebatches */]) {
+                        arrForEach(batchQueue[_DYN_BATCHES /* @min:%2ebatches */], function (theBatch) {
                             if (latency === 4 /* EventLatencyValue.Immediate */) {
-                                immediateQueue += theBatch.count();
+                                immediateQueue += theBatch[_DYN_COUNT /* @min:%2ecount */]();
                             }
                             else {
-                                normalQueue += theBatch.count();
+                                normalQueue += theBatch[_DYN_COUNT /* @min:%2ecount */]();
                             }
                         });
                     }
@@ -688,36 +691,36 @@ var PostChannel = /** @class */ (function (_super) {
                 // Only queue batches (to the HttpManager) if this is a sync request or the httpManager has an idle connection
                 // Thus keeping the events within the PostChannel until the HttpManager has a connection available
                 // This is so we can drop "old" events if the queue is getting full because we can't successfully send events
-                if (!isAsync || _httpManager.canSendRequest()) {
+                if (!isAsync || _httpManager[_DYN_CAN_SEND_REQUEST /* @min:%2ecanSendRequest */]()) {
                     doPerf(_self.core, function () { return "PostChannel._queueBatches"; }, function () {
                         var droppedEvents = [];
                         var latencyToProcess = 4 /* EventLatencyValue.Immediate */;
                         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 /* @min:%2elength */] > 0) {
+                                arrForEach(batchQueue[_DYN_BATCHES /* @min:%2ebatches */], function (theBatch) {
                                     // Add the batch to the http manager to send the requests
                                     if (!_httpManager.addBatch(theBatch)) {
                                         // The events from this iKey are being dropped (killed)
-                                        droppedEvents = droppedEvents.concat(theBatch.events());
+                                        droppedEvents = droppedEvents[_DYN_CONCAT /* @min:%2econcat */](theBatch[_DYN_EVENTS /* @min:%2eevents */]());
                                     }
                                     else {
-                                        eventsQueued = eventsQueued || (theBatch && theBatch.count() > 0);
+                                        eventsQueued = eventsQueued || (theBatch && theBatch[_DYN_COUNT /* @min:%2ecount */]() > 0);
                                     }
                                     if (latencyToProcess === 4 /* EventLatencyValue.Immediate */) {
-                                        _immediateQueueSize -= theBatch.count();
+                                        _immediateQueueSize -= theBatch[_DYN_COUNT /* @min:%2ecount */]();
                                     }
                                     else {
-                                        _queueSize -= theBatch.count();
+                                        _queueSize -= theBatch[_DYN_COUNT /* @min:%2ecount */]();
                                     }
                                 });
                                 // Remove all batches from this Queue
-                                batchQueue.batches = [];
+                                batchQueue[_DYN_BATCHES /* @min:%2ebatches */] = [];
                                 batchQueue.iKeyMap = {};
                             }
                             latencyToProcess--;
                         }
-                        if (droppedEvents.length > 0) {
+                        if (droppedEvents[_DYN_LENGTH /* @min:%2elength */] > 0) {
                             _notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.KillSwitch);
                         }
                         if (eventsQueued && _delayedBatchSendLatency >= latency) {
@@ -749,7 +752,7 @@ var PostChannel = /** @class */ (function (_super) {
                     if (callback) {
                         callback();
                     }
-                    if (_flushCallbackQueue.length > 0) {
+                    if (_flushCallbackQueue[_DYN_LENGTH /* @min:%2elength */] > 0) {
                         _flushCallbackTimer = _createTimer(function () {
                             _flushCallbackTimer = null;
                             _flushImpl(_flushCallbackQueue.shift(), sendReason);
@@ -764,7 +767,7 @@ var PostChannel = /** @class */ (function (_super) {
                 });
             }
             function _waitForIdleManager(callback) {
-                if (_httpManager.isCompletelyIdle()) {
+                if (_httpManager[_DYN_IS_COMPLETELY_IDLE /* @min:%2eisCompletelyIdle */]()) {
                     callback();
                 }
                 else {
@@ -802,27 +805,27 @@ var PostChannel = /** @class */ (function (_super) {
                     maxSendAttempts = _maxUnloadEventSendAttempts;
                 }
                 arrForEach(batches, function (theBatch) {
-                    if (theBatch && theBatch.count() > 0) {
-                        arrForEach(theBatch.events(), function (theEvent) {
+                    if (theBatch && theBatch[_DYN_COUNT /* @min:%2ecount */]() > 0) {
+                        arrForEach(theBatch[_DYN_EVENTS /* @min:%2eevents */](), function (theEvent) {
                             if (theEvent) {
                                 // Check if the request being added back is for a sync event in which case mark it no longer a sync event
-                                if (theEvent.sync) {
-                                    theEvent.latency = 4 /* EventLatencyValue.Immediate */;
-                                    theEvent.sync = false;
+                                if (theEvent[_DYN_SYNC /* @min:%2esync */]) {
+                                    theEvent[_DYN_LATENCY /* @min:%2elatency */] = 4 /* EventLatencyValue.Immediate */;
+                                    theEvent[_DYN_SYNC /* @min:%2esync */] = false;
                                 }
-                                if (theEvent.sendAttempt < maxSendAttempts) {
+                                if (theEvent[_DYN_SEND_ATTEMPT /* @min:%2esendAttempt */] < maxSendAttempts) {
                                     // Reset the event timings
-                                    setProcessTelemetryTimings(theEvent, _self.identifier);
+                                    setProcessTelemetryTimings(theEvent, _self[_DYN_IDENTIFIER /* @min:%2eidentifier */]);
                                     _addEventToQueues(theEvent, false);
                                 }
                                 else {
-                                    droppedEvents.push(theEvent);
+                                    droppedEvents[_DYN_PUSH /* @min:%2epush */](theEvent);
                                 }
                             }
                         });
                     }
                 });
-                if (droppedEvents.length > 0) {
+                if (droppedEvents[_DYN_LENGTH /* @min:%2elength */] > 0) {
                     _notifyEvents(strEventsDiscarded, droppedEvents, EventsDiscardedReason.NonRetryableStatus);
                 }
                 if (_isPageUnloadTriggered) {
@@ -847,8 +850,8 @@ var PostChannel = /** @class */ (function (_super) {
                 for (var _i = 2; _i < arguments.length; _i++) {
                     extraArgs[_i - 2] = arguments[_i];
                 }
-                if (theEvents && theEvents.length > 0) {
-                    _callNotification(evtName, [theEvents].concat(extraArgs));
+                if (theEvents && theEvents[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    _callNotification(evtName, [theEvents][_DYN_CONCAT /* @min:%2econcat */](extraArgs));
                 }
             }
             function _notifyBatchEvents(evtName, batches) {
@@ -856,10 +859,10 @@ var PostChannel = /** @class */ (function (_super) {
                 for (var _i = 2; _i < arguments.length; _i++) {
                     extraArgs[_i - 2] = arguments[_i];
                 }
-                if (batches && batches.length > 0) {
+                if (batches && batches[_DYN_LENGTH /* @min:%2elength */] > 0) {
                     arrForEach(batches, function (theBatch) {
-                        if (theBatch && theBatch.count() > 0) {
-                            _callNotification(evtName, [theBatch.events()].concat(extraArgs));
+                        if (theBatch && theBatch[_DYN_COUNT /* @min:%2ecount */]() > 0) {
+                            _callNotification(evtName, [theBatch.events()][_DYN_CONCAT /* @min:%2econcat */](extraArgs));
                         }
                     });
                 }
@@ -869,7 +872,7 @@ var PostChannel = /** @class */ (function (_super) {
              * @ignore
              */
             function _sendingEvent(batches, reason, isSyncRequest) {
-                if (batches && batches.length > 0) {
+                if (batches && batches[_DYN_LENGTH /* @min:%2elength */] > 0) {
                     _callNotification("eventsSendRequest", [(reason >= 1000 /* EventBatchNotificationReason.SendingUndefined */ && reason <= 1999 /* EventBatchNotificationReason.SendingEventMax */ ?
                             reason - 1000 /* EventBatchNotificationReason.SendingUndefined */ :
                             0 /* SendRequestReason.Undefined */), isSyncRequest !== true]);
@@ -924,9 +927,8 @@ var PostChannel = /** @class */ (function (_super) {
 // Removed Stub for PostChannel.prototype._setTransmitProfile.
 // Removed Stub for PostChannel.prototype._backOffTransmission.
 // Removed Stub for PostChannel.prototype._clearBackOff.
-    // This is a workaround for an IE8 bug when using dynamicProto() with classes that don't have any
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
     // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
-    // this will be removed when ES3 support is dropped.
     PostChannel.__ieDyn=1;
 
     return PostChannel;