@microsoft/applicationinsights-offlinechannel-js 0.3.1-nightly3.2407-06 → 0.3.1-nightly3.2407-08

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Offline Channel, 0.3.1-nightly3.2407-06
+ * Application Insights JavaScript SDK - Offline Channel, 0.3.1-nightly3.2407-08
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1980,7 +1980,7 @@
         return result;
     }
 
-    var version$1 = '3.3.1-nightly3.2407-06';
+    var version$1 = '3.3.1-nightly3.2407-08';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -4398,1435 +4398,1435 @@
     var _DYN_EVTS = "evts";
     var _DYN_LAST_ACCESS_TIME = "lastAccessTime";
 
-    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;
+    function isValidPersistenceLevel(value) {
+        return (isNumber(value) && value >= 0  && value <= EventPersistence.Critical);
+    }
+    function getEndpointDomain(endpoint) {
+        try {
+            var url = endpoint.replace(/^https?:\/\/|^www\./, "");
+            url = url.replace(/\?/, "/");
+            var arr = url[_DYN_SPLIT ]("/");
+            if (arr && arr[_DYN_LENGTH ] > 0) {
+                return arr[0];
             }
         }
-        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;
+        catch (e) {
+        }
+        return endpoint;
     }
-    function _scheduleEvent(dbName, actionName, startEvent, evtTimeOut) {
-        var dbCtx = _getDbContext(dbName);
-        return dbCtx.sch.queue(startEvent, actionName, evtTimeOut);
+    function isGreaterThanZero(value) {
+        return value >= 0;
     }
-    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;
+    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 += "==";
+            }
+            else {
+                line += _base64[_DYN_CHAR_AT ](((chr2 & 15) << 2) | (chr3 >> 6));
+                line += isNaN(chr3) ? "=" : _base64[_DYN_CHAR_AT ](chr3 & 63);
+            }
+        }
+        output += line;
+        return output;
+    }
+    function base64Decode(input) {
+        var output = "";
+        var chr1, chr2, chr3;
+        var enc1, enc2, enc3, enc4;
+        var i = 0;
+        input = input.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 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;
+                });
+            }
+            for (var lp = 0; lp < keys[_DYN_LENGTH ]; lp++) {
+                var key = keys[lp];
+                if (!callback(map[key], key)) {
+                    break;
                 }
             }
+        }
+    }
+    function callNotification(mgr, evtName, theArgs) {
+        var manager = (mgr || {});
+        var notifyFunc = manager[evtName];
+        if (notifyFunc) {
+            try {
+                notifyFunc.apply(manager, theArgs);
+            }
             catch (e) {
-                dbFactory = null;
             }
         }
-        return dbFactory;
     }
-    function _debugLog(dbName, message) {
-        if (getInst("QUnit")) {
-            console && console.log("IndexedDbHelper [" + dbName + "] " + message);
+    function batchDropNotification(mgr, cnt, reason) {
+        if (mgr && cnt > 0) {
+            callNotification(mgr, BATCH_DROP_STR, [cnt, reason]);
         }
+        return;
     }
-    function _eventReject(dbName, rejectMessage, rejectFunc, evtName) {
-        return function (evt) {
-            rejectFunc(new Error(rejectMessage));
-            _debugLog(dbName, "[" + evtName + "] event rejected");
-        };
-    }
-    var IndexedDbHelper = /** @class */ (function () {
-        function IndexedDbHelper(diagLog) {
-            var _dbFactory = getDbFactory() || null;
-            dynamicProto(IndexedDbHelper, this, function (_this) {
-                _this[_DYN_IS_AVAILABLE ] = function () {
-                    return !!_dbFactory;
+
+    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;
                 };
-                _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.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.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.deleteDb = function (dbName) {
-                    if (_dbFactory == null) {
-                        return false;
-                    }
-                    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);
-                                    };
-                                    _debugLog(dbName, "[" + evtName + "] started");
-                                }
-                                catch (e) {
-                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase + " - " + e));
-                                }
-                            }, 0);
-                        });
-                    });
-                };
-                _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);
-                        });
-                    }, 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));
+                _self.base64ToStr = function (item) {
+                    if (!item || !item[_DYN_IS_ARR ]) {
+                        return item;
                     }
                     try {
-                        var result = doAction(_createStoreContext(openDbCtx, eventTable));
-                        if (isPromiseLike(result)) {
-                            return result;
+                        var data = item[_DYN_DATA ];
+                        if (data) {
+                            item[_DYN_DATA ] = base64Encode(data);
                         }
-                        return createAsyncResolvedPromise(result);
+                        return item;
                     }
                     catch (e) {
-                        return createAsyncRejectedPromise(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;
                 }
-                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;
-                    }
-                    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.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 ]();
-                            }
-                        };
-                    });
-                }
-            });
-        }
-        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.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;
-                    }
-                    if (!value) {
-                        return false;
-                    }
-                    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);
-                }
-            });
+            }
         }
-        SimpleQuery.__ieDyn=1;
-        return SimpleQuery;
-    }());
-
-    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 _getTime() {
-        return new Date()[_DYN_GET_TIME ]();
+        return result;
     }
-    function _createDb(db) {
-        if (!db.objectStoreNames.contains(EventObjectStoreName)) {
-            var evtStore = db.createObjectStore(EventObjectStoreName, { keyPath: "id" });
-            evtStore.createIndex("criticalCnt", "criticalCnt", { unique: false });
+    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 _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) {
+            if (!_isQuotaExceeded(storage, e)) {
+                storage = null;
             }
         }
-        return events;
+        return storage;
     }
-    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;
+    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 ](key);
+                    droppedEvents++;
+                }
+                return (droppedEvents < eventsToDropAtOneTime);
+            });
+            if (droppedEvents > 0) {
+                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
+                    delete events[dropKeys[lp]];
+                }
+                return droppedEvents;
             }
+            persistenceCnt++;
         }
-        values[_DYN_PUSH ](newValue);
+        return droppedEvents;
     }
-    function _getId(key, values) {
-        var len = values[_DYN_LENGTH ];
-        for (var lp = 0; lp < len; lp++) {
-            if (key === values[lp].id) {
-                return lp;
+    function _dropMaxTimeEvents$1(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 (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;
             }
         }
-        return -1;
-    }
-    function _cursorContinueEvent(cursorState, value) {
-        return function (evt) {
-            return cursorState[_DYN_CONTINUE ]();
-        };
-    }
-    function _cursorDeleteAndContinue(cursorState, value) {
-        var deleteRequest = cursorState.cursor.delete();
-        deleteRequest[_DYN_ONERROR ] = _cursorContinueEvent(cursorState);
-        deleteRequest[_DYN_ONSUCCESS ] = _cursorContinueEvent(cursorState);
-        return 1 ;
+        catch (e) {
+        }
+        return droppedEvents > 0;
     }
-    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 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 _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 ];
-                    var ikey = itemCtx.getCfg()[_DYN_INSTRUMENTATION_KEY ] || coreConfig[_DYN_INSTRUMENTATION_KEY ];
-                    if (!isString(ikey)) {
-                        return;
-                    }
-                    _iKey = ikey;
                     var storageConfig = providerContext[_DYN_STORAGE_CONFIG ];
-                    _storageId = _this.id || providerContext.id || newGuid();
+                    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 ];
-                    _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;
+                        _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$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;
-                            });
-                        });
+                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultStorageKey;
+                    _storageKey = _storageKeyPrefix + "_" + Version + "_" + _endpoint;
+                    if (autoClean) {
+                        _this.clean();
                     }
                     return true;
                 };
-                _this["_getDbgPlgTargets"] = function () {
-                    return [_dbName, _endpoint, _maxStorageTime, _indexedDb];
-                };
                 _this[_DYN_SUPPORTS_SYNC_REQUES4 ] = function () {
-                    return false;
+                    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 [];
-                    }
-                    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 ]();
-                                    };
-                                    return 1 ;
+                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);
                                 }
-                                return 0 ;
-                            });
-                        })[_DYN_THEN ](function () {
-                            removeEventsResolve(removedEvents);
-                        }, function (reason) {
-                            removeEventsResolve(removedEvents);
-                        });
-                    });
-                };
-                _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([]);
-                        });
-                    });
-                };
-                _this.clean = function (disable) {
-                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
-                        return false;
-                    }
-                    return createAsyncPromise(function (cleanResolve, cleanReject) {
-                        _openDb(function (dbCtx) {
-                            if (dbCtx.isNew) {
-                                return [];
+                                allItems[_DYN_PUSH ](evt);
                             }
-                            return _dropMaxTimeEvents$1(dbCtx, _maxStorageTime);
-                        })[_DYN_THEN ](function (value) {
-                            var cnt = value && value[_DYN_LENGTH ];
-                            if (_notificationManager && cnt) {
-                                batchDropNotification(_notificationManager, cnt, 3 );
+                            if (cnt && allItems && allItems[_DYN_LENGTH ] == cnt) {
+                                return false;
                             }
-                            cleanResolve(cnt && cnt > 0);
-                        }, function (reason) {
-                            cleanResolve(false);
-                        });
-                    });
+                            return true;
+                        }, ordered);
+                    }
+                    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 evt;
+                            }
+                            delete events[id_1];
+                            var droppedCnt = _dropEventsUpToPersistence$1(_maxCriticalCnt, events, _eventDropPerTime);
+                            preDroppedCnt += droppedCnt;
+                            if (!droppedCnt) {
+                                return createAsyncRejectedPromise(new Error("Unable to free up event space"));
+                            }
+                        }
+                    }
+                    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];
+                                }
+                                if (_updateStoredDb(theStore)) {
+                                    return evts;
+                                }
+                            }
+                            catch (e) {
+                            }
+                            evts = _clearDatabase(theStore.key);
+                        }
+                        return evts;
+                    }
+                    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;
+                            });
+                            _updateStoredDb(theStore);
+                        }
+                        return removedItems_1;
+                    }
+                    catch (e) {
+                        return createAsyncRejectedPromise(e);
+                    }
+                };
+                _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, _notificationManager);
+                            if (isDropped) {
+                                return _updateStoredDb(storeDetails);
+                            }
+                            return true;
+                        }
+                        catch (e) {
+                        }
+                        return 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$1(dbCtx, _maxCriticalCnt, _eventDropPerTime)[_DYN_THEN ](function (droppedCount) {
-                                if (_notificationManager && droppedCount) {
-                                    batchDropNotification(_notificationManager, droppedCount, 2 );
+                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);
                                 }
-                                droppedFunc(droppedCount);
-                            }, function (reason) {
-                                droppedFunc(0);
+                                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;
     }());
 
-    function getEndpointDomain(endpoint) {
-        try {
-            var url = endpoint.replace(/^https?:\/\/|^www\./, "");
-            url = url.replace(/\?/, "/");
-            var arr = url[_DYN_SPLIT ]("/");
-            if (arr && arr[_DYN_LENGTH ] > 0) {
-                return arr[0];
-            }
-        }
-        catch (e) {
-        }
-        return endpoint;
-    }
-    function isGreaterThanZero(value) {
-        return value >= 0;
-    }
-    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 += "==";
-            }
-            else {
-                line += _base64[_DYN_CHAR_AT ](((chr2 & 15) << 2) | (chr3 >> 6));
-                line += isNaN(chr3) ? "=" : _base64[_DYN_CHAR_AT ](chr3 & 63);
-            }
-        }
-        output += line;
-        return output;
-    }
-    function base64Decode(input) {
-        var output = "";
-        var chr1, chr2, chr3;
-        var enc1, enc2, enc3, enc4;
-        var i = 0;
-        input = input.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]);
+    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 0;
-    }
-    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) {
+        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;
                     }
-                    return -1;
-                });
-            }
-            for (var lp = 0; lp < keys[_DYN_LENGTH ]; lp++) {
-                var key = keys[lp];
-                if (!callback(map[key], key)) {
-                    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 callNotification(mgr, evtName, theArgs) {
-        var manager = (mgr || {});
-        var notifyFunc = manager[evtName];
-        if (notifyFunc) {
+    function _scheduleEvent(dbName, actionName, startEvent, evtTimeOut) {
+        var dbCtx = _getDbContext(dbName);
+        return dbCtx.sch.queue(startEvent, actionName, evtTimeOut);
+    }
+    function getDbFactory() {
+        var global = getGlobal() || {};
+        var dbFactory = null;
+        if (global) {
             try {
-                notifyFunc.apply(manager, theArgs);
+                for (var lp = 0; lp < IndexedDBNames[_DYN_LENGTH ]; lp++) {
+                    dbFactory = global[IndexedDBNames[lp]];
+                    if (dbFactory && isFunction(dbFactory.open)) {
+                        return dbFactory;
+                    }
+                }
             }
             catch (e) {
+                dbFactory = null;
             }
         }
+        return dbFactory;
     }
-    function batchDropNotification(mgr, cnt, reason) {
-        if (mgr && cnt > 0) {
-            callNotification(mgr, BATCH_DROP_STR, [cnt, reason]);
+    function _debugLog(dbName, message) {
+        if (getInst("QUnit")) {
+            console && console.log("IndexedDbHelper [" + dbName + "] " + message);
         }
-        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;
+    function _eventReject(dbName, rejectMessage, rejectFunc, evtName) {
+        return function (evt) {
+            rejectFunc(new Error(rejectMessage));
+            _debugLog(dbName, "[" + evtName + "] event rejected");
+        };
+    }
+    var IndexedDbHelper = /** @class */ (function () {
+        function IndexedDbHelper(diagLog) {
+            var _dbFactory = getDbFactory() || null;
+            dynamicProto(IndexedDbHelper, this, function (_this) {
+                _this[_DYN_IS_AVAILABLE ] = function () {
+                    return !!_dbFactory;
+                };
+                _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.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.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.deleteDb = function (dbName) {
+                    if (_dbFactory == null) {
+                        return false;
+                    }
+                    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);
+                                    };
+                                    _debugLog(dbName, "[" + evtName + "] started");
+                                }
+                                catch (e) {
+                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase + " - " + e));
+                                }
+                            }, 0);
+                        });
+                    });
+                };
+                _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);
+                        });
+                    }, 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 data = input[_DYN_DATA ];
-                        if (data) {
-                            input[_DYN_DATA ] = base64Decode(data);
+                        var result = doAction(_createStoreContext(openDbCtx, eventTable));
+                        if (isPromiseLike(result)) {
+                            return result;
                         }
-                        return input;
+                        return createAsyncResolvedPromise(result);
                     }
                     catch (e) {
-                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
+                        return createAsyncRejectedPromise(e);
                     }
-                    return null;
-                };
-                _self.base64ToStr = function (item) {
-                    if (!item || !item[_DYN_IS_ARR ]) {
-                        return item;
+                }
+                function _openCursor(openDbCtx, eventTable, query, processFunc) {
+                    if (!openDbCtx || !openDbCtx.db) {
+                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
                     }
-                    try {
-                        var data = item[_DYN_DATA ];
-                        if (data) {
-                            item[_DYN_DATA ] = base64Encode(data);
+                    var simpleQuery = null;
+                    if (query && isString(query)) {
+                        simpleQuery = new SimpleQuery(query);
+                    }
+                    else if (query && query.isMatch) {
+                        simpleQuery = query;
+                    }
+                    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.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 ]();
+                            }
+                        };
+                    });
+                }
+            });
+        }
+        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);
+                            }
                         }
-                        return item;
                     }
-                    catch (e) {
-                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
+                };
+                _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;
                     }
-                    return null;
+                    if (!value) {
+                        return false;
+                    }
+                    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);
+                }
             });
         }
-        PayloadHelper.__ieDyn=1;
-        return PayloadHelper;
+        SimpleQuery.__ieDyn=1;
+        return SimpleQuery;
     }());
 
     var EventsToDropAtOneTime = 10;
-    var Version = "1";
-    var DefaultStorageKey = "AIOffline";
-    var DefaultMaxStorageSizeInBytes = 5000000;
+    var StoreVersion = 1;
+    var OrhpanedEventThresholdInMs = 10080000;
+    var UnknowniKey = "Unknown";
+    var ErrorMessageUnableToAddEvent = "DBError: Unable to add event";
     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;
-                }
+    var DefaultDbName = "AIOffline";
+    var DbVersion = 1;
+    var EventObjectStoreName = "Evts";
+    function _getTime() {
+        return new Date()[_DYN_GET_TIME ]();
+    }
+    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);
             }
         }
-        return result;
+        return events;
     }
-    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 _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;
             }
         }
-        catch (e) {
-            if (!_isQuotaExceeded(storage, e)) {
-                storage = null;
+        values[_DYN_PUSH ](newValue);
+    }
+    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 _cursorContinueEvent(cursorState, value) {
+        return function (evt) {
+            return cursorState[_DYN_CONTINUE ]();
+        };
+    }
+    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 storage;
+            return 0 ;
+        });
     }
-    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++;
-                }
-                return (droppedEvents < eventsToDropAtOneTime);
-            });
-            if (droppedEvents > 0) {
-                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
-                    delete events[dropKeys[lp]];
-                }
-                return droppedEvents;
+    function _deleteEvents(dbCtx, eventPrefixQuery, shouldDelete) {
+        return dbCtx.openCursor(EventObjectStoreName, eventPrefixQuery, function (deleteCursorState, value, values) {
+            if (shouldDelete(value)) {
+                values[_DYN_PUSH ](value);
+                return _cursorDeleteAndContinue(deleteCursorState);
             }
-            persistenceCnt++;
-        }
-        return droppedEvents;
+            return 0 ;
+        });
     }
-    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++;
+    function _dropMaxTimeEvents(dbCtx, maxTime) {
+        return createAsyncPromise(function (deleteEvtsResolve, deleteEvtsReject) {
+            return _deleteEvents(dbCtx, null, function (value) {
+                if (!value || !value.evt) {
+                    return true;
                 }
-                return (droppedEvents < eventsToDropAtOneTime);
-            });
-            if (droppedEvents > 0) {
-                for (var lp = 0; lp < dropKeys[_DYN_LENGTH ]; lp++) {
-                    delete events[dropKeys[lp]];
+                var addedTime = getTimeFromId(value.id);
+                var minStartTime = _getTime() + 1 - maxTime;
+                if (addedTime <= minStartTime) {
+                    return true;
                 }
-                if (mgr) {
-                    batchDropNotification(mgr, droppedEvents, 3 );
+                return false;
+            })[_DYN_THEN ](function (values) {
+                deleteEvtsResolve(values);
+            }, deleteEvtsReject);
+        });
+    }
+    function _dropEventsUpToPersistence(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;
                 }
-                return true;
+                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);
+                });
             }
-        }
-        catch (e) {
-        }
-        return droppedEvents > 0;
+            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 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 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;
-                _storage = _getAvailableStorage(storageType) || null;
-                _this["_getDbgPlgTargets"] = function () {
-                    return [_storageKey, _maxStorageSizeInBytes, _maxStorageTime];
-                };
-                _this[_DYN_INITIALIZE ] = function (providerContext, endpointUrl) {
-                    if (!_storage) {
+                _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 storageConfig = providerContext[_DYN_STORAGE_CONFIG ];
+                    var coreConfig = providerContext[_DYN_ITEM_CTX ].getCfg();
                     var itemCtx = providerContext[_DYN_ITEM_CTX ];
-                    _payloadHelper = new PayloadHelper(itemCtx[_DYN_DIAG_LOG ]());
-                    _endpoint = getEndpointDomain(endpointUrl || providerContext[_DYN_ENDPOINT ]);
-                    var autoClean = !!storageConfig.autoClean;
+                    var ikey = itemCtx.getCfg()[_DYN_INSTRUMENTATION_KEY ] || coreConfig[_DYN_INSTRUMENTATION_KEY ];
+                    if (!isString(ikey)) {
+                        return;
+                    }
+                    _iKey = ikey;
+                    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 () {
-                        _maxStorageSizeInBytes = storageConfig.maxStorageSizeInBytes || DefaultMaxStorageSizeInBytes;
-                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || DefaultMaxInStorageTime;
+                        _maxStorageTime = storageConfig[_DYN_IN_STORAGE_MAX_TIME ] || OrhpanedEventThresholdInMs;
                         var dropNum = storageConfig[_DYN__EVENTS_TO_DROP_PER_2 ];
                         _eventDropPerTime = isNotNullOrUndefined(dropNum) ? dropNum : EventsToDropAtOneTime;
                         _maxCriticalCnt = storageConfig[_DYN_MAX_CRITICAL_EVTS_DR3 ] || MaxCriticalEvtsDropCnt;
                     });
                     unloadHookContainer && unloadHookContainer.add(unloadHook);
-                    _storageKeyPrefix = storageConfig[_DYN_STORAGE_KEY_PREFIX ] || DefaultStorageKey;
-                    _storageKey = _storageKeyPrefix + "_" + Version + "_" + _endpoint;
-                    if (autoClean) {
-                        _this.clean();
+                    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["_getDbgPlgTargets"] = function () {
+                    return [_dbName, _endpoint, _maxStorageTime, _indexedDb];
+                };
                 _this[_DYN_SUPPORTS_SYNC_REQUES4 ] = function () {
-                    return true;
+                    return false;
                 };
                 _this.getAllEvents = function (cnt) {
-                    try {
-                        if (!_storage) {
-                            return;
-                        }
-                        return _getEvts(cnt);
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
+                    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[_DYN_GET_NEXT_BATCH ] = function () {
-                    try {
-                        if (!_storage) {
-                            return;
-                        }
-                        return _getEvts(1, true);
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
+                    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);
+                        });
+                    });
                 };
-                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);
-                    }
-                    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 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[_DYN_ADD_EVENT ] = function (key, item, itemCtx) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return item;
                     }
+                    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) {
-                    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;
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]()) {
+                        return [];
                     }
-                };
-                _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);
+                    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 ]();
+                                    };
+                                    return 1 ;
                                 }
-                                return true;
+                                return 0 ;
                             });
-                            _updateStoredDb(theStore);
-                        }
-                        return removedItems_1;
-                    }
-                    catch (e) {
-                        return createAsyncRejectedPromise(e);
+                        })[_DYN_THEN ](function () {
+                            removeEventsResolve(removedEvents);
+                        }, function (reason) {
+                            removeEventsResolve(removedEvents);
+                        });
+                    });
+                };
+                _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([]);
+                        });
+                    });
                 };
-                _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) {
-                        }
+                _this.clean = function (disable) {
+                    if (_indexedDb == null || !_indexedDb[_DYN_IS_AVAILABLE ]() || !!disable) {
                         return false;
                     }
+                    return createAsyncPromise(function (cleanResolve, cleanReject) {
+                        _openDb(function (dbCtx) {
+                            if (dbCtx.isNew) {
+                                return [];
+                            }
+                            return _dropMaxTimeEvents(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);
+                        });
+                    });
                 };
                 _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);
-                        }
-                    }
-                    catch (e) {
+                    if (_indexedDb) {
+                        _indexedDb.closeDb(_dbName);
                     }
                 };
-                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) {
+                function _openDb(processFunc) {
+                    function _handleDbUpgrade(dbCtx) {
+                        return createAsyncPromise(function (createResolve, createReject) {
                             try {
-                                dbToStore = getJSON().parse(previousDb);
+                                _createDb(dbCtx.db);
                             }
                             catch (e) {
-                                _storage[_DYN_REMOVE_ITEM ](dbKey);
+                                createReject(e);
                             }
-                        }
-                        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 ]();
-                        }
-                    }
-                    try {
-                        var jsonString = getJSON().stringify(dbToStore);
-                        if (jsonString[_DYN_LENGTH ] > _maxStorageSizeInBytes) {
-                            return false;
-                        }
-                        _storage && _storage.setItem(jsonStore.key, jsonString);
+                            createResolve();
+                        });
                     }
-                    catch (e) {
-                        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);
+                        });
                     }
-                    return true;
+                    return _indexedDb.openDb(_dbName, DbVersion, _handleDbOpen, _handleDbUpgrade);
                 }
-                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);
+                function _addDbEvent(dbCtx, dbItem, doRetry) {
+                    return createAsyncPromise(function (addEventResolve, addEventReject) {
+                        function dropEvents(droppedFunc) {
+                            _dropEventsUpToPersistence(dbCtx, _maxCriticalCnt, _eventDropPerTime)[_DYN_THEN ](function (droppedCount) {
+                                if (_notificationManager && droppedCount) {
+                                    batchDropNotification(_notificationManager, droppedCount, 2 );
                                 }
-                                return true;
+                                droppedFunc(droppedCount);
+                            }, function (reason) {
+                                droppedFunc(0);
                             });
                         }
-                        catch (e) {
+                        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);
+                            });
                         }
-                        _storage && _storage[_DYN_REMOVE_ITEM ](storeDetails.key);
-                    }
-                    return removedItems;
+                        _insertNewEvent();
+                    });
                 }
             });
         }
-        WebStorageProvider.__ieDyn=1;
-        return WebStorageProvider;
+        IndexedDbProvider.__ieDyn=1;
+        return IndexedDbProvider;
     }());
 
     var MaxStorageProviderConfig = 2;
@@ -6348,7 +6348,7 @@
         return Sender;
     }());
 
-    var version = '0.3.1-nightly3.2407-06';
+    var version = '0.3.1-nightly3.2407-08';
     var DefaultOfflineIdentifier = "OfflineChannel";
     var DefaultBatchInterval = 15000;
     var DefaultInMemoMaxTime = 15000;