@microsoft/applicationinsights-offlinechannel-js 0.1.1-nightly3.2402-20 → 0.1.1-nightly3.2403-01

package/dist/es5/applicationinsights-offlinechannel-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Offline Channel, 0.1.1-nightly3.2402-20
+ * Application Insights JavaScript SDK - Offline Channel, 0.1.1-nightly3.2403-01
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1030,6 +1030,15 @@
 
     var createEnumStyle = createEnum;
 
+    var EventsDiscardedReason = createEnumStyle({
+        Unknown: 0 ,
+        NonRetryableStatus: 1 ,
+        InvalidEvent: 2 ,
+        SizeLimitExceeded: 3 ,
+        KillSwitch: 4 ,
+        QueueFull: 5
+    });
+
     var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_BLK_VAL = "blkVal";
     var _DYN_LENGTH$1 = "length";
@@ -3643,11 +3652,139 @@
         }
     }
 
+    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+
+    var _DYN_PUSH$1 = "push";
+
+    var EventPersistence = createEnumStyle({
+        Normal: 1 ,
+        Critical: 2
+    });
+
+    function _disableEvents(target, evtNamespace) {
+        eventOff(target, null, null, evtNamespace);
+    }
+    function createOfflineListener(parentEvtNamespace) {
+        var _document = getDocument();
+        var _navigator = getNavigator();
+        var _isListening = false;
+        var listenerList = [];
+        var rState = 1 ;
+        if (_navigator && !isNullOrUndefined(_navigator.onLine) && !_navigator.onLine) {
+            rState = 2 ;
+        }
+        var uState = 0 ;
+        var _currentState = calCurrentState();
+        var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
+        try {
+            if (_enableEvents(getWindow())) {
+                _isListening = true;
+            }
+            if (_document) {
+                var target = _document.body || _document;
+                if (target.ononline) {
+                    if (_enableEvents(target)) {
+                        _isListening = true;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            _isListening = false;
+        }
+        function _enableEvents(target) {
+            var enabled = false;
+            if (target) {
+                enabled = eventOn(target, "online", _setOnline, _evtNamespace);
+                if (enabled) {
+                    eventOn(target, "offline", _setOffline, _evtNamespace);
+                }
+            }
+            return enabled;
+        }
+        function _isOnline() {
+            return _currentState;
+        }
+        function calCurrentState() {
+            if (uState === 2  || rState === 2 ) {
+                return false;
+            }
+            return true;
+        }
+        function listnerNoticeCheck() {
+            var newState = calCurrentState();
+            if (_currentState !== newState) {
+                _currentState = newState;
+                arrForEach(listenerList, function (callback) {
+                    var offlineState = {
+                        isOnline: _currentState,
+                        rState: rState,
+                        uState: uState
+                    };
+                    try {
+                        callback(offlineState);
+                    }
+                    catch (e) {
+                    }
+                });
+            }
+        }
+        function setOnlineState(newState) {
+            uState = newState;
+            listnerNoticeCheck();
+        }
+        function _setOnline() {
+            rState = 1 ;
+            listnerNoticeCheck();
+        }
+        function _setOffline() {
+            rState = 2 ;
+            listnerNoticeCheck();
+        }
+        function _unload() {
+            var win = getWindow();
+            if (win && _isListening) {
+                _disableEvents(win, _evtNamespace);
+                if (_document) {
+                    var target = _document.body || _document;
+                    if (!isUndefined(target.ononline)) {
+                        _disableEvents(target, _evtNamespace);
+                    }
+                }
+                _isListening = false;
+            }
+        }
+        function addListener(callback) {
+            listenerList[_DYN_PUSH$1 ](callback);
+            return {
+                rm: function () {
+                    var index = listenerList.indexOf(callback);
+                    if (index > -1) {
+                        return listenerList.splice(index, 1);
+                    }
+                    else {
+                        return;
+                    }
+                }
+            };
+        }
+        return {
+            isOnline: _isOnline,
+            isListening: function () { return _isListening; },
+            unload: _unload,
+            addListener: addListener,
+            setOnlineState: setOnlineState
+        };
+    }
+
+    var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
+
     var _DYN_ENDPOINT = "endpoint";
     var _DYN_ADD_EVENT = "addEvent";
     var _DYN_COUNT = "count";
-    var _DYN_PUSH$1 = "push";
+    var _DYN_PUSH = "push";
     var _DYN_LENGTH = "length";
+    var _DYN_CLEAR = "clear";
     var _DYN_GET_ITEMS = "getItems";
     var _DYN_SPLIT = "split";
     var _DYN_SPLICE = "splice";
@@ -3669,15 +3806,18 @@
     var _DYN_INDEX_OF = "indexOf";
     var _DYN_IS_ONLINE = "isOnline";
     var _DYN_CANCEL = "cancel";
-    var _DYN_REFRESH = "refresh";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_PERSISTENCE = "persistence";
+    var _DYN_ONUNLOAD_FLUSH = "onunloadFlush";
+    var _DYN_BATCH_HANDLER = "batchHandler";
     var _DYN_MIN_PERSISTENCE_CACH0 = "minPersistenceCacheLevel";
+    var _DYN_REFRESH = "refresh";
     var _DYN_IS_COMPLETELY_IDLE = "isCompletelyIdle";
     var _DYN_CRITICAL_CNT = "criticalCnt";
     var _DYN_GET_OFFLINE_SUPPORT = "getOfflineSupport";
     var _DYN_OVERRIDE_INSTRUMENTA1 = "overrideInstrumentationKey";
     var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
+    var _DYN_NOTIFICATION_MGR = "notificationMgr";
     var _DYN_TO_STRING = "toString";
     var _DYN_URL_STRING = "urlString";
     var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
@@ -3703,1515 +3843,1438 @@
     var _DYN_SUBSTRING = "substring";
     var _DYN_STORAGE_KEY_PREFIX = "storageKeyPrefix";
     var _DYN_IN_STORAGE_MAX_TIME = "inStorageMaxTime";
-    var _DYN_MAX_STORAGE_SIZE_IN_2 = "maxStorageSizeInBytes";
-    var _DYN__EVENTS_TO_DROP_PER_3 = "EventsToDropPerTime";
-    var _DYN_MAX_CRITICAL_EVTS_DR4 = "maxCriticalEvtsDropCnt";
-    var _DYN_SUPPORTS_SYNC_REQUES5 = "supportsSyncRequests";
+    var _DYN__EVENTS_TO_DROP_PER_2 = "EventsToDropPerTime";
+    var _DYN_MAX_CRITICAL_EVTS_DR3 = "maxCriticalEvtsDropCnt";
+    var _DYN_SUPPORTS_SYNC_REQUES4 = "supportsSyncRequests";
     var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_EVTS = "evts";
     var _DYN_LAST_ACCESS_TIME = "lastAccessTime";
 
-    function getEndpointDomain(endpoint) {
-        try {
-            var url = endpoint[_DYN_REPLACE ](/^https?:\/\/|^www\./, "");
-            url = url[_DYN_REPLACE ](/\?/, "/");
-            var arr = url[_DYN_SPLIT ]("/");
-            if (arr && arr[_DYN_LENGTH ] > 0) {
-                return arr[0];
+    var IndexedDBNames = ["indexedDB" ];
+    var DbReadWrite = "readwrite";
+    var Result = "result";
+    var ErrorMessageUnableToOpenDb = "DBError: Unable to open database";
+    var ErrorMessageDbUpgradeRequired = "DBError: Database upgrade required";
+    var ErrorMessageDbNotOpen = "Database is not open";
+    var ErrorMessageDbDoesNotExist = "DBError: Database does not exist";
+    var ErrorMessageFailedToDeleteDatabase = "DBError: Failed to delete the database";
+    var ErrorMessageDbNotSupported = "DBError: Feature not supported";
+    var ErrorMessageFailedToOpenCursor = "DBError: Failed to Open Cursor";
+    var _dbContext = [];
+    function _getDbContext(dbName, diagLog) {
+        var _a;
+        var dbCtx = null;
+        for (var lp = 0; lp < _dbContext[_DYN_LENGTH ]; lp++) {
+            dbCtx = _dbContext[lp];
+            if (dbCtx[_DYN_NAME ] === dbName) {
+                return dbCtx;
             }
         }
-        catch (e) {
-        }
-        return endpoint;
+        dbCtx = (_a = {},
+            _a[_DYN_NAME ] = dbName,
+            _a.sch = createTaskScheduler(createAsyncPromise, "IndexedDbHelper[" + dbName + "]"),
+            _a.dbHdl = [],
+            _a.add = function (db) {
+                dbCtx.dbHdl[_DYN_PUSH ](db);
+                _debugLog(dbName, "- dbOpened (add) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH ] + "]");
+            },
+            _a[_DYN_REMOVE ] = function (db) {
+                var hdls = dbCtx[_DYN_DB_HDL ];
+                for (var lp = 0; lp < hdls[_DYN_LENGTH ]; lp++) {
+                    if (hdls[lp] === db) {
+                        hdls[_DYN_SPLICE ](lp, 1);
+                        break;
+                    }
+                }
+                _debugLog(dbName, "- dbClosed (remove) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH ] + "]");
+            },
+            _a.isOpen = function () {
+                return dbCtx.dbHdl[_DYN_LENGTH ] > 0;
+            },
+            _a.openHdl = function () {
+                if (dbCtx.dbHdl[_DYN_LENGTH ] > 0) {
+                    return dbCtx[_DYN_DB_HDL ][0];
+                }
+                return null;
+            },
+            _a);
+        _dbContext[_DYN_PUSH ](dbCtx);
+        return dbCtx;
     }
-    function isGreaterThanZero(value) {
-        return value >= 0;
+    function _scheduleEvent(dbName, actionName, startEvent, evtTimeOut) {
+        var dbCtx = _getDbContext(dbName);
+        return dbCtx.sch.queue(startEvent, actionName, evtTimeOut);
     }
-    var _base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-    function base64Encode(data) {
-        var line = "";
-        var input = "";
-        if (isString(data)) {
-            input = data;
-        }
-        else {
-            input = data[_DYN_TO_STRING ]();
-        }
-        var output = "";
-        var chr1, chr2, chr3;
-        var lp = 0;
-        while (lp < input[_DYN_LENGTH ]) {
-            chr1 = input[_DYN_CHAR_CODE_AT ](lp++);
-            chr2 = input[_DYN_CHAR_CODE_AT ](lp++);
-            chr3 = input[_DYN_CHAR_CODE_AT ](lp++);
-            line += _base64[_DYN_CHAR_AT ](chr1 >> 2);
-            line += _base64[_DYN_CHAR_AT ](((chr1 & 3) << 4) | (chr2 >> 4));
-            if (isNaN(chr2)) {
-                line += "==";
+    function getDbFactory() {
+        var global = getGlobal() || {};
+        var dbFactory = null;
+        if (global) {
+            try {
+                for (var lp = 0; lp < IndexedDBNames[_DYN_LENGTH ]; lp++) {
+                    dbFactory = global[IndexedDBNames[lp]];
+                    if (dbFactory && isFunction(dbFactory.open)) {
+                        return dbFactory;
+                    }
+                }
             }
-            else {
-                line += _base64[_DYN_CHAR_AT ](((chr2 & 15) << 2) | (chr3 >> 6));
-                line += isNaN(chr3) ? "=" : _base64[_DYN_CHAR_AT ](chr3 & 63);
+            catch (e) {
+                dbFactory = null;
             }
         }
-        output += line;
-        return output;
+        return dbFactory;
     }
-    function base64Decode(input) {
-        var output = "";
-        var chr1, chr2, chr3;
-        var enc1, enc2, enc3, enc4;
-        var i = 0;
-        input = input[_DYN_REPLACE ](/[^A-Za-z0-9\+\/\=]/g, "");
-        while (i < input[_DYN_LENGTH ]) {
-            enc1 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
-            enc2 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
-            enc3 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
-            enc4 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
-            chr1 = (enc1 << 2) | (enc2 >> 4);
-            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
-            chr3 = ((enc3 & 3) << 6) | enc4;
-            output = output + String[_DYN_FROM_CHAR_CODE ](chr1);
-            if (enc3 != 64) {
-                output = output + String[_DYN_FROM_CHAR_CODE ](chr2);
-            }
-            if (enc4 != 64) {
-                output = output + String[_DYN_FROM_CHAR_CODE ](chr3);
-            }
-        }
-        var arr = output[_DYN_SPLIT ](",").map(function (c) { return Number(c); });
-        return new Uint8Array(arr);
-    }
-    function getTimeId() {
-        var time = (new Date())[_DYN_GET_TIME ]();
-        var random = strSubstr(generateW3CId(), 0, 8);
-        return time + "." + random;
-    }
-    function getTimeFromId(id) {
-        try {
-            var regex = new RegExp(/\d+\./g);
-            if (id && isString(id) && regex.test(id)) {
-                var arr = id[_DYN_SPLIT ](".");
-                return parseInt(arr[0]);
-            }
-        }
-        catch (e) {
-        }
-        return 0;
-    }
-
-    var PayloadHelper = /** @class */ (function () {
-        function PayloadHelper(logger) {
-            dynamicProto(PayloadHelper, this, function (_self) {
-                _self.base64ToArr = function (input) {
-                    if (!input || !input[_DYN_IS_ARR ]) {
-                        return input;
-                    }
-                    try {
-                        var data = input[_DYN_DATA ];
-                        if (data) {
-                            input[_DYN_DATA ] = base64Decode(data);
-                        }
-                        return input;
-                    }
-                    catch (e) {
-                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
-                    }
-                    return null;
-                };
-                _self.base64ToStr = function (item) {
-                    if (!item || !item[_DYN_IS_ARR ]) {
-                        return item;
-                    }
-                    try {
-                        var data = item[_DYN_DATA ];
-                        if (data) {
-                            item[_DYN_DATA ] = base64Encode(data);
-                        }
-                        return item;
-                    }
-                    catch (e) {
-                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
-                    }
-                    return null;
-                };
-            });
-        }
-        PayloadHelper.__ieDyn=1;
-        return PayloadHelper;
-    }());
-
-    var EventsToDropAtOneTime$1 = 10;
-    var Version = "1";
-    var DefaultStorageKey = "AIOffline";
-    var DefaultMaxStorageSizeInBytes = 5000000;
-    var MaxCriticalEvtsDropCnt$1 = 2;
-    var DefaultMaxInStorageTime = 10080000;
-    function _isQuotaExceeded(storage, e) {
-        var result = false;
-        if (e instanceof DOMException) {
-            if (e.code === 22 || e[_DYN_NAME ] === "QuotaExceededError" ||
-                e.code === 1014 || e[_DYN_NAME ] === "NS_ERROR_DOM_QUOTA_REACHED") {
-                if (storage && storage[_DYN_LENGTH ] !== 0) {
-                    result = true;
-                }
-            }
-        }
-        return result;
-    }
-    function _getAvailableStorage(type) {
-        var global = getGlobal() || {};
-        var storage = null;
-        try {
-            storage = (global[type]);
-            if (storage) {
-                var x = "__storage_test__";
-                storage.setItem(x, x);
-                storage[_DYN_REMOVE_ITEM ](x);
-            }
-        }
-        catch (e) {
-            if (!_isQuotaExceeded(storage, e)) {
-                storage = null;
-            }
-        }
-        return storage;
-    }
-    function _forEachMap(map, callback) {
-        if (map) {
-            var keys = objKeys(map);
-            for (var lp = 0; lp < keys[_DYN_LENGTH ]; lp++) {
-                var key = keys[lp];
-                if (!callback(map[key], key)) {
-                    break;
-                }
-            }
-        }
-    }
-    function _dropEventsUpToPersistence$1(maxCnt, events, eventsToDropAtOneTime) {
-        var dropKeys = [];
-        var persistenceCnt = 0;
-        var droppedEvents = 0;
-        while (persistenceCnt <= maxCnt && droppedEvents < eventsToDropAtOneTime) {
-            _forEachMap(events, function (evt, key) {
-                if (evt[_DYN_CRITICAL_CNT ] === persistenceCnt) {
-                    dropKeys[_DYN_PUSH$1 ](key);
-                    droppedEvents++;
-                }
-                return (droppedEvents < eventsToDropAtOneTime);
-            });
-            if (droppedEvents > 0) {
-                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
-                    delete events[dropKeys[lp]];
-                }
-                return true;
-            }
-            persistenceCnt++;
+    function _debugLog(dbName, message) {
+        if (getInst("QUnit")) {
+            console && console.log("IndexedDbHelper [" + dbName + "] " + message);
         }
-        return droppedEvents > 0;
     }
-    function _dropMaxTimeEvents$1(maxStorageTime, events, eventsToDropAtOneTime) {
-        var dropKeys = [];
-        var droppedEvents = 0;
-        var currentTime = (new Date())[_DYN_GET_TIME ]() + 1;
-        var minStartTime = (currentTime - maxStorageTime);
-        try {
-            _forEachMap(events, function (evt, key) {
-                var id = getTimeFromId(key);
-                if (id <= minStartTime) {
-                    dropKeys[_DYN_PUSH$1 ](key);
-                    droppedEvents++;
-                }
-                return (droppedEvents < eventsToDropAtOneTime);
-            });
-            if (droppedEvents > 0) {
-                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
-                    delete events[dropKeys[lp]];
-                }
-                return true;
-            }
-        }
-        catch (e) {
-        }
-        return droppedEvents > 0;
+    function _eventReject(dbName, rejectMessage, rejectFunc, evtName) {
+        return function (evt) {
+            rejectFunc(new Error(rejectMessage));
+            _debugLog(dbName, "[" + evtName + "] event rejected");
+        };
     }
-    var WebStorageProvider = /** @class */ (function () {
-        function WebStorageProvider(storageType, id, unloadHookContainer) {
-            dynamicProto(WebStorageProvider, this, function (_this) {
-                var _storage = null;
-                var _storageKeyPrefix = DefaultStorageKey;
-                var _maxStorageSizeInBytes = DefaultMaxStorageSizeInBytes;
-                var _payloadHelper = null;
-                var _storageKey = null;
-                var _endpoint = null;
-                var _maxStorageTime = null;
-                var _eventDropPerTime = null;
-                var _maxCriticalCnt = null;
-                _this.id = id;
-                _storage = _getAvailableStorage(storageType) || null;
-                _this["_getDbgPlgTargets"] = function () {
-                    return [_storageKey, _maxStorageSizeInBytes, _maxStorageTime];
-                };
-                _this[_DYN_INITIALIZE ] = function (providerContext, endpointUrl) {
-                    if (!_storage) {
-                        return false;
-                    }
-                    var storageConfig = providerContext[_DYN_STORAGE_CONFIG ];
-                    var itemCtx = providerContext[_DYN_ITEM_CTX ];
-                    _payloadHelper = new PayloadHelper(itemCtx[_DYN_DIAG_LOG ]());
-                    _endpoint = getEndpointDomain(endpointUrl || providerContext[_DYN_ENDPOINT ]);
-                    var autoClean = !!storageConfig.autoClean;
-                    var unloadHook = onConfigChange(storageConfig, function () {
-                        _maxStorageSizeInBytes = storageConfig[_DYN_MAX_STORAGE_SIZE_IN_2 ] || DefaultMaxStorageSizeInBytes;
-                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || DefaultMaxInStorageTime;
-                        var dropNum = storageConfig[_DYN__EVENTS_TO_DROP_PER_3 ];
-                        _eventDropPerTime = isNotNullOrUndefined(dropNum) ? dropNum : EventsToDropAtOneTime$1;
-                        _maxCriticalCnt = storageConfig[_DYN_MAX_CRITICAL_EVTS_DR4 ] || MaxCriticalEvtsDropCnt$1;
-                    });
-                    unloadHookContainer && unloadHookContainer.add(unloadHook);
-                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultStorageKey;
-                    _storageKey = _storageKeyPrefix + "_" + Version + "_" + _endpoint;
-                    if (autoClean) {
-                        _this.clean();
-                    }
-                    return true;
-                };
-                _this[_DYN_SUPPORTS_SYNC_REQUES5 ] = function () {
-                    return true;
+    var IndexedDbHelper = /** @class */ (function () {
+        function IndexedDbHelper(diagLog) {
+            var _dbFactory = getDbFactory() || null;
+            dynamicProto(IndexedDbHelper, this, function (_this) {
+                _this[_DYN_IS_AVAILABLE ] = function () {
+                    return !!_dbFactory;
                 };
-                _this.getAllEvents = function (cnt) {
-                    try {
-                        if (!_storage) {
-                            return;
-                        }
-                        return _getEvts(cnt);
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
+                _this.openDb = function (dbName, dbVersion, processFunc, versionChangeFunc) {
+                    return _scheduleEvent(dbName, "openDb", function (evtName) {
+                        return createAsyncPromise(function (openResolve, openReject) {
+                            var createdNewDb = false;
+                            function _createDbCtx(dbContext, db, dbOpenRequest, isNew, isUpgrade) {
+                                var _a;
+                                var crDbCtx = (_a = {
+                                        db: db
+                                    },
+                                    _a[_DYN_DB_NAME ] = dbName,
+                                    _a.dbVersion = dbVersion,
+                                    _a.ctx = null,
+                                    _a.isNew = isNew,
+                                    _a.txn = dbOpenRequest ? dbOpenRequest[_DYN_TRANSACTION ] : null
+                                ,
+                                    _a);
+                                if (!isUpgrade) {
+                                    crDbCtx[_DYN_OPEN_STORE ] = function (eventTable, doAction) {
+                                        return _openStore(crDbCtx, eventTable, doAction);
+                                    };
+                                    crDbCtx[_DYN_OPEN_CURSOR ] = function (eventTable, query, cursorFunc) {
+                                        return _openCursor(crDbCtx, eventTable, query, cursorFunc);
+                                    };
+                                }
+                                return crDbCtx;
+                            }
+                            function _databaseUpgrade(db, dbOpenRequest, ev) {
+                                _debugLog(dbName, "db upgrade called");
+                                var upgDbCtx = _createDbCtx(null, db, dbOpenRequest, true, true);
+                                if (!versionChangeFunc) {
+                                    try {
+                                        dbOpenRequest[_DYN_TRANSACTION ] && dbOpenRequest[_DYN_TRANSACTION ].abort();
+                                        dbOpenRequest.result && dbOpenRequest.result.close();
+                                    }
+                                    finally {
+                                        openReject(new Error(ErrorMessageDbUpgradeRequired));
+                                    }
+                                    return;
+                                }
+                                createdNewDb = true;
+                                doAwaitResponse(versionChangeFunc(upgDbCtx), function (response) {
+                                    if (!response[_DYN_REJECTED ]) {
+                                        _debugLog(upgDbCtx[_DYN_DB_NAME ], "on version change success");
+                                        if (!upgDbCtx.txn) {
+                                            upgDbCtx.txn = dbOpenRequest[_DYN_TRANSACTION ];
+                                            _debugLog(upgDbCtx[_DYN_DB_NAME ], "added open request");
+                                        }
+                                    }
+                                    else {
+                                        try {
+                                            dbOpenRequest[_DYN_TRANSACTION ] && dbOpenRequest[_DYN_TRANSACTION ].abort();
+                                        }
+                                        finally {
+                                            openReject(response[_DYN_REASON ]);
+                                        }
+                                    }
+                                });
+                            }
+                            function _databaseOpen(db, dbOpenRequest) {
+                                var opDbCtx = _getDbContext(dbName);
+                                opDbCtx.add(db);
+                                db.onabort = function (evt) {
+                                    _debugLog(dbName, "onabort -- closing the Db");
+                                    opDbCtx[_DYN_REMOVE ](db);
+                                };
+                                db[_DYN_ONERROR ] = function (evt) {
+                                    _debugLog(dbName, "onerror -- closing the Db");
+                                    opDbCtx[_DYN_REMOVE ](db);
+                                };
+                                db.onclose = function (evt) {
+                                    _debugLog(dbName, "onclose -- closing the Db");
+                                    opDbCtx[_DYN_REMOVE ](db);
+                                };
+                                db.onversionchange = function (evt) {
+                                    _debugLog(dbName, "onversionchange -- force closing the Db");
+                                    db.close();
+                                    opDbCtx[_DYN_REMOVE ](db);
+                                };
+                                var openDbCtx = null;
+                                var dbHdl = null;
+                                if (opDbCtx.dbHdl[_DYN_LENGTH ] > 0) {
+                                    dbHdl = opDbCtx[_DYN_DB_HDL ][0];
+                                }
+                                openDbCtx = _createDbCtx(opDbCtx, dbHdl, dbOpenRequest, createdNewDb);
+                                try {
+                                    doAwait(processFunc(openDbCtx), openResolve, openReject);
+                                }
+                                catch (e) {
+                                    openReject(e);
+                                }
+                            }
+                            var dbCtx = _getDbContext(dbName);
+                            if (_dbFactory == null) {
+                                openReject(new Error("No available storage factory"));
+                            }
+                            else if (dbCtx.isOpen()) {
+                                var openDbCtx = _createDbCtx(dbCtx, dbCtx.openHdl(), null, false);
+                                doAwait(processFunc(openDbCtx), openResolve, openReject);
+                            }
+                            else {
+                                var dbOpenRequest_1 = _dbFactory.open(dbName, dbVersion);
+                                if (!dbOpenRequest_1) {
+                                    throw new Error("missing API");
+                                }
+                                dbOpenRequest_1.onblocked = function (evt) {
+                                    _debugLog(dbName, "Db Open Blocked event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
+                                    openReject(new Error(ErrorMessageUnableToOpenDb));
+                                };
+                                dbOpenRequest_1[_DYN_ONERROR ] = function (evt) {
+                                    _debugLog(dbName, "Db Open Error event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
+                                    openReject(new Error(ErrorMessageUnableToOpenDb));
+                                };
+                                dbOpenRequest_1.onupgradeneeded = function (evt) {
+                                    _debugLog(dbName, "Db Open Create/Upgrade needed event [" + evtName + "]");
+                                    try {
+                                        var db = evt.target[Result] || dbOpenRequest_1.result;
+                                        if (!db) {
+                                            _debugLog(dbName, "no db");
+                                            openReject(new Error(ErrorMessageUnableToOpenDb));
+                                            return;
+                                        }
+                                        _databaseUpgrade(db, dbOpenRequest_1);
+                                    }
+                                    catch (e) {
+                                        _eventReject(dbName, ErrorMessageUnableToOpenDb, openReject, evtName)(e);
+                                    }
+                                };
+                                dbOpenRequest_1[_DYN_ONSUCCESS ] = function (evt) {
+                                    _debugLog(dbName, "Db Open sucess [" + evtName + "]");
+                                    var db = evt.target[Result];
+                                    if (!db) {
+                                        openReject(new Error(ErrorMessageUnableToOpenDb));
+                                        return;
+                                    }
+                                    _databaseOpen(db, dbOpenRequest_1);
+                                };
+                            }
+                        });
+                    });
                 };
-                _this[_DYN_GET_NEXT_BATCH ] = function () {
-                    try {
-                        if (!_storage) {
-                            return;
+                _this.closeDb = function (dbName) {
+                    _debugLog(dbName, "close db");
+                    _scheduleEvent(dbName, "closeDb", function (evtName) {
+                        var dbCtx = _getDbContext(dbName);
+                        var dbHdls = dbCtx[_DYN_DB_HDL ];
+                        var len = dbHdls[_DYN_LENGTH ];
+                        if (len > 0) {
+                            for (var lp = 0; lp < len; lp++) {
+                                dbHdls[lp].close();
+                            }
+                            dbCtx[_DYN_DB_HDL ] = [];
                         }
-                        return _getEvts(1);
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
+                        return 1;
+                    }).catch(function (reason) {
+                    });
                 };
-                function _getEvts(cnt) {
-                    var allItems = [];
-                    var theStore = _fetchStoredDb(_storageKey).db;
-                    if (theStore) {
-                        var events = theStore[_DYN_EVTS ];
-                        _forEachMap(events, function (evt) {
-                            if (evt) {
-                                if (evt[_DYN_IS_ARR ]) {
-                                    evt = _payloadHelper.base64ToArr(evt);
-                                }
-                                allItems[_DYN_PUSH$1 ](evt);
-                            }
-                            if (cnt && allItems && allItems[_DYN_LENGTH ] == cnt) {
-                                return false;
-                            }
-                            return true;
-                        });
+                _this.deleteDb = function (dbName) {
+                    if (_dbFactory == null) {
+                        return false;
                     }
-                    return allItems;
-                }
-                _this[_DYN_ADD_EVENT ] = function (key, evt, itemCtx) {
-                    try {
-                        var theStore = _fetchStoredDb(_storageKey);
-                        evt.id = evt.id || getTimeId();
-                        evt[_DYN_CRITICAL_CNT ] = evt[_DYN_CRITICAL_CNT ] || 0;
-                        var events = theStore.db[_DYN_EVTS ];
-                        var id_1 = evt.id;
-                        if (evt && evt[_DYN_IS_ARR ]) {
-                            evt = _payloadHelper.base64ToStr(evt);
-                        }
-                        while (evt) {
-                            events[id_1] = evt;
-                            if (_updateStoredDb(theStore)) {
-                                return evt;
-                            }
-                            delete events[id_1];
-                            if (!_dropEventsUpToPersistence$1(_maxCriticalCnt, events, _eventDropPerTime)) {
-                                return createAsyncRejectedPromise(new Error("Unable to free up event space"));
+                    return _scheduleEvent(dbName, "deleteDb", function (evtName) {
+                        var dbCtx = _getDbContext(dbName);
+                        var dbHdls = dbCtx[_DYN_DB_HDL ];
+                        var len = dbHdls[_DYN_LENGTH ];
+                        if (len > 0) {
+                            _debugLog(dbName, "Db is open [" + len + "] force closing");
+                            for (var lp = 0; lp < len; lp++) {
+                                dbHdls[lp].close();
                             }
+                            dbCtx[_DYN_DB_HDL ] = [];
                         }
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
-                };
-                _this[_DYN_REMOVE_EVENTS ] = function (evts) {
-                    try {
-                        var theStore = _fetchStoredDb(_storageKey, false);
-                        var currentDb = theStore.db;
-                        if (currentDb) {
-                            var events = currentDb[_DYN_EVTS ];
-                            try {
-                                for (var i = 0; i < evts[_DYN_LENGTH ]; ++i) {
-                                    var evt = evts[i];
-                                    delete events[evt.id];
+                        return createAsyncPromise(function (deleteResolve, deleteReject) {
+                            setTimeout(function () {
+                                try {
+                                    _debugLog(dbName, "[" + evtName + "] starting");
+                                    var dbRequest = _dbFactory.deleteDatabase(dbName);
+                                    dbRequest[_DYN_ONERROR ] = function (evt) {
+                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                    };
+                                    dbRequest.onblocked = function (evt) {
+                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                    };
+                                    dbRequest.onupgradeneeded = function (evt) {
+                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                    };
+                                    dbRequest[_DYN_ONSUCCESS ] = function (evt) {
+                                        _debugLog(dbName, "[" + evtName + "] complete");
+                                        deleteResolve(true);
+                                    };
+                                    _debugLog(dbName, "[" + evtName + "] started");
                                 }
-                                if (_updateStoredDb(theStore)) {
-                                    return evts;
+                                catch (e) {
+                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase + " - " + e));
                                 }
-                            }
-                            catch (e) {
-                            }
-                            evts = _clearDatabase(theStore.key);
-                        }
-                        return evts;
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
+                            }, 0);
+                        });
+                    });
                 };
-                _this.clear = function () {
-                    try {
-                        var removedItems_1 = [];
-                        var theStore = _fetchStoredDb(_storageKey, false);
-                        var storedDb = theStore.db;
-                        if (storedDb) {
-                            var events_1 = storedDb[_DYN_EVTS ];
-                            _forEachMap(events_1, function (evt) {
-                                if (evt) {
-                                    delete events_1[evt.id];
-                                    removedItems_1[_DYN_PUSH$1 ](evt);
-                                }
-                                return true;
-                            });
-                            _updateStoredDb(theStore);
+                _this.getDbDetails = function (dbName) {
+                    return _scheduleEvent(dbName, "getDbDetails", function (evtName) {
+                        if (_dbFactory == null || !_dbFactory.databases) {
+                            return createAsyncRejectedPromise(new Error(ErrorMessageDbNotSupported));
                         }
-                        return removedItems_1;
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
+                        return createAsyncPromise(function (databasesResolve, databasesReject) {
+                            var dbPromise = _dbFactory.databases();
+                            dbPromise[_DYN_THEN ](function (databases) {
+                                for (var lp = 0; lp < databases[_DYN_LENGTH ]; lp++) {
+                                    if (databases[lp][_DYN_NAME ] === dbName) {
+                                        databasesResolve(databases[lp]);
+                                        return;
+                                    }
+                                }
+                                databasesReject(new Error(ErrorMessageDbDoesNotExist));
+                            }, databasesReject);
+                        });
+                    }, 2000);
                 };
-                _this.clean = function () {
-                    var storeDetails = _fetchStoredDb(_storageKey, false);
-                    var currentDb = storeDetails.db;
-                    if (currentDb) {
-                        var events = currentDb[_DYN_EVTS ];
-                        try {
-                            var isDropped = _dropMaxTimeEvents$1(_maxStorageTime, events, _eventDropPerTime);
-                            if (isDropped) {
-                                return _updateStoredDb(storeDetails);
+                function _createStoreContext(openDbCtx, eventTable) {
+                    var dbHdl = openDbCtx.db || null;
+                    var tx = dbHdl && dbHdl[_DYN_TRANSACTION ](eventTable, DbReadWrite);
+                    if (tx) {
+                        tx.onabort = function () {
+                        };
+                        tx[_DYN_ONERROR ] = function () {
+                        };
+                        tx.oncomplete = function () {
+                            _debugLog(openDbCtx[_DYN_DB_NAME ], "txn.oncomplete");
+                        };
+                        return {
+                            db: openDbCtx,
+                            store: tx.objectStore(eventTable),
+                            tx: tx,
+                            tbl: eventTable,
+                            openCursor: function (query, processFunc) {
+                                return _openCursor(openDbCtx, eventTable, query, processFunc);
+                            },
+                            newTransaction: function (doAction) {
+                                return _openStore(openDbCtx, eventTable, doAction);
                             }
-                            return true;
-                        }
-                        catch (e) {
-                        }
-                        return false;
+                        };
+                    }
+                    return null;
+                }
+                function _openStore(openDbCtx, eventTable, doAction) {
+                    if (!openDbCtx || !openDbCtx.db) {
+                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
                     }
-                };
-                _this[_DYN_TEARDOWN ] = function () {
                     try {
-                        var theStore = _fetchStoredDb(_storageKey, false);
-                        var storedDb = theStore.db;
-                        if (storedDb) {
-                            storedDb[_DYN_LAST_ACCESS_TIME ] = 0;
-                            _updateStoredDb(theStore, false);
+                        var result = doAction(_createStoreContext(openDbCtx, eventTable));
+                        if (isPromiseLike(result)) {
+                            return result;
                         }
+                        return createAsyncResolvedPromise(result);
                     }
                     catch (e) {
+                        return createAsyncRejectedPromise(e);
                     }
-                };
-                function _newStore(dbKey, db) {
-                    return {
-                        key: dbKey,
-                        db: db
-                    };
-                }
-                function _fetchStoredDb(dbKey, returnDefault) {
-                    var _a;
-                    if (returnDefault === void 0) { returnDefault = true; }
-                    var dbToStore = null;
-                    if (_storage) {
-                        var previousDb = _storage.getItem(dbKey);
-                        if (previousDb) {
-                            try {
-                                dbToStore = getJSON().parse(previousDb);
-                            }
-                            catch (e) {
-                                _storage[_DYN_REMOVE_ITEM ](dbKey);
-                            }
-                        }
-                        if (returnDefault && !dbToStore) {
-                            dbToStore = (_a = {
-                                    evts: {}
-                                },
-                                _a[_DYN_LAST_ACCESS_TIME ] = 0,
-                                _a);
-                        }
-                    }
-                    return _newStore(dbKey, dbToStore);
                 }
-                function _updateStoredDb(jsonStore, updateLastAccessTime) {
-                    if (updateLastAccessTime === void 0) { updateLastAccessTime = true; }
-                    var dbToStore = jsonStore.db;
-                    if (dbToStore) {
-                        if (updateLastAccessTime) {
-                            dbToStore.lastAccessTime = (new Date())[_DYN_GET_TIME ]();
-                        }
+                function _openCursor(openDbCtx, eventTable, query, processFunc) {
+                    if (!openDbCtx || !openDbCtx.db) {
+                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
                     }
-                    try {
-                        var jsonString = getJSON().stringify(dbToStore);
-                        if (jsonString[_DYN_LENGTH ] > _maxStorageSizeInBytes) {
-                            return false;
-                        }
-                        _storage && _storage.setItem(jsonStore.key, jsonString);
+                    var simpleQuery = null;
+                    if (query && isString(query)) {
+                        simpleQuery = new SimpleQuery(query);
                     }
-                    catch (e) {
-                        return false;
+                    else if (query && query.isMatch) {
+                        simpleQuery = query;
                     }
-                    return true;
-                }
-                function _clearDatabase(dbKey) {
-                    var removedItems = [];
-                    var storeDetails = _fetchStoredDb(dbKey, false);
-                    var currentDb = storeDetails.db;
-                    if (currentDb) {
-                        var events = currentDb[_DYN_EVTS ];
-                        try {
-                            _forEachMap(events, function (evt) {
-                                if (evt) {
-                                    removedItems[_DYN_PUSH$1 ](evt);
-                                }
-                                return true;
-                            });
+                    return createAsyncPromise(function (openCursorResolve, openCursorReject) {
+                        var values = [];
+                        var cursorRequest = null;
+                        var queryKeyRange = null;
+                        if (simpleQuery && simpleQuery[_DYN_KEY_RANGE ]) {
+                            queryKeyRange = simpleQuery[_DYN_KEY_RANGE ]();
                         }
-                        catch (e) {
+                        var storeCtx = _createStoreContext(openDbCtx, eventTable);
+                        if (queryKeyRange) {
+                            cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR ](queryKeyRange);
                         }
-                        _storage && _storage[_DYN_REMOVE_ITEM ](storeDetails.key);
-                    }
-                    return removedItems;
+                        else {
+                            cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR ]();
+                        }
+                        cursorRequest[_DYN_ONERROR ] = _eventReject(storeCtx.db[_DYN_DB_NAME ], ErrorMessageFailedToOpenCursor, openCursorReject, "openCursor");
+                        cursorRequest[_DYN_ONSUCCESS ] = function (evt) {
+                            var _a;
+                            var cursor = evt.target[Result];
+                            if (!cursor) {
+                                openCursorResolve(values);
+                                return;
+                            }
+                            var processCursorState = (_a = {
+                                    store: storeCtx,
+                                    cursor: cursor
+                                },
+                                _a[_DYN_CONTINUE ] = function () {
+                                    cursor[_DYN_CONTINUE ]();
+                                },
+                                _a.done = function () {
+                                    openCursorResolve(values);
+                                }
+                            ,
+                                _a);
+                            var value = cursor[_DYN_VALUE ];
+                            if (simpleQuery && !simpleQuery.isMatch(value)) {
+                                processCursorState[_DYN_CONTINUE ]();
+                                return;
+                            }
+                            if (processFunc) {
+                                try {
+                                    switch (processFunc(processCursorState, value, values)) {
+                                        case 2 :
+                                            openCursorResolve(values);
+                                            break;
+                                        case 1 :
+                                            break;
+                                        case 0 :
+                                        default:
+                                            processCursorState[_DYN_CONTINUE ]();
+                                            break;
+                                    }
+                                }
+                                catch (ex) {
+                                    openCursorReject(ex);
+                                }
+                            }
+                            else {
+                                values[_DYN_PUSH ](value);
+                                processCursorState[_DYN_CONTINUE ]();
+                            }
+                        };
+                    });
                 }
             });
         }
-        WebStorageProvider.__ieDyn=1;
-        return WebStorageProvider;
+        IndexedDbHelper.__ieDyn=1;
+        return IndexedDbHelper;
     }());
-
-    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-
-    var _DYN_PUSH = "push";
-
-    var EventPersistence = createEnumStyle({
-        Normal: 1 ,
-        Critical: 2
-    });
-
-    function _disableEvents(target, evtNamespace) {
-        eventOff(target, null, null, evtNamespace);
-    }
-    function createOfflineListener(parentEvtNamespace) {
-        var _document = getDocument();
-        var _navigator = getNavigator();
-        var _isListening = false;
-        var listenerList = [];
-        var rState = 1 ;
-        if (_navigator && !isNullOrUndefined(_navigator.onLine) && !_navigator.onLine) {
-            rState = 2 ;
-        }
-        var uState = 0 ;
-        var _currentState = calCurrentState();
-        var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
-        try {
-            if (_enableEvents(getWindow())) {
-                _isListening = true;
-            }
-            if (_document) {
-                var target = _document.body || _document;
-                if (target.ononline) {
-                    if (_enableEvents(target)) {
-                        _isListening = true;
-                    }
-                }
-            }
-        }
-        catch (e) {
-            _isListening = false;
-        }
-        function _enableEvents(target) {
-            var enabled = false;
-            if (target) {
-                enabled = eventOn(target, "online", _setOnline, _evtNamespace);
-                if (enabled) {
-                    eventOn(target, "offline", _setOffline, _evtNamespace);
-                }
-            }
-            return enabled;
-        }
-        function _isOnline() {
-            return _currentState;
-        }
-        function calCurrentState() {
-            if (uState === 2  || rState === 2 ) {
-                return false;
-            }
-            return true;
-        }
-        function listnerNoticeCheck() {
-            var newState = calCurrentState();
-            if (_currentState !== newState) {
-                _currentState = newState;
-                arrForEach(listenerList, function (callback) {
-                    var offlineState = {
-                        isOnline: _currentState,
-                        rState: rState,
-                        uState: uState
-                    };
-                    try {
-                        callback(offlineState);
-                    }
-                    catch (e) {
+    var SimpleQuery = /** @class */ (function () {
+        function SimpleQuery(theQuery) {
+            var _queryCols = [];
+            var _keyRange = null;
+            dynamicProto(SimpleQuery, this, function (_this) {
+                _this[_DYN_KEY_RANGE ] = function () {
+                    return _keyRange;
+                };
+                _this.parseQuery = function (query) {
+                    _queryCols = [];
+                    if (query) {
+                        var items = query[_DYN_SPLIT ](";");
+                        for (var lp = 0; lp < items[_DYN_LENGTH ]; lp++) {
+                            var item = items[lp];
+                            var idx = item[_DYN_INDEX_OF ]("=");
+                            if (idx !== -1) {
+                                var key = item[_DYN_SUBSTRING ](0, idx);
+                                var value = item[_DYN_SUBSTRING ](idx + 1);
+                                if (key[_DYN_INDEX_OF ]("#") === 0) {
+                                    key = key[_DYN_SUBSTRING ](1);
+                                    if (!_keyRange) {
+                                        _keyRange = IDBKeyRange.bound(value, value + "\uffff");
+                                    }
+                                }
+                                _this.startsWith(key, value);
+                            }
+                        }
                     }
-                });
-            }
-        }
-        function setOnlineState(newState) {
-            uState = newState;
-            listnerNoticeCheck();
-        }
-        function _setOnline() {
-            rState = 1 ;
-            listnerNoticeCheck();
-        }
-        function _setOffline() {
-            rState = 2 ;
-            listnerNoticeCheck();
-        }
-        function _unload() {
-            var win = getWindow();
-            if (win && _isListening) {
-                _disableEvents(win, _evtNamespace);
-                if (_document) {
-                    var target = _document.body || _document;
-                    if (!isUndefined(target.ononline)) {
-                        _disableEvents(target, _evtNamespace);
+                };
+                _this.startsWith = function (columnName, value) {
+                    var _a;
+                    _queryCols[_DYN_PUSH ]((_a = {},
+                        _a[_DYN_NAME ] = columnName,
+                        _a[_DYN_VALUE ] = value,
+                        _a.type = 0 ,
+                        _a));
+                };
+                _this.contains = function (columnName, value) {
+                    var _a;
+                    _queryCols[_DYN_PUSH ]((_a = {},
+                        _a[_DYN_NAME ] = columnName,
+                        _a[_DYN_VALUE ] = value,
+                        _a.type = 1 ,
+                        _a));
+                };
+                _this.isMatch = function (value) {
+                    if (!_queryCols || _queryCols[_DYN_LENGTH ] === 0) {
+                        return true;
                     }
-                }
-                _isListening = false;
-            }
-        }
-        function addListener(callback) {
-            listenerList[_DYN_PUSH ](callback);
-            return {
-                rm: function () {
-                    var index = listenerList.indexOf(callback);
-                    if (index > -1) {
-                        return listenerList.splice(index, 1);
+                    if (!value) {
+                        return false;
                     }
-                    else {
-                        return;
+                    for (var lp = 0; lp < _queryCols[_DYN_LENGTH ]; lp++) {
+                        var query = _queryCols[lp];
+                        var chkValue = value[query.name];
+                        if (chkValue) {
+                            if (query.type === 0 ) {
+                                if (chkValue.indexOf(query[_DYN_VALUE ]) !== 0) {
+                                    return false;
+                                }
+                            }
+                            else if (query.type === 1 ) {
+                                if (chkValue.indexOf(query[_DYN_VALUE ]) === -1) {
+                                    return false;
+                                }
+                            }
+                        }
                     }
+                    return true;
+                };
+                if (theQuery) {
+                    _this.parseQuery(theQuery);
                 }
-            };
+            });
         }
-        return {
-            isOnline: _isOnline,
-            isListening: function () { return _isListening; },
-            unload: _unload,
-            addListener: addListener,
-            setOnlineState: setOnlineState
-        };
-    }
-
-    var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
+        SimpleQuery.__ieDyn=1;
+        return SimpleQuery;
+    }());
 
-    var IndexedDBNames = ["indexedDB" ];
-    var DbReadWrite = "readwrite";
-    var Result = "result";
-    var ErrorMessageUnableToOpenDb = "DBError: Unable to open database";
-    var ErrorMessageDbUpgradeRequired = "DBError: Database upgrade required";
-    var ErrorMessageDbNotOpen = "Database is not open";
-    var ErrorMessageDbDoesNotExist = "DBError: Database does not exist";
-    var ErrorMessageFailedToDeleteDatabase = "DBError: Failed to delete the database";
-    var ErrorMessageDbNotSupported = "DBError: Feature not supported";
-    var ErrorMessageFailedToOpenCursor = "DBError: Failed to Open Cursor";
-    var _dbContext = [];
-    function _getDbContext(dbName, diagLog) {
-        var _a;
-        var dbCtx = null;
-        for (var lp = 0; lp < _dbContext[_DYN_LENGTH ]; lp++) {
-            dbCtx = _dbContext[lp];
-            if (dbCtx[_DYN_NAME ] === dbName) {
-                return dbCtx;
-            }
-        }
-        dbCtx = (_a = {},
-            _a[_DYN_NAME ] = dbName,
-            _a.sch = createTaskScheduler(createAsyncPromise, "IndexedDbHelper[" + dbName + "]"),
-            _a.dbHdl = [],
-            _a.add = function (db) {
-                dbCtx.dbHdl[_DYN_PUSH$1 ](db);
-                _debugLog(dbName, "- dbOpened (add) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH ] + "]");
-            },
-            _a[_DYN_REMOVE ] = function (db) {
-                var hdls = dbCtx[_DYN_DB_HDL ];
-                for (var lp = 0; lp < hdls[_DYN_LENGTH ]; lp++) {
-                    if (hdls[lp] === db) {
-                        hdls[_DYN_SPLICE ](lp, 1);
-                        break;
-                    }
-                }
-                _debugLog(dbName, "- dbClosed (remove) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH ] + "]");
-            },
-            _a.isOpen = function () {
-                return dbCtx.dbHdl[_DYN_LENGTH ] > 0;
-            },
-            _a.openHdl = function () {
-                if (dbCtx.dbHdl[_DYN_LENGTH ] > 0) {
-                    return dbCtx[_DYN_DB_HDL ][0];
-                }
-                return null;
-            },
-            _a);
-        _dbContext[_DYN_PUSH$1 ](dbCtx);
-        return dbCtx;
+    var EventsToDropAtOneTime$1 = 10;
+    var StoreVersion = 1;
+    var OrhpanedEventThresholdInMs = 10080000;
+    var UnknowniKey = "Unknown";
+    var ErrorMessageUnableToAddEvent = "DBError: Unable to add event";
+    var MaxCriticalEvtsDropCnt$1 = 2;
+    var DefaultDbName = "AIOffline";
+    var DbVersion = 1;
+    var EventObjectStoreName = "Evts";
+    function isValidPersistenceLevel(value) {
+        return (isNumber(value) && value >= 0  && value <= EventPersistence.Critical);
     }
-    function _scheduleEvent(dbName, actionName, startEvent, evtTimeOut) {
-        var dbCtx = _getDbContext(dbName);
-        return dbCtx.sch.queue(startEvent, actionName, evtTimeOut);
+    function _getTime() {
+        return new Date()[_DYN_GET_TIME ]();
     }
-    function getDbFactory() {
-        var global = getGlobal() || {};
-        var dbFactory = null;
-        if (global) {
-            try {
-                for (var lp = 0; lp < IndexedDBNames[_DYN_LENGTH ]; lp++) {
-                    dbFactory = global[IndexedDBNames[lp]];
-                    if (dbFactory && isFunction(dbFactory.open)) {
-                        return dbFactory;
-                    }
-                }
+    function _createDb(db) {
+        if (!db.objectStoreNames.contains(EventObjectStoreName)) {
+            var evtStore = db.createObjectStore(EventObjectStoreName, { keyPath: "id" });
+            evtStore.createIndex("criticalCnt", "criticalCnt", { unique: false });
+        }
+    }
+    function _getEvents(values) {
+        var events = [];
+        for (var lp = 0; lp < values[_DYN_LENGTH ]; lp++) {
+            var item = values[lp];
+            if (item && item.evt) {
+                events[_DYN_PUSH ](item.evt);
             }
-            catch (e) {
-                dbFactory = null;
+        }
+        return events;
+    }
+    function _addEventByTime(values, newValue) {
+        for (var idx = 0; idx < values[_DYN_LENGTH ]; idx++) {
+            if (newValue.tm < values[idx].tm) {
+                values[_DYN_SPLICE ](idx, 0, newValue);
+                return;
             }
         }
-        return dbFactory;
+        values[_DYN_PUSH ](newValue);
     }
-    function _debugLog(dbName, message) {
-        if (getInst("QUnit")) {
-            console && console.log("IndexedDbHelper [" + dbName + "] " + message);
+    function _getId(key, values) {
+        var len = values[_DYN_LENGTH ];
+        for (var lp = 0; lp < len; lp++) {
+            if (key === values[lp].id) {
+                return lp;
+            }
         }
+        return -1;
     }
-    function _eventReject(dbName, rejectMessage, rejectFunc, evtName) {
+    function _cursorContinueEvent(cursorState, value) {
         return function (evt) {
-            rejectFunc(new Error(rejectMessage));
-            _debugLog(dbName, "[" + evtName + "] event rejected");
+            return cursorState[_DYN_CONTINUE ]();
         };
     }
-    var IndexedDbHelper = /** @class */ (function () {
-        function IndexedDbHelper(diagLog) {
-            var _dbFactory = getDbFactory() || null;
-            dynamicProto(IndexedDbHelper, this, function (_this) {
-                _this[_DYN_IS_AVAILABLE ] = function () {
-                    return !!_dbFactory;
+    function _cursorDeleteAndContinue(cursorState, value) {
+        var deleteRequest = cursorState.cursor.delete();
+        deleteRequest[_DYN_ONERROR ] = _cursorContinueEvent(cursorState);
+        deleteRequest[_DYN_ONSUCCESS ] = _cursorContinueEvent(cursorState);
+        return 1 ;
+    }
+    function _getAllEvents(dbCtx, cursorQuery, cnt) {
+        return dbCtx.openCursor(EventObjectStoreName, cursorQuery, function (cursorState, value, values) {
+            values[_DYN_PUSH ](value);
+            if (cnt && values && values[_DYN_LENGTH ] == cnt) {
+                return 2 ;
+            }
+            return 0 ;
+        });
+    }
+    function _deleteEvents(dbCtx, eventPrefixQuery, shouldDelete) {
+        return dbCtx.openCursor(EventObjectStoreName, eventPrefixQuery, function (deleteCursorState, value, values) {
+            if (shouldDelete(value)) {
+                values[_DYN_PUSH ](value);
+                return _cursorDeleteAndContinue(deleteCursorState);
+            }
+            return 0 ;
+        });
+    }
+    function _dropMaxTimeEvents$1(dbCtx, maxTime) {
+        return createAsyncPromise(function (deleteEvtsResolve, deleteEvtsReject) {
+            return _deleteEvents(dbCtx, null, function (value) {
+                if (!value || !value.evt) {
+                    return true;
+                }
+                var addedTime = getTimeFromId(value.id);
+                var minStartTime = _getTime() + 1 - maxTime;
+                if (addedTime <= minStartTime) {
+                    return true;
+                }
+                return false;
+            })[_DYN_THEN ](function (values) {
+                deleteEvtsResolve(values);
+            }, deleteEvtsReject);
+        });
+    }
+    function _dropEventsUpToPersistence$1(dbCtx, maxpriorityCnt, maxDropCnt) {
+        return createAsyncPromise(function (dropEventsResolve, dropEventsReject) {
+            var droppedEvents = 0;
+            function _resolveWithDroppedEvents() {
+                dropEventsResolve(droppedEvents);
+            }
+            function _dropEvent(deleteStoreCtx, dropItem) {
+                return createAsyncPromise(function (deleteResolve) {
+                    var deleteRequest = deleteStoreCtx.store.delete(dropItem.key);
+                    deleteRequest[_DYN_ONSUCCESS ] = function (evt) {
+                        droppedEvents++;
+                        deleteResolve();
+                    };
+                    deleteRequest[_DYN_ONERROR ] = function (evt) {
+                        deleteResolve();
+                    };
+                });
+            }
+            function _processCandidates(dropCandidates) {
+                if (dropCandidates[_DYN_LENGTH ] === 0) {
+                    _resolveWithDroppedEvents();
+                    return;
+                }
+                dbCtx[_DYN_OPEN_STORE ](EventObjectStoreName, function (deleteStoreCtx) {
+                    var deleteEvts = [];
+                    for (var lp = 0; lp < dropCandidates[_DYN_LENGTH ]; lp++) {
+                        deleteEvts[_DYN_PUSH ](_dropEvent(deleteStoreCtx, dropCandidates[lp]));
+                    }
+                    return createAsyncAllPromise(deleteEvts)[_DYN_THEN ](_resolveWithDroppedEvents, _resolveWithDroppedEvents);
+                });
+            }
+            var cursorPromise = dbCtx.openCursor(EventObjectStoreName, null, function (cursorState, value, values) {
+                if (value.evt[_DYN_CRITICAL_CNT ] <= maxpriorityCnt) {
+                    _addEventByTime(values, value);
+                    if (values[_DYN_LENGTH ] > maxDropCnt) {
+                        values.splice(values[_DYN_LENGTH ] - 1, 1);
+                    }
+                }
+                return 0 ;
+            });
+            cursorPromise[_DYN_THEN ](_processCandidates, function () {
+                dropEventsResolve(0);
+            });
+        });
+    }
+    var IndexedDbProvider = /** @class */ (function () {
+        function IndexedDbProvider(id, unloadHookContainer) {
+            dynamicProto(IndexedDbProvider, this, function (_this) {
+                var _indexedDb = null;
+                var _dbName = null;
+                var _iKey = UnknowniKey;
+                var _storageId = null;
+                var _autoClean = null;
+                var _endpoint = null;
+                var _storageKeyPrefix = null;
+                var _maxStorageTime = null;
+                var _eventDropPerTime = null;
+                var _maxCriticalCnt = null;
+                var _notificationManager = null;
+                _this.id = id;
+                _this[_DYN_INITIALIZE ] = function (providerContext) {
+                    var diagLog = providerContext.itemCtx[_DYN_DIAG_LOG ]();
+                    _indexedDb = new IndexedDbHelper(diagLog);
+                    if (!_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        _indexedDb = null;
+                        return false;
+                    }
+                    var coreConfig = providerContext[_DYN_ITEM_CTX ].getCfg();
+                    var itemCtx = providerContext[_DYN_ITEM_CTX ];
+                    _iKey = itemCtx.getCfg()[_DYN_INSTRUMENTATION_KEY ] || coreConfig[_DYN_INSTRUMENTATION_KEY ];
+                    var storageConfig = providerContext[_DYN_STORAGE_CONFIG ];
+                    _storageId = _this.id || providerContext.id || newGuid();
+                    _notificationManager = providerContext[_DYN_NOTIFICATION_MGR ];
+                    _endpoint = getEndpointDomain(providerContext[_DYN_ENDPOINT ]);
+                    _autoClean = !!storageConfig.autoClean;
+                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultDbName;
+                    _dbName = _storageKeyPrefix + "_" + DbVersion + "_" + _endpoint;
+                    var unloadHook = onConfigChange(storageConfig, function () {
+                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || OrhpanedEventThresholdInMs;
+                        var dropNum = storageConfig[_DYN__EVENTS_TO_DROP_PER_2 ];
+                        _eventDropPerTime = isNotNullOrUndefined(dropNum) ? dropNum : EventsToDropAtOneTime$1;
+                        _maxCriticalCnt = storageConfig[_DYN_MAX_CRITICAL_EVTS_DR3 ] || MaxCriticalEvtsDropCnt$1;
+                    });
+                    unloadHookContainer && unloadHookContainer.add(unloadHook);
+                    if (_dbName) {
+                        doAwaitResponse(_this.clean(!_autoClean), function (response) {
+                            _openDb(function (dbCtx) {
+                                return true;
+                            })[_DYN_THEN ](function (value) {
+                            }, function (reason) {
+                                diagLog.warnToConsole("IndexedDbProvider failed to initialize - " + (reason || "<unknown>"));
+                                _indexedDb = null;
+                            });
+                        });
+                    }
+                    return true;
                 };
-                _this.openDb = function (dbName, dbVersion, processFunc, versionChangeFunc) {
-                    return _scheduleEvent(dbName, "openDb", function (evtName) {
-                        return createAsyncPromise(function (openResolve, openReject) {
-                            var createdNewDb = false;
-                            function _createDbCtx(dbContext, db, dbOpenRequest, isNew, isUpgrade) {
-                                var _a;
-                                var crDbCtx = (_a = {
-                                        db: db
-                                    },
-                                    _a[_DYN_DB_NAME ] = dbName,
-                                    _a.dbVersion = dbVersion,
-                                    _a.ctx = null,
-                                    _a.isNew = isNew,
-                                    _a.txn = dbOpenRequest ? dbOpenRequest[_DYN_TRANSACTION ] : null
-                                ,
-                                    _a);
-                                if (!isUpgrade) {
-                                    crDbCtx[_DYN_OPEN_STORE ] = function (eventTable, doAction) {
-                                        return _openStore(crDbCtx, eventTable, doAction);
-                                    };
-                                    crDbCtx[_DYN_OPEN_CURSOR ] = function (eventTable, query, cursorFunc) {
-                                        return _openCursor(crDbCtx, eventTable, query, cursorFunc);
-                                    };
-                                }
-                                return crDbCtx;
-                            }
-                            function _databaseUpgrade(db, dbOpenRequest, ev) {
-                                _debugLog(dbName, "db upgrade called");
-                                var upgDbCtx = _createDbCtx(null, db, dbOpenRequest, true, true);
-                                if (!versionChangeFunc) {
-                                    try {
-                                        dbOpenRequest[_DYN_TRANSACTION ] && dbOpenRequest[_DYN_TRANSACTION ].abort();
-                                        dbOpenRequest.result && dbOpenRequest.result.close();
-                                    }
-                                    finally {
-                                        openReject(new Error(ErrorMessageDbUpgradeRequired));
-                                    }
-                                    return;
-                                }
-                                createdNewDb = true;
-                                doAwaitResponse(versionChangeFunc(upgDbCtx), function (response) {
-                                    if (!response[_DYN_REJECTED ]) {
-                                        _debugLog(upgDbCtx[_DYN_DB_NAME ], "on version change success");
-                                        if (!upgDbCtx.txn) {
-                                            upgDbCtx.txn = dbOpenRequest[_DYN_TRANSACTION ];
-                                            _debugLog(upgDbCtx[_DYN_DB_NAME ], "added open request");
-                                        }
-                                    }
-                                    else {
-                                        try {
-                                            dbOpenRequest[_DYN_TRANSACTION ] && dbOpenRequest[_DYN_TRANSACTION ].abort();
-                                        }
-                                        finally {
-                                            openReject(response[_DYN_REASON ]);
-                                        }
-                                    }
-                                });
-                            }
-                            function _databaseOpen(db, dbOpenRequest) {
-                                var opDbCtx = _getDbContext(dbName);
-                                opDbCtx.add(db);
-                                db.onabort = function (evt) {
-                                    _debugLog(dbName, "onabort -- closing the Db");
-                                    opDbCtx[_DYN_REMOVE ](db);
-                                };
-                                db[_DYN_ONERROR ] = function (evt) {
-                                    _debugLog(dbName, "onerror -- closing the Db");
-                                    opDbCtx[_DYN_REMOVE ](db);
-                                };
-                                db.onclose = function (evt) {
-                                    _debugLog(dbName, "onclose -- closing the Db");
-                                    opDbCtx[_DYN_REMOVE ](db);
-                                };
-                                db.onversionchange = function (evt) {
-                                    _debugLog(dbName, "onversionchange -- force closing the Db");
-                                    db.close();
-                                    opDbCtx[_DYN_REMOVE ](db);
-                                };
-                                var openDbCtx = null;
-                                var dbHdl = null;
-                                if (opDbCtx.dbHdl[_DYN_LENGTH ] > 0) {
-                                    dbHdl = opDbCtx[_DYN_DB_HDL ][0];
-                                }
-                                openDbCtx = _createDbCtx(opDbCtx, dbHdl, dbOpenRequest, createdNewDb);
-                                try {
-                                    doAwait(processFunc(openDbCtx), openResolve, openReject);
-                                }
-                                catch (e) {
-                                    openReject(e);
-                                }
-                            }
-                            var dbCtx = _getDbContext(dbName);
-                            if (_dbFactory == null) {
-                                openReject(new Error("No available storage factory"));
-                            }
-                            else if (dbCtx.isOpen()) {
-                                var openDbCtx = _createDbCtx(dbCtx, dbCtx.openHdl(), null, false);
-                                doAwait(processFunc(openDbCtx), openResolve, openReject);
-                            }
-                            else {
-                                var dbOpenRequest_1 = _dbFactory.open(dbName, dbVersion);
-                                if (!dbOpenRequest_1) {
-                                    throw new Error("missing API");
-                                }
-                                dbOpenRequest_1.onblocked = function (evt) {
-                                    _debugLog(dbName, "Db Open Blocked event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
-                                    openReject(new Error(ErrorMessageUnableToOpenDb));
-                                };
-                                dbOpenRequest_1[_DYN_ONERROR ] = function (evt) {
-                                    _debugLog(dbName, "Db Open Error event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
-                                    openReject(new Error(ErrorMessageUnableToOpenDb));
-                                };
-                                dbOpenRequest_1.onupgradeneeded = function (evt) {
-                                    _debugLog(dbName, "Db Open Create/Upgrade needed event [" + evtName + "]");
-                                    try {
-                                        var db = evt.target[Result] || dbOpenRequest_1.result;
-                                        if (!db) {
-                                            _debugLog(dbName, "no db");
-                                            openReject(new Error(ErrorMessageUnableToOpenDb));
-                                            return;
-                                        }
-                                        _databaseUpgrade(db, dbOpenRequest_1);
-                                    }
-                                    catch (e) {
-                                        _eventReject(dbName, ErrorMessageUnableToOpenDb, openReject, evtName)(e);
-                                    }
-                                };
-                                dbOpenRequest_1[_DYN_ONSUCCESS ] = function (evt) {
-                                    _debugLog(dbName, "Db Open sucess [" + evtName + "]");
-                                    var db = evt.target[Result];
-                                    if (!db) {
-                                        openReject(new Error(ErrorMessageUnableToOpenDb));
-                                        return;
-                                    }
-                                    _databaseOpen(db, dbOpenRequest_1);
-                                };
-                            }
+                _this["_getDbgPlgTargets"] = function () {
+                    return [_dbName, _endpoint, _maxStorageTime, _indexedDb];
+                };
+                _this[_DYN_SUPPORTS_SYNC_REQUES4 ] = function () {
+                    return false;
+                };
+                _this.getAllEvents = function (cnt) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return [];
+                    }
+                    return _openDb(function (dbCtx) {
+                        return createAsyncPromise(function (allEventsResolve, allEventsReject) {
+                            _getAllEvents(dbCtx, null, cnt)[_DYN_THEN ](function (values) {
+                                allEventsResolve(_getEvents(values));
+                            }, allEventsReject);
                         });
                     });
                 };
-                _this.closeDb = function (dbName) {
-                    _debugLog(dbName, "close db");
-                    _scheduleEvent(dbName, "closeDb", function (evtName) {
-                        var dbCtx = _getDbContext(dbName);
-                        var dbHdls = dbCtx[_DYN_DB_HDL ];
-                        var len = dbHdls[_DYN_LENGTH ];
-                        if (len > 0) {
-                            for (var lp = 0; lp < len; lp++) {
-                                dbHdls[lp].close();
-                            }
-                            dbCtx[_DYN_DB_HDL ] = [];
-                        }
-                        return 1;
-                    }).catch(function (reason) {
+                _this[_DYN_GET_NEXT_BATCH ] = function () {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return [];
+                    }
+                    return _openDb(function (dbCtx) {
+                        return createAsyncPromise(function (allEventsResolve, allEventsReject) {
+                            _getAllEvents(dbCtx, null, 1)[_DYN_THEN ](function (values) {
+                                allEventsResolve(_getEvents(values));
+                            }, allEventsReject);
+                        });
                     });
                 };
-                _this.deleteDb = function (dbName) {
-                    if (_dbFactory == null) {
-                        return false;
+                _this[_DYN_ADD_EVENT ] = function (key, item, itemCtx) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return item;
                     }
-                    return _scheduleEvent(dbName, "deleteDb", function (evtName) {
-                        var dbCtx = _getDbContext(dbName);
-                        var dbHdls = dbCtx[_DYN_DB_HDL ];
-                        var len = dbHdls[_DYN_LENGTH ];
-                        if (len > 0) {
-                            _debugLog(dbName, "Db is open [" + len + "] force closing");
-                            for (var lp = 0; lp < len; lp++) {
-                                dbHdls[lp].close();
-                            }
-                            dbCtx[_DYN_DB_HDL ] = [];
-                        }
-                        return createAsyncPromise(function (deleteResolve, deleteReject) {
-                            setTimeout(function () {
-                                try {
-                                    _debugLog(dbName, "[" + evtName + "] starting");
-                                    var dbRequest = _dbFactory.deleteDatabase(dbName);
-                                    dbRequest[_DYN_ONERROR ] = function (evt) {
-                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
-                                    };
-                                    dbRequest.onblocked = function (evt) {
-                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
-                                    };
-                                    dbRequest.onupgradeneeded = function (evt) {
-                                        deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
-                                    };
-                                    dbRequest[_DYN_ONSUCCESS ] = function (evt) {
-                                        _debugLog(dbName, "[" + evtName + "] complete");
-                                        deleteResolve(true);
+                    item.id = item.id || getTimeId();
+                    item[_DYN_CRITICAL_CNT ] = item[_DYN_CRITICAL_CNT ] || 0;
+                    return _openDb(function (dbCtx) {
+                        var eventKey = key || item.id;
+                        var dbItem = {
+                            id: eventKey,
+                            evt: item,
+                            tm: _getTime(),
+                            v: StoreVersion
+                        };
+                        return _addDbEvent(dbCtx, dbItem, true);
+                    });
+                };
+                _this[_DYN_REMOVE_EVENTS ] = function (evts) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return [];
+                    }
+                    var removedEvents = [];
+                    return createAsyncPromise(function (removeEventsResolve, removeEventsReject) {
+                        _openDb(function (dbCtx) {
+                            return dbCtx.openCursor(EventObjectStoreName, null, function (cursorState, value, values) {
+                                if (_getId(value.id, evts) !== -1) {
+                                    var deleteRequest = cursorState.cursor.delete();
+                                    deleteRequest[_DYN_ONERROR ] = _cursorContinueEvent(cursorState);
+                                    deleteRequest[_DYN_ONSUCCESS ] = function () {
+                                        removedEvents[_DYN_PUSH ](value.evt);
+                                        cursorState[_DYN_CONTINUE ]();
                                     };
-                                    _debugLog(dbName, "[" + evtName + "] started");
-                                }
-                                catch (e) {
-                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase + " - " + e));
+                                    return 1 ;
                                 }
-                            }, 0);
+                                return 0 ;
+                            });
+                        })[_DYN_THEN ](function () {
+                            removeEventsResolve(removedEvents);
+                        }, function (reason) {
+                            removeEventsResolve(removedEvents);
                         });
                     });
                 };
-                _this.getDbDetails = function (dbName) {
-                    return _scheduleEvent(dbName, "getDbDetails", function (evtName) {
-                        if (_dbFactory == null || !_dbFactory.databases) {
-                            return createAsyncRejectedPromise(new Error(ErrorMessageDbNotSupported));
-                        }
-                        return createAsyncPromise(function (databasesResolve, databasesReject) {
-                            var dbPromise = _dbFactory.databases();
-                            dbPromise[_DYN_THEN ](function (databases) {
-                                for (var lp = 0; lp < databases[_DYN_LENGTH ]; lp++) {
-                                    if (databases[lp][_DYN_NAME ] === dbName) {
-                                        databasesResolve(databases[lp]);
-                                        return;
-                                    }
-                                }
-                                databasesReject(new Error(ErrorMessageDbDoesNotExist));
-                            }, databasesReject);
+                _this[_DYN_CLEAR ] = function (disable) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
+                        return [];
+                    }
+                    return createAsyncPromise(function (clearResolve, clearReject) {
+                        _openDb(function (dbCtx) {
+                            return _deleteEvents(dbCtx, null, function (value) {
+                                return true;
+                            });
+                        })[_DYN_THEN ](function (values) {
+                            clearResolve(_getEvents(values));
+                        }, function (reason) {
+                            clearResolve([]);
                         });
-                    }, 2000);
+                    });
                 };
-                function _createStoreContext(openDbCtx, eventTable) {
-                    var dbHdl = openDbCtx.db || null;
-                    var tx = dbHdl && dbHdl[_DYN_TRANSACTION ](eventTable, DbReadWrite);
-                    if (tx) {
-                        tx.onabort = function () {
-                        };
-                        tx[_DYN_ONERROR ] = function () {
-                        };
-                        tx.oncomplete = function () {
-                            _debugLog(openDbCtx[_DYN_DB_NAME ], "txn.oncomplete");
-                        };
-                        return {
-                            db: openDbCtx,
-                            store: tx.objectStore(eventTable),
-                            tx: tx,
-                            tbl: eventTable,
-                            openCursor: function (query, processFunc) {
-                                return _openCursor(openDbCtx, eventTable, query, processFunc);
-                            },
-                            newTransaction: function (doAction) {
-                                return _openStore(openDbCtx, eventTable, doAction);
-                            }
-                        };
-                    }
-                    return null;
-                }
-                function _openStore(openDbCtx, eventTable, doAction) {
-                    if (!openDbCtx || !openDbCtx.db) {
-                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
-                    }
-                    try {
-                        var result = doAction(_createStoreContext(openDbCtx, eventTable));
-                        if (isPromiseLike(result)) {
-                            return result;
-                        }
-                        return createAsyncResolvedPromise(result);
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
-                    }
-                }
-                function _openCursor(openDbCtx, eventTable, query, processFunc) {
-                    if (!openDbCtx || !openDbCtx.db) {
-                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
-                    }
-                    var simpleQuery = null;
-                    if (query && isString(query)) {
-                        simpleQuery = new SimpleQuery(query);
-                    }
-                    else if (query && query.isMatch) {
-                        simpleQuery = query;
+                _this.clean = function (disable) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
+                        return false;
                     }
-                    return createAsyncPromise(function (openCursorResolve, openCursorReject) {
-                        var values = [];
-                        var cursorRequest = null;
-                        var queryKeyRange = null;
-                        if (simpleQuery && simpleQuery[_DYN_KEY_RANGE ]) {
-                            queryKeyRange = simpleQuery[_DYN_KEY_RANGE ]();
-                        }
-                        var storeCtx = _createStoreContext(openDbCtx, eventTable);
-                        if (queryKeyRange) {
-                            cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR ](queryKeyRange);
-                        }
-                        else {
-                            cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR ]();
-                        }
-                        cursorRequest[_DYN_ONERROR ] = _eventReject(storeCtx.db[_DYN_DB_NAME ], ErrorMessageFailedToOpenCursor, openCursorReject, "openCursor");
-                        cursorRequest[_DYN_ONSUCCESS ] = function (evt) {
-                            var _a;
-                            var cursor = evt.target[Result];
-                            if (!cursor) {
-                                openCursorResolve(values);
-                                return;
-                            }
-                            var processCursorState = (_a = {
-                                    store: storeCtx,
-                                    cursor: cursor
-                                },
-                                _a[_DYN_CONTINUE ] = function () {
-                                    cursor[_DYN_CONTINUE ]();
-                                },
-                                _a.done = function () {
-                                    openCursorResolve(values);
-                                }
-                            ,
-                                _a);
-                            var value = cursor[_DYN_VALUE ];
-                            if (simpleQuery && !simpleQuery.isMatch(value)) {
-                                processCursorState[_DYN_CONTINUE ]();
-                                return;
-                            }
-                            if (processFunc) {
-                                try {
-                                    switch (processFunc(processCursorState, value, values)) {
-                                        case 2 :
-                                            openCursorResolve(values);
-                                            break;
-                                        case 1 :
-                                            break;
-                                        case 0 :
-                                        default:
-                                            processCursorState[_DYN_CONTINUE ]();
-                                            break;
-                                    }
-                                }
-                                catch (ex) {
-                                    openCursorReject(ex);
-                                }
+                    return createAsyncPromise(function (cleanResolve, cleanReject) {
+                        _openDb(function (dbCtx) {
+                            if (dbCtx.isNew) {
+                                return [];
                             }
-                            else {
-                                values[_DYN_PUSH$1 ](value);
-                                processCursorState[_DYN_CONTINUE ]();
+                            return _dropMaxTimeEvents$1(dbCtx, _maxStorageTime);
+                        })[_DYN_THEN ](function (value) {
+                            var cnt = value && value[_DYN_LENGTH ];
+                            if (_notificationManager && cnt) {
+                                batchDropNotification(_notificationManager, cnt, 3 );
                             }
-                        };
+                            cleanResolve(cnt && cnt > 0);
+                        }, function (reason) {
+                            cleanResolve(false);
+                        });
                     });
-                }
-            });
-        }
-        IndexedDbHelper.__ieDyn=1;
-        return IndexedDbHelper;
-    }());
-    var SimpleQuery = /** @class */ (function () {
-        function SimpleQuery(theQuery) {
-            var _queryCols = [];
-            var _keyRange = null;
-            dynamicProto(SimpleQuery, this, function (_this) {
-                _this[_DYN_KEY_RANGE ] = function () {
-                    return _keyRange;
                 };
-                _this.parseQuery = function (query) {
-                    _queryCols = [];
-                    if (query) {
-                        var items = query[_DYN_SPLIT ](";");
-                        for (var lp = 0; lp < items[_DYN_LENGTH ]; lp++) {
-                            var item = items[lp];
-                            var idx = item[_DYN_INDEX_OF ]("=");
-                            if (idx !== -1) {
-                                var key = item[_DYN_SUBSTRING ](0, idx);
-                                var value = item[_DYN_SUBSTRING ](idx + 1);
-                                if (key[_DYN_INDEX_OF ]("#") === 0) {
-                                    key = key[_DYN_SUBSTRING ](1);
-                                    if (!_keyRange) {
-                                        _keyRange = IDBKeyRange.bound(value, value + "\uffff");
-                                    }
-                                }
-                                _this.startsWith(key, value);
-                            }
-                        }
+                _this[_DYN_TEARDOWN ] = function () {
+                    if (_indexedDb) {
+                        _indexedDb.closeDb(_dbName);
                     }
                 };
-                _this.startsWith = function (columnName, value) {
-                    var _a;
-                    _queryCols[_DYN_PUSH$1 ]((_a = {},
-                        _a[_DYN_NAME ] = columnName,
-                        _a[_DYN_VALUE ] = value,
-                        _a.type = 0 ,
-                        _a));
-                };
-                _this.contains = function (columnName, value) {
-                    var _a;
-                    _queryCols[_DYN_PUSH$1 ]((_a = {},
-                        _a[_DYN_NAME ] = columnName,
-                        _a[_DYN_VALUE ] = value,
-                        _a.type = 1 ,
-                        _a));
-                };
-                _this.isMatch = function (value) {
-                    if (!_queryCols || _queryCols[_DYN_LENGTH ] === 0) {
-                        return true;
+                function _openDb(processFunc) {
+                    function _handleDbUpgrade(dbCtx) {
+                        return createAsyncPromise(function (createResolve, createReject) {
+                            try {
+                                _createDb(dbCtx.db);
+                            }
+                            catch (e) {
+                                createReject(e);
+                            }
+                            createResolve();
+                        });
                     }
-                    if (!value) {
-                        return false;
+                    function _handleDbOpen(dbCtx) {
+                        return createAsyncPromise(function (openResolve, openReject) {
+                            var providerCtx = {
+                                iKey: _iKey,
+                                id: _endpoint,
+                                storageId: _storageId
+                            };
+                            dbCtx.ctx = providerCtx;
+                            doAwait(processFunc(dbCtx), openResolve, openReject);
+                        });
                     }
-                    for (var lp = 0; lp < _queryCols[_DYN_LENGTH ]; lp++) {
-                        var query = _queryCols[lp];
-                        var chkValue = value[query.name];
-                        if (chkValue) {
-                            if (query.type === 0 ) {
-                                if (chkValue.indexOf(query[_DYN_VALUE ]) !== 0) {
-                                    return false;
-                                }
-                            }
-                            else if (query.type === 1 ) {
-                                if (chkValue.indexOf(query[_DYN_VALUE ]) === -1) {
-                                    return false;
+                    return _indexedDb.openDb(_dbName, DbVersion, _handleDbOpen, _handleDbUpgrade);
+                }
+                function _addDbEvent(dbCtx, dbItem, doRetry) {
+                    return createAsyncPromise(function (addEventResolve, addEventReject) {
+                        function dropEvents(droppedFunc) {
+                            _dropEventsUpToPersistence$1(dbCtx, _maxCriticalCnt, _eventDropPerTime)[_DYN_THEN ](function (droppedCount) {
+                                if (_notificationManager && droppedCount) {
+                                    batchDropNotification(_notificationManager, droppedCount, 2 );
                                 }
-                            }
+                                droppedFunc(droppedCount);
+                            }, function (reason) {
+                                droppedFunc(0);
+                            });
+                        }
+                        function _insertNewEvent() {
+                            dbCtx[_DYN_OPEN_STORE ](EventObjectStoreName, function (storeCtx) {
+                                var request = storeCtx.store.put(dbItem);
+                                request[_DYN_ONSUCCESS ] = function (evt) {
+                                    addEventResolve(dbItem.evt);
+                                };
+                                request[_DYN_ONERROR ] = function (evt) {
+                                    if (!doRetry) {
+                                        addEventReject(new Error(ErrorMessageUnableToAddEvent));
+                                        return;
+                                    }
+                                    function _retryAddEvent(dropCount) {
+                                        if (dropCount === 0) {
+                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
+                                        }
+                                        _addDbEvent(dbCtx, dbItem, false)[_DYN_THEN ](function (theItem) {
+                                            addEventResolve(dbItem.evt);
+                                        }, function () {
+                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
+                                        });
+                                    }
+                                    dropEvents(function (droppedCount) {
+                                        if (droppedCount > 0) {
+                                            _retryAddEvent(droppedCount);
+                                        }
+                                        else {
+                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
+                                        }
+                                    });
+                                };
+                            }).catch(function (e) {
+                                addEventReject(e);
+                            });
                         }
-                    }
-                    return true;
-                };
-                if (theQuery) {
-                    _this.parseQuery(theQuery);
+                        _insertNewEvent();
+                    });
                 }
             });
         }
-        SimpleQuery.__ieDyn=1;
-        return SimpleQuery;
+        IndexedDbProvider.__ieDyn=1;
+        return IndexedDbProvider;
     }());
 
-    var EventsToDropAtOneTime = 10;
-    var StoreVersion = 1;
-    var OrhpanedEventThresholdInMs = 10080000;
-    var MaxSizeLimit = 5000000;
-    var UnknowniKey = "Unknown";
-    var ErrorMessageUnableToAddEvent = "DBError: Unable to add event";
-    var MaxCriticalEvtsDropCnt = 2;
-    var DefaultDbName = "AIOffline";
-    var DbVersion = 1;
-    var EventObjectStoreName = "Evts";
-    function isValidPersistenceLevel(value) {
-        return (isNumber(value) && value >= 0  && value <= EventPersistence.Critical);
+    function getEndpointDomain(endpoint) {
+        try {
+            var url = endpoint[_DYN_REPLACE ](/^https?:\/\/|^www\./, "");
+            url = url[_DYN_REPLACE ](/\?/, "/");
+            var arr = url[_DYN_SPLIT ]("/");
+            if (arr && arr[_DYN_LENGTH ] > 0) {
+                return arr[0];
+            }
+        }
+        catch (e) {
+        }
+        return endpoint;
     }
-    function _getTime() {
-        return new Date()[_DYN_GET_TIME ]();
+    function isGreaterThanZero(value) {
+        return value >= 0;
     }
-    function _createDb(db) {
-        if (!db.objectStoreNames.contains(EventObjectStoreName)) {
-            var evtStore = db.createObjectStore(EventObjectStoreName, { keyPath: "id" });
-            evtStore.createIndex("criticalCnt", "criticalCnt", { unique: false });
+    var _base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    function base64Encode(data) {
+        var line = "";
+        var input = "";
+        if (isString(data)) {
+            input = data;
         }
-    }
-    function _getEvents(values) {
-        var events = [];
-        for (var lp = 0; lp < values[_DYN_LENGTH ]; lp++) {
-            var item = values[lp];
-            if (item && item.evt) {
-                events[_DYN_PUSH$1 ](item.evt);
-            }
+        else {
+            input = data[_DYN_TO_STRING ]();
         }
-        return events;
-    }
-    function _addEventByTime(values, newValue) {
-        for (var idx = 0; idx < values[_DYN_LENGTH ]; idx++) {
-            if (newValue.tm < values[idx].tm) {
-                values[_DYN_SPLICE ](idx, 0, newValue);
-                return;
+        var output = "";
+        var chr1, chr2, chr3;
+        var lp = 0;
+        while (lp < input[_DYN_LENGTH ]) {
+            chr1 = input[_DYN_CHAR_CODE_AT ](lp++);
+            chr2 = input[_DYN_CHAR_CODE_AT ](lp++);
+            chr3 = input[_DYN_CHAR_CODE_AT ](lp++);
+            line += _base64[_DYN_CHAR_AT ](chr1 >> 2);
+            line += _base64[_DYN_CHAR_AT ](((chr1 & 3) << 4) | (chr2 >> 4));
+            if (isNaN(chr2)) {
+                line += "==";
+            }
+            else {
+                line += _base64[_DYN_CHAR_AT ](((chr2 & 15) << 2) | (chr3 >> 6));
+                line += isNaN(chr3) ? "=" : _base64[_DYN_CHAR_AT ](chr3 & 63);
             }
         }
-        values[_DYN_PUSH$1 ](newValue);
+        output += line;
+        return output;
     }
-    function _getId(key, values) {
-        var len = values[_DYN_LENGTH ];
-        for (var lp = 0; lp < len; lp++) {
-            if (key === values[lp].id) {
-                return lp;
+    function base64Decode(input) {
+        var output = "";
+        var chr1, chr2, chr3;
+        var enc1, enc2, enc3, enc4;
+        var i = 0;
+        input = input[_DYN_REPLACE ](/[^A-Za-z0-9\+\/\=]/g, "");
+        while (i < input[_DYN_LENGTH ]) {
+            enc1 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
+            enc2 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
+            enc3 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
+            enc4 = _base64[_DYN_INDEX_OF ](input[_DYN_CHAR_AT ](i++));
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+            output = output + String[_DYN_FROM_CHAR_CODE ](chr1);
+            if (enc3 != 64) {
+                output = output + String[_DYN_FROM_CHAR_CODE ](chr2);
+            }
+            if (enc4 != 64) {
+                output = output + String[_DYN_FROM_CHAR_CODE ](chr3);
             }
         }
-        return -1;
+        var arr = output[_DYN_SPLIT ](",").map(function (c) { return Number(c); });
+        return new Uint8Array(arr);
     }
-    function _cursorContinueEvent(cursorState, value) {
-        return function (evt) {
-            return cursorState[_DYN_CONTINUE ]();
-        };
+    function getTimeId() {
+        var time = (new Date())[_DYN_GET_TIME ]();
+        var random = strSubstr(generateW3CId(), 0, 8);
+        return time + "." + random;
     }
-    function _cursorDeleteAndContinue(cursorState, value) {
-        var deleteRequest = cursorState.cursor.delete();
-        deleteRequest[_DYN_ONERROR ] = _cursorContinueEvent(cursorState);
-        deleteRequest[_DYN_ONSUCCESS ] = _cursorContinueEvent(cursorState);
-        return 1 ;
+    function getTimeFromId(id) {
+        try {
+            var regex = new RegExp(/\d+\./g);
+            if (id && isString(id) && regex.test(id)) {
+                var arr = id[_DYN_SPLIT ](".");
+                return parseInt(arr[0]);
+            }
+        }
+        catch (e) {
+        }
+        return 0;
     }
-    function _getAllEvents(dbCtx, cursorQuery, cnt) {
-        return dbCtx.openCursor(EventObjectStoreName, cursorQuery, function (cursorState, value, values) {
-            values[_DYN_PUSH$1 ](value);
-            if (cnt && values && values[_DYN_LENGTH ] == cnt) {
-                return 2 ;
+    var EVT_DISCARD_STR = "eventsDiscarded";
+    var EVT_STORE_STR = "offlineEventsStored";
+    var EVT_SENT_STR = "offlineBatchSent";
+    var BATCH_DROP_STR = "offlineBatchDrop";
+    function forEachMap(map, callback, ordered) {
+        if (map) {
+            var keys = objKeys(map);
+            if (!!ordered && keys) {
+                var time_1 = (new Date())[_DYN_GET_TIME ]();
+                keys = keys.sort(function (a, b) {
+                    try {
+                        var aTime = getTimeFromId(a) || time_1;
+                        var bTime = getTimeFromId(b) || time_1;
+                        return aTime - bTime;
+                    }
+                    catch (e) {
+                    }
+                    return -1;
+                });
             }
-            return 0 ;
-        });
+            for (var lp = 0; lp < keys[_DYN_LENGTH ]; lp++) {
+                var key = keys[lp];
+                if (!callback(map[key], key)) {
+                    break;
+                }
+            }
+        }
     }
-    function _deleteEvents(dbCtx, eventPrefixQuery, shouldDelete) {
-        return dbCtx.openCursor(EventObjectStoreName, eventPrefixQuery, function (deleteCursorState, value, values) {
-            if (shouldDelete(value)) {
-                values[_DYN_PUSH$1 ](value);
-                return _cursorDeleteAndContinue(deleteCursorState);
+    function callNotification(mgr, evtName, theArgs) {
+        var manager = (mgr || {});
+        var notifyFunc = manager[evtName];
+        if (notifyFunc) {
+            try {
+                notifyFunc.apply(manager, theArgs);
             }
-            return 0 ;
-        });
+            catch (e) {
+            }
+        }
     }
-    function _dropMaxTimeEvents(dbCtx, maxTime) {
-        return createAsyncPromise(function (deleteEvtsResolve, deleteEvtsReject) {
-            return _deleteEvents(dbCtx, null, function (value) {
-                if (!value || !value.evt) {
-                    return true;
-                }
-                var addedTime = getTimeFromId(value.id);
-                var minStartTime = _getTime() + 1 - maxTime;
-                if (addedTime <= minStartTime) {
-                    return true;
+    function batchDropNotification(mgr, cnt, reason) {
+        if (mgr && cnt > 0) {
+            callNotification(mgr, BATCH_DROP_STR, [cnt, reason]);
+        }
+        return;
+    }
+
+    var PayloadHelper = /** @class */ (function () {
+        function PayloadHelper(logger) {
+            dynamicProto(PayloadHelper, this, function (_self) {
+                _self.base64ToArr = function (input) {
+                    if (!input || !input[_DYN_IS_ARR ]) {
+                        return input;
+                    }
+                    try {
+                        var data = input[_DYN_DATA ];
+                        if (data) {
+                            input[_DYN_DATA ] = base64Decode(data);
+                        }
+                        return input;
+                    }
+                    catch (e) {
+                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
+                    }
+                    return null;
+                };
+                _self.base64ToStr = function (item) {
+                    if (!item || !item[_DYN_IS_ARR ]) {
+                        return item;
+                    }
+                    try {
+                        var data = item[_DYN_DATA ];
+                        if (data) {
+                            item[_DYN_DATA ] = base64Encode(data);
+                        }
+                        return item;
+                    }
+                    catch (e) {
+                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
+                    }
+                    return null;
+                };
+            });
+        }
+        PayloadHelper.__ieDyn=1;
+        return PayloadHelper;
+    }());
+
+    var EventsToDropAtOneTime = 10;
+    var Version = "1";
+    var DefaultStorageKey = "AIOffline";
+    var DefaultMaxStorageSizeInBytes = 5000000;
+    var MaxCriticalEvtsDropCnt = 2;
+    var DefaultMaxInStorageTime = 10080000;
+    function _isQuotaExceeded(storage, e) {
+        var result = false;
+        if (e instanceof DOMException) {
+            if (e.code === 22 || e[_DYN_NAME ] === "QuotaExceededError" ||
+                e.code === 1014 || e[_DYN_NAME ] === "NS_ERROR_DOM_QUOTA_REACHED") {
+                if (storage && storage[_DYN_LENGTH ] !== 0) {
+                    result = true;
                 }
-                return false;
-            })[_DYN_THEN ](function (values) {
-                deleteEvtsResolve(values);
-            }, deleteEvtsReject);
-        });
+            }
+        }
+        return result;
     }
-    function _dropEventsUpToPersistence(dbCtx, maxpriorityCnt, maxDropCnt) {
-        return createAsyncPromise(function (dropEventsResolve, dropEventsReject) {
-            var droppedEvents = 0;
-            function _resolveWithDroppedEvents() {
-                dropEventsResolve(droppedEvents);
+    function _getAvailableStorage(type) {
+        var global = getGlobal() || {};
+        var storage = null;
+        try {
+            storage = (global[type]);
+            if (storage) {
+                var x = "__storage_test__";
+                storage.setItem(x, x);
+                storage[_DYN_REMOVE_ITEM ](x);
             }
-            function _dropEvent(deleteStoreCtx, dropItem) {
-                return createAsyncPromise(function (deleteResolve) {
-                    var deleteRequest = deleteStoreCtx.store.delete(dropItem.key);
-                    deleteRequest[_DYN_ONSUCCESS ] = function (evt) {
-                        droppedEvents++;
-                        deleteResolve();
-                    };
-                    deleteRequest[_DYN_ONERROR ] = function (evt) {
-                        deleteResolve();
-                    };
-                });
+        }
+        catch (e) {
+            if (!_isQuotaExceeded(storage, e)) {
+                storage = null;
             }
-            function _processCandidates(dropCandidates) {
-                if (dropCandidates[_DYN_LENGTH ] === 0) {
-                    _resolveWithDroppedEvents();
-                    return;
+        }
+        return storage;
+    }
+    function _dropEventsUpToPersistence(maxCnt, events, eventsToDropAtOneTime) {
+        var dropKeys = [];
+        var persistenceCnt = 0;
+        var droppedEvents = 0;
+        while (persistenceCnt <= maxCnt && droppedEvents < eventsToDropAtOneTime) {
+            forEachMap(events, function (evt, key) {
+                if (evt[_DYN_CRITICAL_CNT ] === persistenceCnt) {
+                    dropKeys[_DYN_PUSH ](key);
+                    droppedEvents++;
                 }
-                dbCtx[_DYN_OPEN_STORE ](EventObjectStoreName, function (deleteStoreCtx) {
-                    var deleteEvts = [];
-                    for (var lp = 0; lp < dropCandidates[_DYN_LENGTH ]; lp++) {
-                        deleteEvts[_DYN_PUSH$1 ](_dropEvent(deleteStoreCtx, dropCandidates[lp]));
-                    }
-                    return createAsyncAllPromise(deleteEvts)[_DYN_THEN ](_resolveWithDroppedEvents, _resolveWithDroppedEvents);
-                });
+                return (droppedEvents < eventsToDropAtOneTime);
+            });
+            if (droppedEvents > 0) {
+                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
+                    delete events[dropKeys[lp]];
+                }
+                return droppedEvents;
             }
-            var cursorPromise = dbCtx.openCursor(EventObjectStoreName, null, function (cursorState, value, values) {
-                if (value.evt[_DYN_CRITICAL_CNT ] <= maxpriorityCnt) {
-                    _addEventByTime(values, value);
-                    if (values[_DYN_LENGTH ] > maxDropCnt) {
-                        values.splice(values[_DYN_LENGTH ] - 1, 1);
-                    }
+            persistenceCnt++;
+        }
+        return droppedEvents;
+    }
+    function _dropMaxTimeEvents(maxStorageTime, events, eventsToDropAtOneTime, mgr) {
+        var dropKeys = [];
+        var droppedEvents = 0;
+        var currentTime = (new Date())[_DYN_GET_TIME ]() + 1;
+        var minStartTime = (currentTime - maxStorageTime);
+        try {
+            forEachMap(events, function (evt, key) {
+                var id = getTimeFromId(key);
+                if (id <= minStartTime) {
+                    dropKeys[_DYN_PUSH ](key);
+                    droppedEvents++;
                 }
-                return 0 ;
-            });
-            cursorPromise[_DYN_THEN ](_processCandidates, function () {
-                dropEventsResolve(0);
+                return (droppedEvents < eventsToDropAtOneTime);
             });
-        });
+            if (droppedEvents > 0) {
+                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
+                    delete events[dropKeys[lp]];
+                }
+                if (mgr) {
+                    batchDropNotification(mgr, droppedEvents, 3 );
+                }
+                return true;
+            }
+        }
+        catch (e) {
+        }
+        return droppedEvents > 0;
     }
-    var IndexedDbProvider = /** @class */ (function () {
-        function IndexedDbProvider(id, unloadHookContainer) {
-            dynamicProto(IndexedDbProvider, this, function (_this) {
-                var _indexedDb = null;
-                var _dbName = null;
-                var _iKey = UnknowniKey;
-                var _storageId = null;
-                var _autoClean = null;
+    var WebStorageProvider = /** @class */ (function () {
+        function WebStorageProvider(storageType, id, unloadHookContainer) {
+            dynamicProto(WebStorageProvider, this, function (_this) {
+                var _storage = null;
+                var _storageKeyPrefix = DefaultStorageKey;
+                var _maxStorageSizeInBytes = DefaultMaxStorageSizeInBytes;
+                var _payloadHelper = null;
+                var _storageKey = null;
                 var _endpoint = null;
-                var _storageKeyPrefix = null;
                 var _maxStorageTime = null;
                 var _eventDropPerTime = null;
                 var _maxCriticalCnt = null;
-                var _maxStorageSizeInBytes = null;
+                var _notificationManager = null;
                 _this.id = id;
-                _this[_DYN_INITIALIZE ] = function (providerContext) {
-                    var diagLog = providerContext.itemCtx[_DYN_DIAG_LOG ]();
-                    _indexedDb = new IndexedDbHelper(diagLog);
-                    if (!_indexedDb[_DYN_IS_AVAILABLE ]()) {
-                        _indexedDb = null;
+                _storage = _getAvailableStorage(storageType) || null;
+                _this["_getDbgPlgTargets"] = function () {
+                    return [_storageKey, _maxStorageSizeInBytes, _maxStorageTime];
+                };
+                _this[_DYN_INITIALIZE ] = function (providerContext, endpointUrl) {
+                    if (!_storage) {
                         return false;
                     }
-                    var coreConfig = providerContext[_DYN_ITEM_CTX ].getCfg();
-                    var itemCtx = providerContext[_DYN_ITEM_CTX ];
-                    _iKey = itemCtx.getCfg()[_DYN_INSTRUMENTATION_KEY ] || coreConfig[_DYN_INSTRUMENTATION_KEY ];
                     var storageConfig = providerContext[_DYN_STORAGE_CONFIG ];
-                    _storageId = _this.id || providerContext.id || newGuid();
-                    _endpoint = getEndpointDomain(providerContext[_DYN_ENDPOINT ]);
-                    _autoClean = !!storageConfig.autoClean;
-                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultDbName;
-                    _dbName = _storageKeyPrefix + "_" + DbVersion + "_" + _endpoint;
+                    var itemCtx = providerContext[_DYN_ITEM_CTX ];
+                    _payloadHelper = new PayloadHelper(itemCtx[_DYN_DIAG_LOG ]());
+                    _endpoint = getEndpointDomain(endpointUrl || providerContext[_DYN_ENDPOINT ]);
+                    var autoClean = !!storageConfig.autoClean;
+                    _notificationManager = providerContext[_DYN_NOTIFICATION_MGR ];
                     var unloadHook = onConfigChange(storageConfig, function () {
-                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || OrhpanedEventThresholdInMs;
-                        _maxStorageSizeInBytes = storageConfig[_DYN_MAX_STORAGE_SIZE_IN_2 ] || MaxSizeLimit;
-                        var dropNum = storageConfig[_DYN__EVENTS_TO_DROP_PER_3 ];
+                        _maxStorageSizeInBytes = storageConfig.maxStorageSizeInBytes || DefaultMaxStorageSizeInBytes;
+                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || DefaultMaxInStorageTime;
+                        var dropNum = storageConfig[_DYN__EVENTS_TO_DROP_PER_2 ];
                         _eventDropPerTime = isNotNullOrUndefined(dropNum) ? dropNum : EventsToDropAtOneTime;
-                        _maxCriticalCnt = storageConfig[_DYN_MAX_CRITICAL_EVTS_DR4 ] || MaxCriticalEvtsDropCnt;
+                        _maxCriticalCnt = storageConfig[_DYN_MAX_CRITICAL_EVTS_DR3 ] || MaxCriticalEvtsDropCnt;
                     });
                     unloadHookContainer && unloadHookContainer.add(unloadHook);
-                    if (_dbName) {
-                        doAwaitResponse(_this.clean(!_autoClean), function (response) {
-                            _openDb(function (dbCtx) {
-                                return true;
-                            })[_DYN_THEN ](function (value) {
-                            }, function (reason) {
-                                diagLog.warnToConsole("IndexedDbProvider failed to initialize - " + (reason || "<unknown>"));
-                                _indexedDb = null;
-                            });
-                        });
+                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultStorageKey;
+                    _storageKey = _storageKeyPrefix + "_" + Version + "_" + _endpoint;
+                    if (autoClean) {
+                        _this.clean();
                     }
                     return true;
                 };
-                _this["_getDbgPlgTargets"] = function () {
-                    return [_dbName, _maxStorageSizeInBytes, _maxStorageTime, _indexedDb];
-                };
-                _this[_DYN_SUPPORTS_SYNC_REQUES5 ] = function () {
-                    return false;
+                _this[_DYN_SUPPORTS_SYNC_REQUES4 ] = function () {
+                    return true;
                 };
                 _this.getAllEvents = function (cnt) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
-                        return [];
+                    try {
+                        if (!_storage) {
+                            return;
+                        }
+                        return _getEvts(cnt);
+                    }
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
                     }
-                    return _openDb(function (dbCtx) {
-                        return createAsyncPromise(function (allEventsResolve, allEventsReject) {
-                            _getAllEvents(dbCtx, null, cnt)[_DYN_THEN ](function (values) {
-                                allEventsResolve(_getEvents(values));
-                            }, allEventsReject);
-                        });
-                    });
                 };
                 _this[_DYN_GET_NEXT_BATCH ] = function () {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
-                        return [];
+                    try {
+                        if (!_storage) {
+                            return;
+                        }
+                        return _getEvts(1, true);
                     }
-                    return _openDb(function (dbCtx) {
-                        return createAsyncPromise(function (allEventsResolve, allEventsReject) {
-                            _getAllEvents(dbCtx, null, 1)[_DYN_THEN ](function (values) {
-                                allEventsResolve(_getEvents(values));
-                            }, allEventsReject);
-                        });
-                    });
-                };
-                _this[_DYN_ADD_EVENT ] = function (key, item, itemCtx) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
-                        return item;
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
                     }
-                    item.id = item.id || getTimeId();
-                    item[_DYN_CRITICAL_CNT ] = item[_DYN_CRITICAL_CNT ] || 0;
-                    return _openDb(function (dbCtx) {
-                        var eventKey = key || item.id;
-                        var dbItem = {
-                            id: eventKey,
-                            evt: item,
-                            tm: _getTime(),
-                            v: StoreVersion
-                        };
-                        return _addDbEvent(dbCtx, dbItem, true);
-                    });
                 };
-                _this[_DYN_REMOVE_EVENTS ] = function (evts) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
-                        return [];
+                function _getEvts(cnt, ordered) {
+                    var allItems = [];
+                    var theStore = _fetchStoredDb(_storageKey).db;
+                    if (theStore) {
+                        var events = theStore[_DYN_EVTS ];
+                        forEachMap(events, function (evt) {
+                            if (evt) {
+                                if (evt[_DYN_IS_ARR ]) {
+                                    evt = _payloadHelper.base64ToArr(evt);
+                                }
+                                allItems[_DYN_PUSH ](evt);
+                            }
+                            if (cnt && allItems && allItems[_DYN_LENGTH ] == cnt) {
+                                return false;
+                            }
+                            return true;
+                        }, ordered);
                     }
-                    var removedEvents = [];
-                    return createAsyncPromise(function (removeEventsResolve, removeEventsReject) {
-                        _openDb(function (dbCtx) {
-                            return dbCtx.openCursor(EventObjectStoreName, null, function (cursorState, value, values) {
-                                if (_getId(value.id, evts) !== -1) {
-                                    var deleteRequest = cursorState.cursor.delete();
-                                    deleteRequest[_DYN_ONERROR ] = _cursorContinueEvent(cursorState);
-                                    deleteRequest[_DYN_ONSUCCESS ] = function () {
-                                        removedEvents[_DYN_PUSH$1 ](value.evt);
-                                        cursorState[_DYN_CONTINUE ]();
-                                    };
-                                    return 1 ;
+                    return allItems;
+                }
+                _this[_DYN_ADD_EVENT ] = function (key, evt, itemCtx) {
+                    try {
+                        var theStore = _fetchStoredDb(_storageKey);
+                        evt.id = evt.id || getTimeId();
+                        evt[_DYN_CRITICAL_CNT ] = evt[_DYN_CRITICAL_CNT ] || 0;
+                        var events = theStore.db[_DYN_EVTS ];
+                        var id_1 = evt.id;
+                        if (evt && evt[_DYN_IS_ARR ]) {
+                            evt = _payloadHelper.base64ToStr(evt);
+                        }
+                        var preDroppedCnt = 0;
+                        while (evt) {
+                            events[id_1] = evt;
+                            if (_updateStoredDb(theStore)) {
+                                if (preDroppedCnt && _notificationManager) {
+                                    batchDropNotification(_notificationManager, preDroppedCnt, 2 );
                                 }
-                                return 0 ;
-                            });
-                        })[_DYN_THEN ](function () {
-                            removeEventsResolve(removedEvents);
-                        }, function (reason) {
-                            removeEventsResolve(removedEvents);
-                        });
-                    });
+                                return evt;
+                            }
+                            delete events[id_1];
+                            var droppedCnt = _dropEventsUpToPersistence(_maxCriticalCnt, events, _eventDropPerTime);
+                            preDroppedCnt += droppedCnt;
+                            if (!droppedCnt) {
+                                return createAsyncRejectedPromise(new Error("Unable to free up event space"));
+                            }
+                        }
+                    }
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
+                    }
                 };
-                _this.clear = function (disable) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
-                        return [];
+                _this[_DYN_REMOVE_EVENTS ] = function (evts) {
+                    try {
+                        var theStore = _fetchStoredDb(_storageKey, false);
+                        var currentDb = theStore.db;
+                        if (currentDb) {
+                            var events = currentDb[_DYN_EVTS ];
+                            try {
+                                for (var i = 0; i < evts[_DYN_LENGTH ]; ++i) {
+                                    var evt = evts[i];
+                                    delete events[evt.id];
+                                }
+                                if (_updateStoredDb(theStore)) {
+                                    return evts;
+                                }
+                            }
+                            catch (e) {
+                            }
+                            evts = _clearDatabase(theStore.key);
+                        }
+                        return evts;
                     }
-                    return createAsyncPromise(function (clearResolve, clearReject) {
-                        _openDb(function (dbCtx) {
-                            return _deleteEvents(dbCtx, null, function (value) {
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
+                    }
+                };
+                _this[_DYN_CLEAR ] = function () {
+                    try {
+                        var removedItems_1 = [];
+                        var theStore = _fetchStoredDb(_storageKey, false);
+                        var storedDb = theStore.db;
+                        if (storedDb) {
+                            var events_1 = storedDb[_DYN_EVTS ];
+                            forEachMap(events_1, function (evt) {
+                                if (evt) {
+                                    delete events_1[evt.id];
+                                    removedItems_1[_DYN_PUSH ](evt);
+                                }
                                 return true;
                             });
-                        })[_DYN_THEN ](function (values) {
-                            clearResolve(_getEvents(values));
-                        }, function (reason) {
-                            clearResolve([]);
-                        });
-                    });
+                            _updateStoredDb(theStore);
+                        }
+                        return removedItems_1;
+                    }
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
+                    }
                 };
-                _this.clean = function (disable) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
+                _this.clean = function () {
+                    var storeDetails = _fetchStoredDb(_storageKey, false);
+                    var currentDb = storeDetails.db;
+                    if (currentDb) {
+                        var events = currentDb[_DYN_EVTS ];
+                        try {
+                            var isDropped = _dropMaxTimeEvents(_maxStorageTime, events, _eventDropPerTime, _notificationManager);
+                            if (isDropped) {
+                                return _updateStoredDb(storeDetails);
+                            }
+                            return true;
+                        }
+                        catch (e) {
+                        }
                         return false;
                     }
-                    return createAsyncPromise(function (cleanResolve, cleanReject) {
-                        _openDb(function (dbCtx) {
-                            if (dbCtx.isNew) {
-                                return [];
-                            }
-                            return _dropMaxTimeEvents(dbCtx, _maxStorageTime);
-                        })[_DYN_THEN ](function (value) {
-                            cleanResolve(value && value[_DYN_LENGTH ] > 0);
-                        }, function (reason) {
-                            cleanResolve(false);
-                        });
-                    });
                 };
                 _this[_DYN_TEARDOWN ] = function () {
-                    if (_indexedDb) {
-                        _indexedDb.closeDb(_dbName);
+                    try {
+                        var theStore = _fetchStoredDb(_storageKey, false);
+                        var storedDb = theStore.db;
+                        if (storedDb) {
+                            storedDb[_DYN_LAST_ACCESS_TIME ] = 0;
+                            _updateStoredDb(theStore, false);
+                        }
+                    }
+                    catch (e) {
                     }
                 };
-                function _openDb(processFunc) {
-                    function _handleDbUpgrade(dbCtx) {
-                        return createAsyncPromise(function (createResolve, createReject) {
+                function _newStore(dbKey, db) {
+                    return {
+                        key: dbKey,
+                        db: db
+                    };
+                }
+                function _fetchStoredDb(dbKey, returnDefault) {
+                    var _a;
+                    if (returnDefault === void 0) { returnDefault = true; }
+                    var dbToStore = null;
+                    if (_storage) {
+                        var previousDb = _storage.getItem(dbKey);
+                        if (previousDb) {
                             try {
-                                _createDb(dbCtx.db);
+                                dbToStore = getJSON().parse(previousDb);
                             }
                             catch (e) {
-                                createReject(e);
+                                _storage[_DYN_REMOVE_ITEM ](dbKey);
                             }
-                            createResolve();
-                        });
+                        }
+                        if (returnDefault && !dbToStore) {
+                            dbToStore = (_a = {
+                                    evts: {}
+                                },
+                                _a[_DYN_LAST_ACCESS_TIME ] = 0,
+                                _a);
+                        }
                     }
-                    function _handleDbOpen(dbCtx) {
-                        return createAsyncPromise(function (openResolve, openReject) {
-                            var providerCtx = {
-                                iKey: _iKey,
-                                id: _endpoint,
-                                storageId: _storageId
-                            };
-                            dbCtx.ctx = providerCtx;
-                            doAwait(processFunc(dbCtx), openResolve, openReject);
-                        });
+                    return _newStore(dbKey, dbToStore);
+                }
+                function _updateStoredDb(jsonStore, updateLastAccessTime) {
+                    if (updateLastAccessTime === void 0) { updateLastAccessTime = true; }
+                    var dbToStore = jsonStore.db;
+                    if (dbToStore) {
+                        if (updateLastAccessTime) {
+                            dbToStore.lastAccessTime = (new Date())[_DYN_GET_TIME ]();
+                        }
                     }
-                    return _indexedDb.openDb(_dbName, DbVersion, _handleDbOpen, _handleDbUpgrade);
+                    try {
+                        var jsonString = getJSON().stringify(dbToStore);
+                        if (jsonString[_DYN_LENGTH ] > _maxStorageSizeInBytes) {
+                            return false;
+                        }
+                        _storage && _storage.setItem(jsonStore.key, jsonString);
+                    }
+                    catch (e) {
+                        return false;
+                    }
+                    return true;
                 }
-                function _addDbEvent(dbCtx, dbItem, doRetry) {
-                    return createAsyncPromise(function (addEventResolve, addEventReject) {
-                        function dropEvents(droppedFunc) {
-                            _dropEventsUpToPersistence(dbCtx, _maxCriticalCnt, _eventDropPerTime)[_DYN_THEN ](function (droppedCount) {
-                                droppedFunc(droppedCount);
-                            }, function (reason) {
-                                droppedFunc(0);
+                function _clearDatabase(dbKey) {
+                    var removedItems = [];
+                    var storeDetails = _fetchStoredDb(dbKey, false);
+                    var currentDb = storeDetails.db;
+                    if (currentDb) {
+                        var events = currentDb[_DYN_EVTS ];
+                        try {
+                            forEachMap(events, function (evt) {
+                                if (evt) {
+                                    removedItems[_DYN_PUSH ](evt);
+                                }
+                                return true;
                             });
                         }
-                        function _insertNewEvent() {
-                            dbCtx[_DYN_OPEN_STORE ](EventObjectStoreName, function (storeCtx) {
-                                var request = storeCtx.store.put(dbItem);
-                                request[_DYN_ONSUCCESS ] = function (evt) {
-                                    addEventResolve(dbItem.evt);
-                                };
-                                request[_DYN_ONERROR ] = function (evt) {
-                                    if (!doRetry) {
-                                        addEventReject(new Error(ErrorMessageUnableToAddEvent));
-                                        return;
-                                    }
-                                    function _retryAddEvent(dropCount) {
-                                        if (dropCount === 0) {
-                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
-                                        }
-                                        _addDbEvent(dbCtx, dbItem, false)[_DYN_THEN ](function (theItem) {
-                                            addEventResolve(dbItem.evt);
-                                        }, function () {
-                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
-                                        });
-                                    }
-                                    dropEvents(function (droppedCount) {
-                                        if (droppedCount > 0) {
-                                            _retryAddEvent(droppedCount);
-                                        }
-                                        else {
-                                            addEventReject(new Error(ErrorMessageUnableToAddEvent));
-                                        }
-                                    });
-                                };
-                            }).catch(function (e) {
-                                addEventReject(e);
-                            });
+                        catch (e) {
                         }
-                        _insertNewEvent();
-                    });
+                        _storage && _storage[_DYN_REMOVE_ITEM ](storeDetails.key);
+                    }
+                    return removedItems;
                 }
             });
         }
-        IndexedDbProvider.__ieDyn=1;
-        return IndexedDbProvider;
+        WebStorageProvider.__ieDyn=1;
+        return WebStorageProvider;
     }());
 
     var MaxStorageProviderConfig = 2;
@@ -5412,7 +5475,7 @@
                         if (!_provider) {
                             reject(new Error(NoProviderErrMsg));
                         }
-                        return doAwaitResponse(_provider.clear(), function (response) {
+                        return doAwaitResponse(_provider[_DYN_CLEAR ](), function (response) {
                             try {
                                 var cnt = 0;
                                 if (!response[_DYN_REJECTED ]) {
@@ -5524,13 +5587,13 @@
                     if (!isNullOrUndefined(evtsLimitInMem) && _self[_DYN_COUNT ]() >= evtsLimitInMem) {
                         return false;
                     }
-                    _buffer[_DYN_PUSH$1 ](payload);
+                    _buffer[_DYN_PUSH ](payload);
                     return true;
                 };
                 _self[_DYN_COUNT ] = function () {
                     return _buffer[_DYN_LENGTH ];
                 };
-                _self.clear = function () {
+                _self[_DYN_CLEAR ] = function () {
                     _buffer = [];
                 };
                 _self[_DYN_GET_ITEMS ] = function () {
@@ -5983,7 +6046,7 @@
         return Sender;
     }());
 
-    var version = '0.1.1-nightly3.2402-20';
+    var version = '0.1.1-nightly3.2403-01';
     var DefaultOfflineIdentifier = "OfflineChannel";
     var DefaultBatchInterval = 15000;
     var DefaultInMemoMaxTime = 15000;
@@ -6035,6 +6098,7 @@
                 var _primaryChannelId;
                 var _overrideIkey;
                 var _evtsLimitInMemo;
+                var _notificationManager;
                 _initDefaults();
                 _self[_DYN_INITIALIZE ] = function (coreConfig, core, extensions, pluginChain) {
                     if (!_hasInitialized) {
@@ -6044,21 +6108,26 @@
                         var evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineSender"), core.evtNamespace && core.evtNamespace());
                         _offlineListener = createOfflineListener(evtNamespace);
                         _taskScheduler = createTaskScheduler(createAsyncPromise, "offline channel");
+                        _notificationManager = core.getNotifyMgr();
                     }
-                    _createUrlConfig(coreConfig, core, extensions, pluginChain);
-                    var ctx = _getCoreItemCtx(coreConfig, core, extensions, pluginChain);
-                    _sender[_DYN_INITIALIZE ](coreConfig, core, ctx, _diagLogger, _primaryChannelId, _self._unloadHooks);
-                    if (_sender) {
-                        _senderInst = _sender.getXhrInst();
-                        _offlineListener.addListener(function (val) {
-                            if (!val[_DYN_IS_ONLINE ]) {
-                                _sendNextBatchTimer && _sendNextBatchTimer[_DYN_CANCEL ]();
-                            }
-                            else {
-                                _sendNextBatchTimer && _sendNextBatchTimer[_DYN_REFRESH ]();
-                            }
-                        });
-                        _setSendNextTimer();
+                    try {
+                        _createUrlConfig(coreConfig, core, extensions, pluginChain);
+                        var ctx = _getCoreItemCtx(coreConfig, core, extensions, pluginChain);
+                        _sender[_DYN_INITIALIZE ](coreConfig, core, ctx, _diagLogger, _primaryChannelId, _self._unloadHooks);
+                        if (_sender) {
+                            _senderInst = _sender.getXhrInst();
+                            _offlineListener.addListener(function (val) {
+                                if (!val[_DYN_IS_ONLINE ]) {
+                                    _sendNextBatchTimer && _sendNextBatchTimer[_DYN_CANCEL ]();
+                                }
+                                else {
+                                    _setSendNextTimer();
+                                }
+                            });
+                            _setSendNextTimer();
+                        }
+                    }
+                    catch (e) {
                     }
                 };
                 _self.processTelemetry = function (evt, itemCtx) {
@@ -6089,11 +6158,15 @@
                                     _flushInMemoItems();
                                     var retry = _inMemoBatch[_DYN_ADD_EVENT ](evt);
                                     if (!retry) {
+                                        _evtDropNotification([evt], EventsDiscardedReason.QueueFull);
                                         _throwInternal(_diagLogger, 2 , 105 , "Maximum offline in-memory buffer size reached", true);
                                     }
                                 }
                                 _setupInMemoTimer();
                             }
+                            else {
+                                _evtDropNotification([item], EventsDiscardedReason.InvalidEvent);
+                            }
                             return;
                         }
                     }
@@ -6113,23 +6186,23 @@
                     _setupInMemoTimer();
                     _setSendNextTimer();
                 };
-                _self.onunloadFlush = function () {
+                _self[_DYN_ONUNLOAD_FLUSH ] = function () {
                     if (!_paused) {
-                        var shouldContinue = true;
-                        while (_inMemoBatch[_DYN_COUNT ]() && shouldContinue) {
-                            shouldContinue = _flushInMemoItems(true);
+                        while (_inMemoBatch[_DYN_COUNT ]()) {
+                            _flushInMemoItems(true);
                         }
                     }
                 };
                 _self.flush = function (sync, callBack, sendReason) {
+                    return _self[_DYN_ONUNLOAD_FLUSH ]();
                 };
                 _self.getOfflineListener = function () {
                     return _offlineListener;
                 };
                 _self._doTeardown = function (unloadCtx, unloadState) {
-                    _self.onunloadFlush();
+                    _self[_DYN_ONUNLOAD_FLUSH ]();
                     _offlineListener && runTargetUnload(_offlineListener, false);
-                    var handler = _urlCfg.batchHandler;
+                    var handler = _urlCfg[_DYN_BATCH_HANDLER ];
                     handler && handler[_DYN_TEARDOWN ]();
                     _clearScheduledTimer();
                     _initDefaults();
@@ -6202,7 +6275,7 @@
                                 criticalCnt_1++;
                             }
                             idx_1 = index;
-                            payloadArr_1[_DYN_PUSH$1 ](payload);
+                            payloadArr_1[_DYN_PUSH ](payload);
                         });
                         if (!payloadArr_1[_DYN_LENGTH ]) {
                             return;
@@ -6211,15 +6284,27 @@
                         _inMemoBatch = _inMemoBatch.createNew(_endpoint, inMemo[_DYN_GET_ITEMS ]().slice(idx_1 + 1), _evtsLimitInMemo);
                         var payloadData = _constructPayloadData(payloadArr_1, criticalCnt_1);
                         var callback = function (res) {
-                            if (res[_DYN_STATE ] == 2 ) {
-                                arrForEach(sentItems_1, function (item) {
-                                    _inMemoBatch[_DYN_ADD_EVENT ](item);
-                                });
-                                _setupInMemoTimer();
+                            if (!res || !res[_DYN_STATE ]) {
+                                return null;
+                            }
+                            var state = res[_DYN_STATE ];
+                            if (state == 2 ) {
+                                if (!unload) {
+                                    arrForEach(sentItems_1, function (item) {
+                                        _inMemoBatch[_DYN_ADD_EVENT ](item);
+                                    });
+                                    _setupInMemoTimer();
+                                }
+                                else {
+                                    _evtDropNotification(sentItems_1, EventsDiscardedReason.NonRetryableStatus);
+                                }
+                            }
+                            else {
+                                _storeNotification(sentItems_1);
                             }
                         };
                         if (payloadData) {
-                            var promise = _urlCfg.batchHandler.storeBatch(payloadData, callback, unload);
+                            var promise = _urlCfg[_DYN_BATCH_HANDLER ].storeBatch(payloadData, callback, unload);
                             _queueStorageEvent("storeBatch", promise);
                         }
                         if (!_inMemoBatch[_DYN_COUNT ]()) {
@@ -6248,10 +6333,14 @@
                                         }
                                         var data = res && res[_DYN_DATA ];
                                         if (state === 1  && data) {
+                                            _sentNotification(data);
                                             _sendNextBatchTimer && _sendNextBatchTimer[_DYN_REFRESH ]();
                                         }
+                                        if (state === 3 ) {
+                                            batchDropNotification(_notificationManager, 1, 1 );
+                                        }
                                     };
-                                    var promise = _urlCfg.batchHandler.sendNextBatch(callback, false, _senderInst);
+                                    var promise = _urlCfg[_DYN_BATCH_HANDLER ].sendNextBatch(callback, false, _senderInst);
                                     _queueStorageEvent("sendNextBatch", promise);
                                 }
                             }
@@ -6346,7 +6435,7 @@
                         var ctx = createProcessTelemetryContext(null, theConfig, core);
                         storageConfig = ctx.getExtCfg(_self.identifier, defaultOfflineChannelConfig);
                         var channelIds = storageConfig.primaryOnlineChannelId;
-                        var onlineUrl = _endpoint;
+                        var onlineUrl = null;
                         if (channelIds && channelIds[_DYN_LENGTH ]) {
                             arrForEach(channelIds, function (id) {
                                 var plugin = _self.core.getPlugin(id);
@@ -6363,15 +6452,22 @@
                         }
                         _overrideIkey = storageConfig[_DYN_OVERRIDE_INSTRUMENTA1 ];
                         var urlConfig = _urlCfg;
-                        var curUrl = onlineUrl || coreConfig.endpointUrl;
+                        var curUrl = onlineUrl || coreConfig.endpointUrl || _endpoint;
                         if (curUrl !== _endpoint) {
                             var coreRootCtx = _getCoreItemCtx(coreConfig, core, extensions, pluginChain);
                             var providerContext = {
                                 itemCtx: coreRootCtx,
                                 storageConfig: storageConfig,
                                 id: _self.id,
-                                endpoint: curUrl
+                                endpoint: curUrl,
+                                notificationMgr: _notificationManager
                             };
+                            var oriHandler = _urlCfg && _urlCfg[_DYN_BATCH_HANDLER ];
+                            try {
+                                oriHandler && oriHandler[_DYN_TEARDOWN ]();
+                            }
+                            catch (e) {
+                            }
                             var handler = new OfflineBatchHandler(_self[_DYN_DIAG_LOG ](), _self._unloadHooks);
                             handler[_DYN_INITIALIZE ](providerContext);
                             urlConfig = {
@@ -6383,7 +6479,13 @@
                                 batchHandler: handler
                             };
                             _evtsLimitInMemo = storageConfig.eventsLimitInMem;
-                            _inMemoBatch = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, null, _evtsLimitInMemo);
+                            var evts = null;
+                            var curEvts = _inMemoBatch && _inMemoBatch[_DYN_GET_ITEMS ]();
+                            if (curEvts && curEvts[_DYN_LENGTH ]) {
+                                evts = curEvts.slice(0);
+                                _inMemoBatch[_DYN_CLEAR ]();
+                            }
+                            _inMemoBatch = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, evts, _evtsLimitInMemo);
                             _inMemoTimerOut = storageConfig.inMemoMaxTime;
                             var onlineConfig = ctx.getExtCfg(_primaryChannelId, {}) || {};
                             _convertUndefined = onlineConfig.convertUndefined;
@@ -6393,8 +6495,30 @@
                             _maxBatchSize = storageConfig.maxBatchsize;
                         }
                         _urlCfg = urlConfig;
+                        _endpoint = curUrl;
                     }));
                 }
+                function _callNotification(evtName, theArgs) {
+                    callNotification(_notificationManager, evtName, theArgs);
+                }
+                function _evtDropNotification(events, reason) {
+                    if (events && events[_DYN_LENGTH ]) {
+                        _callNotification(EVT_DISCARD_STR, [events, reason]);
+                    }
+                    return;
+                }
+                function _sentNotification(batch) {
+                    if (batch && batch[_DYN_DATA ]) {
+                        _callNotification(EVT_SENT_STR, [batch]);
+                    }
+                    return;
+                }
+                function _storeNotification(events) {
+                    if (events && events[_DYN_LENGTH ]) {
+                        _callNotification(EVT_STORE_STR, [events]);
+                    }
+                    return;
+                }
             });
             return _this;
         }