@powerhousedao/connect 1.0.4 → 1.0.6-dev.0

package/dist/modules/@powerhousedao/reactor-browser/chunk-ISDEPHKP.js

@@ -0,0 +1,2513 @@
+import {
+  BaseQueueManager,
+  DriveNotFoundError,
+  ReactorBuilder,
+  memory_default,
+  mergeOperations
+} from "./chunk-SQ5HIKYV.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/.pnpm/localforage@1.10.0/node_modules/localforage/dist/localforage.js
+var require_localforage = __commonJS({
+  "../../node_modules/.pnpm/localforage@1.10.0/node_modules/localforage/dist/localforage.js"(exports, module) {
+    (function(f) {
+      if (typeof exports === "object" && typeof module !== "undefined") {
+        module.exports = f();
+      } else if (typeof define === "function" && define.amd) {
+        define([], f);
+      } else {
+        var g;
+        if (typeof window !== "undefined") {
+          g = window;
+        } else if (typeof global !== "undefined") {
+          g = global;
+        } else if (typeof self !== "undefined") {
+          g = self;
+        } else {
+          g = this;
+        }
+        g.localforage = f();
+      }
+    })(function() {
+      var define2, module2, exports2;
+      return function e(t, n, r) {
+        function s(o2, u) {
+          if (!n[o2]) {
+            if (!t[o2]) {
+              var a = typeof __require == "function" && __require;
+              if (!u && a) return a(o2, true);
+              if (i) return i(o2, true);
+              var f = new Error("Cannot find module '" + o2 + "'");
+              throw f.code = "MODULE_NOT_FOUND", f;
+            }
+            var l = n[o2] = { exports: {} };
+            t[o2][0].call(l.exports, function(e2) {
+              var n2 = t[o2][1][e2];
+              return s(n2 ? n2 : e2);
+            }, l, l.exports, e, t, n, r);
+          }
+          return n[o2].exports;
+        }
+        var i = typeof __require == "function" && __require;
+        for (var o = 0; o < r.length; o++) s(r[o]);
+        return s;
+      }({ 1: [function(_dereq_, module3, exports3) {
+        (function(global2) {
+          "use strict";
+          var Mutation = global2.MutationObserver || global2.WebKitMutationObserver;
+          var scheduleDrain;
+          {
+            if (Mutation) {
+              var called = 0;
+              var observer = new Mutation(nextTick);
+              var element = global2.document.createTextNode("");
+              observer.observe(element, {
+                characterData: true
+              });
+              scheduleDrain = function() {
+                element.data = called = ++called % 2;
+              };
+            } else if (!global2.setImmediate && typeof global2.MessageChannel !== "undefined") {
+              var channel = new global2.MessageChannel();
+              channel.port1.onmessage = nextTick;
+              scheduleDrain = function() {
+                channel.port2.postMessage(0);
+              };
+            } else if ("document" in global2 && "onreadystatechange" in global2.document.createElement("script")) {
+              scheduleDrain = function() {
+                var scriptEl = global2.document.createElement("script");
+                scriptEl.onreadystatechange = function() {
+                  nextTick();
+                  scriptEl.onreadystatechange = null;
+                  scriptEl.parentNode.removeChild(scriptEl);
+                  scriptEl = null;
+                };
+                global2.document.documentElement.appendChild(scriptEl);
+              };
+            } else {
+              scheduleDrain = function() {
+                setTimeout(nextTick, 0);
+              };
+            }
+          }
+          var draining;
+          var queue = [];
+          function nextTick() {
+            draining = true;
+            var i, oldQueue;
+            var len = queue.length;
+            while (len) {
+              oldQueue = queue;
+              queue = [];
+              i = -1;
+              while (++i < len) {
+                oldQueue[i]();
+              }
+              len = queue.length;
+            }
+            draining = false;
+          }
+          module3.exports = immediate;
+          function immediate(task) {
+            if (queue.push(task) === 1 && !draining) {
+              scheduleDrain();
+            }
+          }
+        }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
+      }, {}], 2: [function(_dereq_, module3, exports3) {
+        "use strict";
+        var immediate = _dereq_(1);
+        function INTERNAL() {
+        }
+        var handlers = {};
+        var REJECTED = ["REJECTED"];
+        var FULFILLED = ["FULFILLED"];
+        var PENDING = ["PENDING"];
+        module3.exports = Promise2;
+        function Promise2(resolver) {
+          if (typeof resolver !== "function") {
+            throw new TypeError("resolver must be a function");
+          }
+          this.state = PENDING;
+          this.queue = [];
+          this.outcome = void 0;
+          if (resolver !== INTERNAL) {
+            safelyResolveThenable(this, resolver);
+          }
+        }
+        Promise2.prototype["catch"] = function(onRejected) {
+          return this.then(null, onRejected);
+        };
+        Promise2.prototype.then = function(onFulfilled, onRejected) {
+          if (typeof onFulfilled !== "function" && this.state === FULFILLED || typeof onRejected !== "function" && this.state === REJECTED) {
+            return this;
+          }
+          var promise = new this.constructor(INTERNAL);
+          if (this.state !== PENDING) {
+            var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
+            unwrap(promise, resolver, this.outcome);
+          } else {
+            this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+          }
+          return promise;
+        };
+        function QueueItem(promise, onFulfilled, onRejected) {
+          this.promise = promise;
+          if (typeof onFulfilled === "function") {
+            this.onFulfilled = onFulfilled;
+            this.callFulfilled = this.otherCallFulfilled;
+          }
+          if (typeof onRejected === "function") {
+            this.onRejected = onRejected;
+            this.callRejected = this.otherCallRejected;
+          }
+        }
+        QueueItem.prototype.callFulfilled = function(value) {
+          handlers.resolve(this.promise, value);
+        };
+        QueueItem.prototype.otherCallFulfilled = function(value) {
+          unwrap(this.promise, this.onFulfilled, value);
+        };
+        QueueItem.prototype.callRejected = function(value) {
+          handlers.reject(this.promise, value);
+        };
+        QueueItem.prototype.otherCallRejected = function(value) {
+          unwrap(this.promise, this.onRejected, value);
+        };
+        function unwrap(promise, func, value) {
+          immediate(function() {
+            var returnValue;
+            try {
+              returnValue = func(value);
+            } catch (e) {
+              return handlers.reject(promise, e);
+            }
+            if (returnValue === promise) {
+              handlers.reject(promise, new TypeError("Cannot resolve promise with itself"));
+            } else {
+              handlers.resolve(promise, returnValue);
+            }
+          });
+        }
+        handlers.resolve = function(self2, value) {
+          var result = tryCatch(getThen, value);
+          if (result.status === "error") {
+            return handlers.reject(self2, result.value);
+          }
+          var thenable = result.value;
+          if (thenable) {
+            safelyResolveThenable(self2, thenable);
+          } else {
+            self2.state = FULFILLED;
+            self2.outcome = value;
+            var i = -1;
+            var len = self2.queue.length;
+            while (++i < len) {
+              self2.queue[i].callFulfilled(value);
+            }
+          }
+          return self2;
+        };
+        handlers.reject = function(self2, error) {
+          self2.state = REJECTED;
+          self2.outcome = error;
+          var i = -1;
+          var len = self2.queue.length;
+          while (++i < len) {
+            self2.queue[i].callRejected(error);
+          }
+          return self2;
+        };
+        function getThen(obj) {
+          var then = obj && obj.then;
+          if (obj && (typeof obj === "object" || typeof obj === "function") && typeof then === "function") {
+            return function appyThen() {
+              then.apply(obj, arguments);
+            };
+          }
+        }
+        function safelyResolveThenable(self2, thenable) {
+          var called = false;
+          function onError(value) {
+            if (called) {
+              return;
+            }
+            called = true;
+            handlers.reject(self2, value);
+          }
+          function onSuccess(value) {
+            if (called) {
+              return;
+            }
+            called = true;
+            handlers.resolve(self2, value);
+          }
+          function tryToUnwrap() {
+            thenable(onSuccess, onError);
+          }
+          var result = tryCatch(tryToUnwrap);
+          if (result.status === "error") {
+            onError(result.value);
+          }
+        }
+        function tryCatch(func, value) {
+          var out = {};
+          try {
+            out.value = func(value);
+            out.status = "success";
+          } catch (e) {
+            out.status = "error";
+            out.value = e;
+          }
+          return out;
+        }
+        Promise2.resolve = resolve;
+        function resolve(value) {
+          if (value instanceof this) {
+            return value;
+          }
+          return handlers.resolve(new this(INTERNAL), value);
+        }
+        Promise2.reject = reject;
+        function reject(reason) {
+          var promise = new this(INTERNAL);
+          return handlers.reject(promise, reason);
+        }
+        Promise2.all = all;
+        function all(iterable) {
+          var self2 = this;
+          if (Object.prototype.toString.call(iterable) !== "[object Array]") {
+            return this.reject(new TypeError("must be an array"));
+          }
+          var len = iterable.length;
+          var called = false;
+          if (!len) {
+            return this.resolve([]);
+          }
+          var values = new Array(len);
+          var resolved = 0;
+          var i = -1;
+          var promise = new this(INTERNAL);
+          while (++i < len) {
+            allResolver(iterable[i], i);
+          }
+          return promise;
+          function allResolver(value, i2) {
+            self2.resolve(value).then(resolveFromAll, function(error) {
+              if (!called) {
+                called = true;
+                handlers.reject(promise, error);
+              }
+            });
+            function resolveFromAll(outValue) {
+              values[i2] = outValue;
+              if (++resolved === len && !called) {
+                called = true;
+                handlers.resolve(promise, values);
+              }
+            }
+          }
+        }
+        Promise2.race = race;
+        function race(iterable) {
+          var self2 = this;
+          if (Object.prototype.toString.call(iterable) !== "[object Array]") {
+            return this.reject(new TypeError("must be an array"));
+          }
+          var len = iterable.length;
+          var called = false;
+          if (!len) {
+            return this.resolve([]);
+          }
+          var i = -1;
+          var promise = new this(INTERNAL);
+          while (++i < len) {
+            resolver(iterable[i]);
+          }
+          return promise;
+          function resolver(value) {
+            self2.resolve(value).then(function(response) {
+              if (!called) {
+                called = true;
+                handlers.resolve(promise, response);
+              }
+            }, function(error) {
+              if (!called) {
+                called = true;
+                handlers.reject(promise, error);
+              }
+            });
+          }
+        }
+      }, { "1": 1 }], 3: [function(_dereq_, module3, exports3) {
+        (function(global2) {
+          "use strict";
+          if (typeof global2.Promise !== "function") {
+            global2.Promise = _dereq_(2);
+          }
+        }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
+      }, { "2": 2 }], 4: [function(_dereq_, module3, exports3) {
+        "use strict";
+        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+          return typeof obj;
+        } : function(obj) {
+          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+        };
+        function _classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        function getIDB() {
+          try {
+            if (typeof indexedDB !== "undefined") {
+              return indexedDB;
+            }
+            if (typeof webkitIndexedDB !== "undefined") {
+              return webkitIndexedDB;
+            }
+            if (typeof mozIndexedDB !== "undefined") {
+              return mozIndexedDB;
+            }
+            if (typeof OIndexedDB !== "undefined") {
+              return OIndexedDB;
+            }
+            if (typeof msIndexedDB !== "undefined") {
+              return msIndexedDB;
+            }
+          } catch (e) {
+            return;
+          }
+        }
+        var idb = getIDB();
+        function isIndexedDBValid() {
+          try {
+            if (!idb || !idb.open) {
+              return false;
+            }
+            var isSafari = typeof openDatabase !== "undefined" && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform);
+            var hasFetch = typeof fetch === "function" && fetch.toString().indexOf("[native code") !== -1;
+            return (!isSafari || hasFetch) && typeof indexedDB !== "undefined" && // some outdated implementations of IDB that appear on Samsung
+            // and HTC Android devices <4.4 are missing IDBKeyRange
+            // See: https://github.com/mozilla/localForage/issues/128
+            // See: https://github.com/mozilla/localForage/issues/272
+            typeof IDBKeyRange !== "undefined";
+          } catch (e) {
+            return false;
+          }
+        }
+        function createBlob(parts, properties) {
+          parts = parts || [];
+          properties = properties || {};
+          try {
+            return new Blob(parts, properties);
+          } catch (e) {
+            if (e.name !== "TypeError") {
+              throw e;
+            }
+            var Builder = typeof BlobBuilder !== "undefined" ? BlobBuilder : typeof MSBlobBuilder !== "undefined" ? MSBlobBuilder : typeof MozBlobBuilder !== "undefined" ? MozBlobBuilder : WebKitBlobBuilder;
+            var builder = new Builder();
+            for (var i = 0; i < parts.length; i += 1) {
+              builder.append(parts[i]);
+            }
+            return builder.getBlob(properties.type);
+          }
+        }
+        if (typeof Promise === "undefined") {
+          _dereq_(3);
+        }
+        var Promise$1 = Promise;
+        function executeCallback(promise, callback) {
+          if (callback) {
+            promise.then(function(result) {
+              callback(null, result);
+            }, function(error) {
+              callback(error);
+            });
+          }
+        }
+        function executeTwoCallbacks(promise, callback, errorCallback) {
+          if (typeof callback === "function") {
+            promise.then(callback);
+          }
+          if (typeof errorCallback === "function") {
+            promise["catch"](errorCallback);
+          }
+        }
+        function normalizeKey(key2) {
+          if (typeof key2 !== "string") {
+            console.warn(key2 + " used as a key, but it is not a string.");
+            key2 = String(key2);
+          }
+          return key2;
+        }
+        function getCallback() {
+          if (arguments.length && typeof arguments[arguments.length - 1] === "function") {
+            return arguments[arguments.length - 1];
+          }
+        }
+        var DETECT_BLOB_SUPPORT_STORE = "local-forage-detect-blob-support";
+        var supportsBlobs = void 0;
+        var dbContexts = {};
+        var toString = Object.prototype.toString;
+        var READ_ONLY = "readonly";
+        var READ_WRITE = "readwrite";
+        function _binStringToArrayBuffer(bin) {
+          var length2 = bin.length;
+          var buf = new ArrayBuffer(length2);
+          var arr = new Uint8Array(buf);
+          for (var i = 0; i < length2; i++) {
+            arr[i] = bin.charCodeAt(i);
+          }
+          return buf;
+        }
+        function _checkBlobSupportWithoutCaching(idb2) {
+          return new Promise$1(function(resolve) {
+            var txn = idb2.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE);
+            var blob = createBlob([""]);
+            txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, "key");
+            txn.onabort = function(e) {
+              e.preventDefault();
+              e.stopPropagation();
+              resolve(false);
+            };
+            txn.oncomplete = function() {
+              var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/);
+              var matchedEdge = navigator.userAgent.match(/Edge\//);
+              resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43);
+            };
+          })["catch"](function() {
+            return false;
+          });
+        }
+        function _checkBlobSupport(idb2) {
+          if (typeof supportsBlobs === "boolean") {
+            return Promise$1.resolve(supportsBlobs);
+          }
+          return _checkBlobSupportWithoutCaching(idb2).then(function(value) {
+            supportsBlobs = value;
+            return supportsBlobs;
+          });
+        }
+        function _deferReadiness(dbInfo) {
+          var dbContext = dbContexts[dbInfo.name];
+          var deferredOperation = {};
+          deferredOperation.promise = new Promise$1(function(resolve, reject) {
+            deferredOperation.resolve = resolve;
+            deferredOperation.reject = reject;
+          });
+          dbContext.deferredOperations.push(deferredOperation);
+          if (!dbContext.dbReady) {
+            dbContext.dbReady = deferredOperation.promise;
+          } else {
+            dbContext.dbReady = dbContext.dbReady.then(function() {
+              return deferredOperation.promise;
+            });
+          }
+        }
+        function _advanceReadiness(dbInfo) {
+          var dbContext = dbContexts[dbInfo.name];
+          var deferredOperation = dbContext.deferredOperations.pop();
+          if (deferredOperation) {
+            deferredOperation.resolve();
+            return deferredOperation.promise;
+          }
+        }
+        function _rejectReadiness(dbInfo, err) {
+          var dbContext = dbContexts[dbInfo.name];
+          var deferredOperation = dbContext.deferredOperations.pop();
+          if (deferredOperation) {
+            deferredOperation.reject(err);
+            return deferredOperation.promise;
+          }
+        }
+        function _getConnection(dbInfo, upgradeNeeded) {
+          return new Promise$1(function(resolve, reject) {
+            dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext();
+            if (dbInfo.db) {
+              if (upgradeNeeded) {
+                _deferReadiness(dbInfo);
+                dbInfo.db.close();
+              } else {
+                return resolve(dbInfo.db);
+              }
+            }
+            var dbArgs = [dbInfo.name];
+            if (upgradeNeeded) {
+              dbArgs.push(dbInfo.version);
+            }
+            var openreq = idb.open.apply(idb, dbArgs);
+            if (upgradeNeeded) {
+              openreq.onupgradeneeded = function(e) {
+                var db = openreq.result;
+                try {
+                  db.createObjectStore(dbInfo.storeName);
+                  if (e.oldVersion <= 1) {
+                    db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
+                  }
+                } catch (ex) {
+                  if (ex.name === "ConstraintError") {
+                    console.warn('The database "' + dbInfo.name + '" has been upgraded from version ' + e.oldVersion + " to version " + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.');
+                  } else {
+                    throw ex;
+                  }
+                }
+              };
+            }
+            openreq.onerror = function(e) {
+              e.preventDefault();
+              reject(openreq.error);
+            };
+            openreq.onsuccess = function() {
+              var db = openreq.result;
+              db.onversionchange = function(e) {
+                e.target.close();
+              };
+              resolve(db);
+              _advanceReadiness(dbInfo);
+            };
+          });
+        }
+        function _getOriginalConnection(dbInfo) {
+          return _getConnection(dbInfo, false);
+        }
+        function _getUpgradedConnection(dbInfo) {
+          return _getConnection(dbInfo, true);
+        }
+        function _isUpgradeNeeded(dbInfo, defaultVersion) {
+          if (!dbInfo.db) {
+            return true;
+          }
+          var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName);
+          var isDowngrade = dbInfo.version < dbInfo.db.version;
+          var isUpgrade = dbInfo.version > dbInfo.db.version;
+          if (isDowngrade) {
+            if (dbInfo.version !== defaultVersion) {
+              console.warn('The database "' + dbInfo.name + `" can't be downgraded from version ` + dbInfo.db.version + " to version " + dbInfo.version + ".");
+            }
+            dbInfo.version = dbInfo.db.version;
+          }
+          if (isUpgrade || isNewStore) {
+            if (isNewStore) {
+              var incVersion = dbInfo.db.version + 1;
+              if (incVersion > dbInfo.version) {
+                dbInfo.version = incVersion;
+              }
+            }
+            return true;
+          }
+          return false;
+        }
+        function _encodeBlob(blob) {
+          return new Promise$1(function(resolve, reject) {
+            var reader = new FileReader();
+            reader.onerror = reject;
+            reader.onloadend = function(e) {
+              var base64 = btoa(e.target.result || "");
+              resolve({
+                __local_forage_encoded_blob: true,
+                data: base64,
+                type: blob.type
+              });
+            };
+            reader.readAsBinaryString(blob);
+          });
+        }
+        function _decodeBlob(encodedBlob) {
+          var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data));
+          return createBlob([arrayBuff], { type: encodedBlob.type });
+        }
+        function _isEncodedBlob(value) {
+          return value && value.__local_forage_encoded_blob;
+        }
+        function _fullyReady(callback) {
+          var self2 = this;
+          var promise = self2._initReady().then(function() {
+            var dbContext = dbContexts[self2._dbInfo.name];
+            if (dbContext && dbContext.dbReady) {
+              return dbContext.dbReady;
+            }
+          });
+          executeTwoCallbacks(promise, callback, callback);
+          return promise;
+        }
+        function _tryReconnect(dbInfo) {
+          _deferReadiness(dbInfo);
+          var dbContext = dbContexts[dbInfo.name];
+          var forages = dbContext.forages;
+          for (var i = 0; i < forages.length; i++) {
+            var forage = forages[i];
+            if (forage._dbInfo.db) {
+              forage._dbInfo.db.close();
+              forage._dbInfo.db = null;
+            }
+          }
+          dbInfo.db = null;
+          return _getOriginalConnection(dbInfo).then(function(db) {
+            dbInfo.db = db;
+            if (_isUpgradeNeeded(dbInfo)) {
+              return _getUpgradedConnection(dbInfo);
+            }
+            return db;
+          }).then(function(db) {
+            dbInfo.db = dbContext.db = db;
+            for (var i2 = 0; i2 < forages.length; i2++) {
+              forages[i2]._dbInfo.db = db;
+            }
+          })["catch"](function(err) {
+            _rejectReadiness(dbInfo, err);
+            throw err;
+          });
+        }
+        function createTransaction(dbInfo, mode, callback, retries) {
+          if (retries === void 0) {
+            retries = 1;
+          }
+          try {
+            var tx = dbInfo.db.transaction(dbInfo.storeName, mode);
+            callback(null, tx);
+          } catch (err) {
+            if (retries > 0 && (!dbInfo.db || err.name === "InvalidStateError" || err.name === "NotFoundError")) {
+              return Promise$1.resolve().then(function() {
+                if (!dbInfo.db || err.name === "NotFoundError" && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) {
+                  if (dbInfo.db) {
+                    dbInfo.version = dbInfo.db.version + 1;
+                  }
+                  return _getUpgradedConnection(dbInfo);
+                }
+              }).then(function() {
+                return _tryReconnect(dbInfo).then(function() {
+                  createTransaction(dbInfo, mode, callback, retries - 1);
+                });
+              })["catch"](callback);
+            }
+            callback(err);
+          }
+        }
+        function createDbContext() {
+          return {
+            // Running localForages sharing a database.
+            forages: [],
+            // Shared database.
+            db: null,
+            // Database readiness (promise).
+            dbReady: null,
+            // Deferred operations on the database.
+            deferredOperations: []
+          };
+        }
+        function _initStorage(options) {
+          var self2 = this;
+          var dbInfo = {
+            db: null
+          };
+          if (options) {
+            for (var i in options) {
+              dbInfo[i] = options[i];
+            }
+          }
+          var dbContext = dbContexts[dbInfo.name];
+          if (!dbContext) {
+            dbContext = createDbContext();
+            dbContexts[dbInfo.name] = dbContext;
+          }
+          dbContext.forages.push(self2);
+          if (!self2._initReady) {
+            self2._initReady = self2.ready;
+            self2.ready = _fullyReady;
+          }
+          var initPromises = [];
+          function ignoreErrors() {
+            return Promise$1.resolve();
+          }
+          for (var j = 0; j < dbContext.forages.length; j++) {
+            var forage = dbContext.forages[j];
+            if (forage !== self2) {
+              initPromises.push(forage._initReady()["catch"](ignoreErrors));
+            }
+          }
+          var forages = dbContext.forages.slice(0);
+          return Promise$1.all(initPromises).then(function() {
+            dbInfo.db = dbContext.db;
+            return _getOriginalConnection(dbInfo);
+          }).then(function(db) {
+            dbInfo.db = db;
+            if (_isUpgradeNeeded(dbInfo, self2._defaultConfig.version)) {
+              return _getUpgradedConnection(dbInfo);
+            }
+            return db;
+          }).then(function(db) {
+            dbInfo.db = dbContext.db = db;
+            self2._dbInfo = dbInfo;
+            for (var k = 0; k < forages.length; k++) {
+              var forage2 = forages[k];
+              if (forage2 !== self2) {
+                forage2._dbInfo.db = dbInfo.db;
+                forage2._dbInfo.version = dbInfo.version;
+              }
+            }
+          });
+        }
+        function getItem(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store.get(key2);
+                  req.onsuccess = function() {
+                    var value = req.result;
+                    if (value === void 0) {
+                      value = null;
+                    }
+                    if (_isEncodedBlob(value)) {
+                      value = _decodeBlob(value);
+                    }
+                    resolve(value);
+                  };
+                  req.onerror = function() {
+                    reject(req.error);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function iterate(iterator, callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store.openCursor();
+                  var iterationNumber = 1;
+                  req.onsuccess = function() {
+                    var cursor = req.result;
+                    if (cursor) {
+                      var value = cursor.value;
+                      if (_isEncodedBlob(value)) {
+                        value = _decodeBlob(value);
+                      }
+                      var result = iterator(value, cursor.key, iterationNumber++);
+                      if (result !== void 0) {
+                        resolve(result);
+                      } else {
+                        cursor["continue"]();
+                      }
+                    } else {
+                      resolve();
+                    }
+                  };
+                  req.onerror = function() {
+                    reject(req.error);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function setItem(key2, value, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            var dbInfo;
+            self2.ready().then(function() {
+              dbInfo = self2._dbInfo;
+              if (toString.call(value) === "[object Blob]") {
+                return _checkBlobSupport(dbInfo.db).then(function(blobSupport) {
+                  if (blobSupport) {
+                    return value;
+                  }
+                  return _encodeBlob(value);
+                });
+              }
+              return value;
+            }).then(function(value2) {
+              createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  if (value2 === null) {
+                    value2 = void 0;
+                  }
+                  var req = store.put(value2, key2);
+                  transaction.oncomplete = function() {
+                    if (value2 === void 0) {
+                      value2 = null;
+                    }
+                    resolve(value2);
+                  };
+                  transaction.onabort = transaction.onerror = function() {
+                    var err2 = req.error ? req.error : req.transaction.error;
+                    reject(err2);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function removeItem(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store["delete"](key2);
+                  transaction.oncomplete = function() {
+                    resolve();
+                  };
+                  transaction.onerror = function() {
+                    reject(req.error);
+                  };
+                  transaction.onabort = function() {
+                    var err2 = req.error ? req.error : req.transaction.error;
+                    reject(err2);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function clear(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store.clear();
+                  transaction.oncomplete = function() {
+                    resolve();
+                  };
+                  transaction.onabort = transaction.onerror = function() {
+                    var err2 = req.error ? req.error : req.transaction.error;
+                    reject(err2);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function length(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store.count();
+                  req.onsuccess = function() {
+                    resolve(req.result);
+                  };
+                  req.onerror = function() {
+                    reject(req.error);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function key(n, callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            if (n < 0) {
+              resolve(null);
+              return;
+            }
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var advanced = false;
+                  var req = store.openKeyCursor();
+                  req.onsuccess = function() {
+                    var cursor = req.result;
+                    if (!cursor) {
+                      resolve(null);
+                      return;
+                    }
+                    if (n === 0) {
+                      resolve(cursor.key);
+                    } else {
+                      if (!advanced) {
+                        advanced = true;
+                        cursor.advance(n);
+                      } else {
+                        resolve(cursor.key);
+                      }
+                    }
+                  };
+                  req.onerror = function() {
+                    reject(req.error);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function keys(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) {
+                if (err) {
+                  return reject(err);
+                }
+                try {
+                  var store = transaction.objectStore(self2._dbInfo.storeName);
+                  var req = store.openKeyCursor();
+                  var keys2 = [];
+                  req.onsuccess = function() {
+                    var cursor = req.result;
+                    if (!cursor) {
+                      resolve(keys2);
+                      return;
+                    }
+                    keys2.push(cursor.key);
+                    cursor["continue"]();
+                  };
+                  req.onerror = function() {
+                    reject(req.error);
+                  };
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function dropInstance(options, callback) {
+          callback = getCallback.apply(this, arguments);
+          var currentConfig = this.config();
+          options = typeof options !== "function" && options || {};
+          if (!options.name) {
+            options.name = options.name || currentConfig.name;
+            options.storeName = options.storeName || currentConfig.storeName;
+          }
+          var self2 = this;
+          var promise;
+          if (!options.name) {
+            promise = Promise$1.reject("Invalid arguments");
+          } else {
+            var isCurrentDb = options.name === currentConfig.name && self2._dbInfo.db;
+            var dbPromise = isCurrentDb ? Promise$1.resolve(self2._dbInfo.db) : _getOriginalConnection(options).then(function(db) {
+              var dbContext = dbContexts[options.name];
+              var forages = dbContext.forages;
+              dbContext.db = db;
+              for (var i = 0; i < forages.length; i++) {
+                forages[i]._dbInfo.db = db;
+              }
+              return db;
+            });
+            if (!options.storeName) {
+              promise = dbPromise.then(function(db) {
+                _deferReadiness(options);
+                var dbContext = dbContexts[options.name];
+                var forages = dbContext.forages;
+                db.close();
+                for (var i = 0; i < forages.length; i++) {
+                  var forage = forages[i];
+                  forage._dbInfo.db = null;
+                }
+                var dropDBPromise = new Promise$1(function(resolve, reject) {
+                  var req = idb.deleteDatabase(options.name);
+                  req.onerror = function() {
+                    var db2 = req.result;
+                    if (db2) {
+                      db2.close();
+                    }
+                    reject(req.error);
+                  };
+                  req.onblocked = function() {
+                    console.warn('dropInstance blocked for database "' + options.name + '" until all open connections are closed');
+                  };
+                  req.onsuccess = function() {
+                    var db2 = req.result;
+                    if (db2) {
+                      db2.close();
+                    }
+                    resolve(db2);
+                  };
+                });
+                return dropDBPromise.then(function(db2) {
+                  dbContext.db = db2;
+                  for (var i2 = 0; i2 < forages.length; i2++) {
+                    var _forage = forages[i2];
+                    _advanceReadiness(_forage._dbInfo);
+                  }
+                })["catch"](function(err) {
+                  (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() {
+                  });
+                  throw err;
+                });
+              });
+            } else {
+              promise = dbPromise.then(function(db) {
+                if (!db.objectStoreNames.contains(options.storeName)) {
+                  return;
+                }
+                var newVersion = db.version + 1;
+                _deferReadiness(options);
+                var dbContext = dbContexts[options.name];
+                var forages = dbContext.forages;
+                db.close();
+                for (var i = 0; i < forages.length; i++) {
+                  var forage = forages[i];
+                  forage._dbInfo.db = null;
+                  forage._dbInfo.version = newVersion;
+                }
+                var dropObjectPromise = new Promise$1(function(resolve, reject) {
+                  var req = idb.open(options.name, newVersion);
+                  req.onerror = function(err) {
+                    var db2 = req.result;
+                    db2.close();
+                    reject(err);
+                  };
+                  req.onupgradeneeded = function() {
+                    var db2 = req.result;
+                    db2.deleteObjectStore(options.storeName);
+                  };
+                  req.onsuccess = function() {
+                    var db2 = req.result;
+                    db2.close();
+                    resolve(db2);
+                  };
+                });
+                return dropObjectPromise.then(function(db2) {
+                  dbContext.db = db2;
+                  for (var j = 0; j < forages.length; j++) {
+                    var _forage2 = forages[j];
+                    _forage2._dbInfo.db = db2;
+                    _advanceReadiness(_forage2._dbInfo);
+                  }
+                })["catch"](function(err) {
+                  (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() {
+                  });
+                  throw err;
+                });
+              });
+            }
+          }
+          executeCallback(promise, callback);
+          return promise;
+        }
+        var asyncStorage = {
+          _driver: "asyncStorage",
+          _initStorage,
+          _support: isIndexedDBValid(),
+          iterate,
+          getItem,
+          setItem,
+          removeItem,
+          clear,
+          length,
+          key,
+          keys,
+          dropInstance
+        };
+        function isWebSQLValid() {
+          return typeof openDatabase === "function";
+        }
+        var BASE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var BLOB_TYPE_PREFIX = "~~local_forage_type~";
+        var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;
+        var SERIALIZED_MARKER = "__lfsc__:";
+        var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length;
+        var TYPE_ARRAYBUFFER = "arbf";
+        var TYPE_BLOB = "blob";
+        var TYPE_INT8ARRAY = "si08";
+        var TYPE_UINT8ARRAY = "ui08";
+        var TYPE_UINT8CLAMPEDARRAY = "uic8";
+        var TYPE_INT16ARRAY = "si16";
+        var TYPE_INT32ARRAY = "si32";
+        var TYPE_UINT16ARRAY = "ur16";
+        var TYPE_UINT32ARRAY = "ui32";
+        var TYPE_FLOAT32ARRAY = "fl32";
+        var TYPE_FLOAT64ARRAY = "fl64";
+        var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length;
+        var toString$1 = Object.prototype.toString;
+        function stringToBuffer(serializedString) {
+          var bufferLength = serializedString.length * 0.75;
+          var len = serializedString.length;
+          var i;
+          var p = 0;
+          var encoded1, encoded2, encoded3, encoded4;
+          if (serializedString[serializedString.length - 1] === "=") {
+            bufferLength--;
+            if (serializedString[serializedString.length - 2] === "=") {
+              bufferLength--;
+            }
+          }
+          var buffer = new ArrayBuffer(bufferLength);
+          var bytes = new Uint8Array(buffer);
+          for (i = 0; i < len; i += 4) {
+            encoded1 = BASE_CHARS.indexOf(serializedString[i]);
+            encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]);
+            encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]);
+            encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]);
+            bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+            bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+            bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+          }
+          return buffer;
+        }
+        function bufferToString(buffer) {
+          var bytes = new Uint8Array(buffer);
+          var base64String = "";
+          var i;
+          for (i = 0; i < bytes.length; i += 3) {
+            base64String += BASE_CHARS[bytes[i] >> 2];
+            base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
+            base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
+            base64String += BASE_CHARS[bytes[i + 2] & 63];
+          }
+          if (bytes.length % 3 === 2) {
+            base64String = base64String.substring(0, base64String.length - 1) + "=";
+          } else if (bytes.length % 3 === 1) {
+            base64String = base64String.substring(0, base64String.length - 2) + "==";
+          }
+          return base64String;
+        }
+        function serialize(value, callback) {
+          var valueType = "";
+          if (value) {
+            valueType = toString$1.call(value);
+          }
+          if (value && (valueType === "[object ArrayBuffer]" || value.buffer && toString$1.call(value.buffer) === "[object ArrayBuffer]")) {
+            var buffer;
+            var marker = SERIALIZED_MARKER;
+            if (value instanceof ArrayBuffer) {
+              buffer = value;
+              marker += TYPE_ARRAYBUFFER;
+            } else {
+              buffer = value.buffer;
+              if (valueType === "[object Int8Array]") {
+                marker += TYPE_INT8ARRAY;
+              } else if (valueType === "[object Uint8Array]") {
+                marker += TYPE_UINT8ARRAY;
+              } else if (valueType === "[object Uint8ClampedArray]") {
+                marker += TYPE_UINT8CLAMPEDARRAY;
+              } else if (valueType === "[object Int16Array]") {
+                marker += TYPE_INT16ARRAY;
+              } else if (valueType === "[object Uint16Array]") {
+                marker += TYPE_UINT16ARRAY;
+              } else if (valueType === "[object Int32Array]") {
+                marker += TYPE_INT32ARRAY;
+              } else if (valueType === "[object Uint32Array]") {
+                marker += TYPE_UINT32ARRAY;
+              } else if (valueType === "[object Float32Array]") {
+                marker += TYPE_FLOAT32ARRAY;
+              } else if (valueType === "[object Float64Array]") {
+                marker += TYPE_FLOAT64ARRAY;
+              } else {
+                callback(new Error("Failed to get type for BinaryArray"));
+              }
+            }
+            callback(marker + bufferToString(buffer));
+          } else if (valueType === "[object Blob]") {
+            var fileReader = new FileReader();
+            fileReader.onload = function() {
+              var str = BLOB_TYPE_PREFIX + value.type + "~" + bufferToString(this.result);
+              callback(SERIALIZED_MARKER + TYPE_BLOB + str);
+            };
+            fileReader.readAsArrayBuffer(value);
+          } else {
+            try {
+              callback(JSON.stringify(value));
+            } catch (e) {
+              console.error("Couldn't convert value into a JSON string: ", value);
+              callback(null, e);
+            }
+          }
+        }
+        function deserialize(value) {
+          if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) {
+            return JSON.parse(value);
+          }
+          var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);
+          var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH);
+          var blobType;
+          if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {
+            var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);
+            blobType = matcher[1];
+            serializedString = serializedString.substring(matcher[0].length);
+          }
+          var buffer = stringToBuffer(serializedString);
+          switch (type) {
+            case TYPE_ARRAYBUFFER:
+              return buffer;
+            case TYPE_BLOB:
+              return createBlob([buffer], { type: blobType });
+            case TYPE_INT8ARRAY:
+              return new Int8Array(buffer);
+            case TYPE_UINT8ARRAY:
+              return new Uint8Array(buffer);
+            case TYPE_UINT8CLAMPEDARRAY:
+              return new Uint8ClampedArray(buffer);
+            case TYPE_INT16ARRAY:
+              return new Int16Array(buffer);
+            case TYPE_UINT16ARRAY:
+              return new Uint16Array(buffer);
+            case TYPE_INT32ARRAY:
+              return new Int32Array(buffer);
+            case TYPE_UINT32ARRAY:
+              return new Uint32Array(buffer);
+            case TYPE_FLOAT32ARRAY:
+              return new Float32Array(buffer);
+            case TYPE_FLOAT64ARRAY:
+              return new Float64Array(buffer);
+            default:
+              throw new Error("Unkown type: " + type);
+          }
+        }
+        var localforageSerializer = {
+          serialize,
+          deserialize,
+          stringToBuffer,
+          bufferToString
+        };
+        function createDbTable(t, dbInfo, callback, errorCallback) {
+          t.executeSql("CREATE TABLE IF NOT EXISTS " + dbInfo.storeName + " (id INTEGER PRIMARY KEY, key unique, value)", [], callback, errorCallback);
+        }
+        function _initStorage$1(options) {
+          var self2 = this;
+          var dbInfo = {
+            db: null
+          };
+          if (options) {
+            for (var i in options) {
+              dbInfo[i] = typeof options[i] !== "string" ? options[i].toString() : options[i];
+            }
+          }
+          var dbInfoPromise = new Promise$1(function(resolve, reject) {
+            try {
+              dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size);
+            } catch (e) {
+              return reject(e);
+            }
+            dbInfo.db.transaction(function(t) {
+              createDbTable(t, dbInfo, function() {
+                self2._dbInfo = dbInfo;
+                resolve();
+              }, function(t2, error) {
+                reject(error);
+              });
+            }, reject);
+          });
+          dbInfo.serializer = localforageSerializer;
+          return dbInfoPromise;
+        }
+        function tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) {
+          t.executeSql(sqlStatement, args, callback, function(t2, error) {
+            if (error.code === error.SYNTAX_ERR) {
+              t2.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?", [dbInfo.storeName], function(t3, results) {
+                if (!results.rows.length) {
+                  createDbTable(t3, dbInfo, function() {
+                    t3.executeSql(sqlStatement, args, callback, errorCallback);
+                  }, errorCallback);
+                } else {
+                  errorCallback(t3, error);
+                }
+              }, errorCallback);
+            } else {
+              errorCallback(t2, error);
+            }
+          }, errorCallback);
+        }
+        function getItem$1(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName + " WHERE key = ? LIMIT 1", [key2], function(t2, results) {
+                  var result = results.rows.length ? results.rows.item(0).value : null;
+                  if (result) {
+                    result = dbInfo.serializer.deserialize(result);
+                  }
+                  resolve(result);
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function iterate$1(iterator, callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName, [], function(t2, results) {
+                  var rows = results.rows;
+                  var length2 = rows.length;
+                  for (var i = 0; i < length2; i++) {
+                    var item = rows.item(i);
+                    var result = item.value;
+                    if (result) {
+                      result = dbInfo.serializer.deserialize(result);
+                    }
+                    result = iterator(result, item.key, i + 1);
+                    if (result !== void 0) {
+                      resolve(result);
+                      return;
+                    }
+                  }
+                  resolve();
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function _setItem(key2, value, callback, retriesLeft) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              if (value === void 0) {
+                value = null;
+              }
+              var originalValue = value;
+              var dbInfo = self2._dbInfo;
+              dbInfo.serializer.serialize(value, function(value2, error) {
+                if (error) {
+                  reject(error);
+                } else {
+                  dbInfo.db.transaction(function(t) {
+                    tryExecuteSql(t, dbInfo, "INSERT OR REPLACE INTO " + dbInfo.storeName + " (key, value) VALUES (?, ?)", [key2, value2], function() {
+                      resolve(originalValue);
+                    }, function(t2, error2) {
+                      reject(error2);
+                    });
+                  }, function(sqlError) {
+                    if (sqlError.code === sqlError.QUOTA_ERR) {
+                      if (retriesLeft > 0) {
+                        resolve(_setItem.apply(self2, [key2, originalValue, callback, retriesLeft - 1]));
+                        return;
+                      }
+                      reject(sqlError);
+                    }
+                  });
+                }
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function setItem$1(key2, value, callback) {
+          return _setItem.apply(this, [key2, value, callback, 1]);
+        }
+        function removeItem$1(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName + " WHERE key = ?", [key2], function() {
+                  resolve();
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function clear$1(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName, [], function() {
+                  resolve();
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function length$1(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "SELECT COUNT(key) as c FROM " + dbInfo.storeName, [], function(t2, results) {
+                  var result = results.rows.item(0).c;
+                  resolve(result);
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function key$1(n, callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName + " WHERE id = ? LIMIT 1", [n + 1], function(t2, results) {
+                  var result = results.rows.length ? results.rows.item(0).key : null;
+                  resolve(result);
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function keys$1(callback) {
+          var self2 = this;
+          var promise = new Promise$1(function(resolve, reject) {
+            self2.ready().then(function() {
+              var dbInfo = self2._dbInfo;
+              dbInfo.db.transaction(function(t) {
+                tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName, [], function(t2, results) {
+                  var keys2 = [];
+                  for (var i = 0; i < results.rows.length; i++) {
+                    keys2.push(results.rows.item(i).key);
+                  }
+                  resolve(keys2);
+                }, function(t2, error) {
+                  reject(error);
+                });
+              });
+            })["catch"](reject);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function getAllStoreNames(db) {
+          return new Promise$1(function(resolve, reject) {
+            db.transaction(function(t) {
+              t.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'", [], function(t2, results) {
+                var storeNames = [];
+                for (var i = 0; i < results.rows.length; i++) {
+                  storeNames.push(results.rows.item(i).name);
+                }
+                resolve({
+                  db,
+                  storeNames
+                });
+              }, function(t2, error) {
+                reject(error);
+              });
+            }, function(sqlError) {
+              reject(sqlError);
+            });
+          });
+        }
+        function dropInstance$1(options, callback) {
+          callback = getCallback.apply(this, arguments);
+          var currentConfig = this.config();
+          options = typeof options !== "function" && options || {};
+          if (!options.name) {
+            options.name = options.name || currentConfig.name;
+            options.storeName = options.storeName || currentConfig.storeName;
+          }
+          var self2 = this;
+          var promise;
+          if (!options.name) {
+            promise = Promise$1.reject("Invalid arguments");
+          } else {
+            promise = new Promise$1(function(resolve) {
+              var db;
+              if (options.name === currentConfig.name) {
+                db = self2._dbInfo.db;
+              } else {
+                db = openDatabase(options.name, "", "", 0);
+              }
+              if (!options.storeName) {
+                resolve(getAllStoreNames(db));
+              } else {
+                resolve({
+                  db,
+                  storeNames: [options.storeName]
+                });
+              }
+            }).then(function(operationInfo) {
+              return new Promise$1(function(resolve, reject) {
+                operationInfo.db.transaction(function(t) {
+                  function dropTable(storeName) {
+                    return new Promise$1(function(resolve2, reject2) {
+                      t.executeSql("DROP TABLE IF EXISTS " + storeName, [], function() {
+                        resolve2();
+                      }, function(t2, error) {
+                        reject2(error);
+                      });
+                    });
+                  }
+                  var operations = [];
+                  for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) {
+                    operations.push(dropTable(operationInfo.storeNames[i]));
+                  }
+                  Promise$1.all(operations).then(function() {
+                    resolve();
+                  })["catch"](function(e) {
+                    reject(e);
+                  });
+                }, function(sqlError) {
+                  reject(sqlError);
+                });
+              });
+            });
+          }
+          executeCallback(promise, callback);
+          return promise;
+        }
+        var webSQLStorage = {
+          _driver: "webSQLStorage",
+          _initStorage: _initStorage$1,
+          _support: isWebSQLValid(),
+          iterate: iterate$1,
+          getItem: getItem$1,
+          setItem: setItem$1,
+          removeItem: removeItem$1,
+          clear: clear$1,
+          length: length$1,
+          key: key$1,
+          keys: keys$1,
+          dropInstance: dropInstance$1
+        };
+        function isLocalStorageValid() {
+          try {
+            return typeof localStorage !== "undefined" && "setItem" in localStorage && // in IE8 typeof localStorage.setItem === 'object'
+            !!localStorage.setItem;
+          } catch (e) {
+            return false;
+          }
+        }
+        function _getKeyPrefix(options, defaultConfig) {
+          var keyPrefix = options.name + "/";
+          if (options.storeName !== defaultConfig.storeName) {
+            keyPrefix += options.storeName + "/";
+          }
+          return keyPrefix;
+        }
+        function checkIfLocalStorageThrows() {
+          var localStorageTestKey = "_localforage_support_test";
+          try {
+            localStorage.setItem(localStorageTestKey, true);
+            localStorage.removeItem(localStorageTestKey);
+            return false;
+          } catch (e) {
+            return true;
+          }
+        }
+        function _isLocalStorageUsable() {
+          return !checkIfLocalStorageThrows() || localStorage.length > 0;
+        }
+        function _initStorage$2(options) {
+          var self2 = this;
+          var dbInfo = {};
+          if (options) {
+            for (var i in options) {
+              dbInfo[i] = options[i];
+            }
+          }
+          dbInfo.keyPrefix = _getKeyPrefix(options, self2._defaultConfig);
+          if (!_isLocalStorageUsable()) {
+            return Promise$1.reject();
+          }
+          self2._dbInfo = dbInfo;
+          dbInfo.serializer = localforageSerializer;
+          return Promise$1.resolve();
+        }
+        function clear$2(callback) {
+          var self2 = this;
+          var promise = self2.ready().then(function() {
+            var keyPrefix = self2._dbInfo.keyPrefix;
+            for (var i = localStorage.length - 1; i >= 0; i--) {
+              var key2 = localStorage.key(i);
+              if (key2.indexOf(keyPrefix) === 0) {
+                localStorage.removeItem(key2);
+              }
+            }
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function getItem$2(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = self2.ready().then(function() {
+            var dbInfo = self2._dbInfo;
+            var result = localStorage.getItem(dbInfo.keyPrefix + key2);
+            if (result) {
+              result = dbInfo.serializer.deserialize(result);
+            }
+            return result;
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function iterate$2(iterator, callback) {
+          var self2 = this;
+          var promise = self2.ready().then(function() {
+            var dbInfo = self2._dbInfo;
+            var keyPrefix = dbInfo.keyPrefix;
+            var keyPrefixLength = keyPrefix.length;
+            var length2 = localStorage.length;
+            var iterationNumber = 1;
+            for (var i = 0; i < length2; i++) {
+              var key2 = localStorage.key(i);
+              if (key2.indexOf(keyPrefix) !== 0) {
+                continue;
+              }
+              var value = localStorage.getItem(key2);
+              if (value) {
+                value = dbInfo.serializer.deserialize(value);
+              }
+              value = iterator(value, key2.substring(keyPrefixLength), iterationNumber++);
+              if (value !== void 0) {
+                return value;
+              }
+            }
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function key$2(n, callback) {
+          var self2 = this;
+          var promise = self2.ready().then(function() {
+            var dbInfo = self2._dbInfo;
+            var result;
+            try {
+              result = localStorage.key(n);
+            } catch (error) {
+              result = null;
+            }
+            if (result) {
+              result = result.substring(dbInfo.keyPrefix.length);
+            }
+            return result;
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function keys$2(callback) {
+          var self2 = this;
+          var promise = self2.ready().then(function() {
+            var dbInfo = self2._dbInfo;
+            var length2 = localStorage.length;
+            var keys2 = [];
+            for (var i = 0; i < length2; i++) {
+              var itemKey = localStorage.key(i);
+              if (itemKey.indexOf(dbInfo.keyPrefix) === 0) {
+                keys2.push(itemKey.substring(dbInfo.keyPrefix.length));
+              }
+            }
+            return keys2;
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function length$2(callback) {
+          var self2 = this;
+          var promise = self2.keys().then(function(keys2) {
+            return keys2.length;
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function removeItem$2(key2, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = self2.ready().then(function() {
+            var dbInfo = self2._dbInfo;
+            localStorage.removeItem(dbInfo.keyPrefix + key2);
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function setItem$2(key2, value, callback) {
+          var self2 = this;
+          key2 = normalizeKey(key2);
+          var promise = self2.ready().then(function() {
+            if (value === void 0) {
+              value = null;
+            }
+            var originalValue = value;
+            return new Promise$1(function(resolve, reject) {
+              var dbInfo = self2._dbInfo;
+              dbInfo.serializer.serialize(value, function(value2, error) {
+                if (error) {
+                  reject(error);
+                } else {
+                  try {
+                    localStorage.setItem(dbInfo.keyPrefix + key2, value2);
+                    resolve(originalValue);
+                  } catch (e) {
+                    if (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED") {
+                      reject(e);
+                    }
+                    reject(e);
+                  }
+                }
+              });
+            });
+          });
+          executeCallback(promise, callback);
+          return promise;
+        }
+        function dropInstance$2(options, callback) {
+          callback = getCallback.apply(this, arguments);
+          options = typeof options !== "function" && options || {};
+          if (!options.name) {
+            var currentConfig = this.config();
+            options.name = options.name || currentConfig.name;
+            options.storeName = options.storeName || currentConfig.storeName;
+          }
+          var self2 = this;
+          var promise;
+          if (!options.name) {
+            promise = Promise$1.reject("Invalid arguments");
+          } else {
+            promise = new Promise$1(function(resolve) {
+              if (!options.storeName) {
+                resolve(options.name + "/");
+              } else {
+                resolve(_getKeyPrefix(options, self2._defaultConfig));
+              }
+            }).then(function(keyPrefix) {
+              for (var i = localStorage.length - 1; i >= 0; i--) {
+                var key2 = localStorage.key(i);
+                if (key2.indexOf(keyPrefix) === 0) {
+                  localStorage.removeItem(key2);
+                }
+              }
+            });
+          }
+          executeCallback(promise, callback);
+          return promise;
+        }
+        var localStorageWrapper = {
+          _driver: "localStorageWrapper",
+          _initStorage: _initStorage$2,
+          _support: isLocalStorageValid(),
+          iterate: iterate$2,
+          getItem: getItem$2,
+          setItem: setItem$2,
+          removeItem: removeItem$2,
+          clear: clear$2,
+          length: length$2,
+          key: key$2,
+          keys: keys$2,
+          dropInstance: dropInstance$2
+        };
+        var sameValue = function sameValue2(x, y) {
+          return x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y);
+        };
+        var includes = function includes2(array, searchElement) {
+          var len = array.length;
+          var i = 0;
+          while (i < len) {
+            if (sameValue(array[i], searchElement)) {
+              return true;
+            }
+            i++;
+          }
+          return false;
+        };
+        var isArray = Array.isArray || function(arg) {
+          return Object.prototype.toString.call(arg) === "[object Array]";
+        };
+        var DefinedDrivers = {};
+        var DriverSupport = {};
+        var DefaultDrivers = {
+          INDEXEDDB: asyncStorage,
+          WEBSQL: webSQLStorage,
+          LOCALSTORAGE: localStorageWrapper
+        };
+        var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver];
+        var OptionalDriverMethods = ["dropInstance"];
+        var LibraryMethods = ["clear", "getItem", "iterate", "key", "keys", "length", "removeItem", "setItem"].concat(OptionalDriverMethods);
+        var DefaultConfig = {
+          description: "",
+          driver: DefaultDriverOrder.slice(),
+          name: "localforage",
+          // Default DB size is _JUST UNDER_ 5MB, as it's the highest size
+          // we can use without a prompt.
+          size: 4980736,
+          storeName: "keyvaluepairs",
+          version: 1
+        };
+        function callWhenReady(localForageInstance, libraryMethod) {
+          localForageInstance[libraryMethod] = function() {
+            var _args = arguments;
+            return localForageInstance.ready().then(function() {
+              return localForageInstance[libraryMethod].apply(localForageInstance, _args);
+            });
+          };
+        }
+        function extend() {
+          for (var i = 1; i < arguments.length; i++) {
+            var arg = arguments[i];
+            if (arg) {
+              for (var _key in arg) {
+                if (arg.hasOwnProperty(_key)) {
+                  if (isArray(arg[_key])) {
+                    arguments[0][_key] = arg[_key].slice();
+                  } else {
+                    arguments[0][_key] = arg[_key];
+                  }
+                }
+              }
+            }
+          }
+          return arguments[0];
+        }
+        var LocalForage2 = function() {
+          function LocalForage3(options) {
+            _classCallCheck(this, LocalForage3);
+            for (var driverTypeKey in DefaultDrivers) {
+              if (DefaultDrivers.hasOwnProperty(driverTypeKey)) {
+                var driver = DefaultDrivers[driverTypeKey];
+                var driverName = driver._driver;
+                this[driverTypeKey] = driverName;
+                if (!DefinedDrivers[driverName]) {
+                  this.defineDriver(driver);
+                }
+              }
+            }
+            this._defaultConfig = extend({}, DefaultConfig);
+            this._config = extend({}, this._defaultConfig, options);
+            this._driverSet = null;
+            this._initDriver = null;
+            this._ready = false;
+            this._dbInfo = null;
+            this._wrapLibraryMethodsWithReady();
+            this.setDriver(this._config.driver)["catch"](function() {
+            });
+          }
+          LocalForage3.prototype.config = function config(options) {
+            if ((typeof options === "undefined" ? "undefined" : _typeof(options)) === "object") {
+              if (this._ready) {
+                return new Error("Can't call config() after localforage has been used.");
+              }
+              for (var i in options) {
+                if (i === "storeName") {
+                  options[i] = options[i].replace(/\W/g, "_");
+                }
+                if (i === "version" && typeof options[i] !== "number") {
+                  return new Error("Database version must be a number.");
+                }
+                this._config[i] = options[i];
+              }
+              if ("driver" in options && options.driver) {
+                return this.setDriver(this._config.driver);
+              }
+              return true;
+            } else if (typeof options === "string") {
+              return this._config[options];
+            } else {
+              return this._config;
+            }
+          };
+          LocalForage3.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {
+            var promise = new Promise$1(function(resolve, reject) {
+              try {
+                var driverName = driverObject._driver;
+                var complianceError = new Error("Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver");
+                if (!driverObject._driver) {
+                  reject(complianceError);
+                  return;
+                }
+                var driverMethods = LibraryMethods.concat("_initStorage");
+                for (var i = 0, len = driverMethods.length; i < len; i++) {
+                  var driverMethodName = driverMethods[i];
+                  var isRequired = !includes(OptionalDriverMethods, driverMethodName);
+                  if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== "function") {
+                    reject(complianceError);
+                    return;
+                  }
+                }
+                var configureMissingMethods = function configureMissingMethods2() {
+                  var methodNotImplementedFactory = function methodNotImplementedFactory2(methodName) {
+                    return function() {
+                      var error = new Error("Method " + methodName + " is not implemented by the current driver");
+                      var promise2 = Promise$1.reject(error);
+                      executeCallback(promise2, arguments[arguments.length - 1]);
+                      return promise2;
+                    };
+                  };
+                  for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) {
+                    var optionalDriverMethod = OptionalDriverMethods[_i];
+                    if (!driverObject[optionalDriverMethod]) {
+                      driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod);
+                    }
+                  }
+                };
+                configureMissingMethods();
+                var setDriverSupport = function setDriverSupport2(support) {
+                  if (DefinedDrivers[driverName]) {
+                    console.info("Redefining LocalForage driver: " + driverName);
+                  }
+                  DefinedDrivers[driverName] = driverObject;
+                  DriverSupport[driverName] = support;
+                  resolve();
+                };
+                if ("_support" in driverObject) {
+                  if (driverObject._support && typeof driverObject._support === "function") {
+                    driverObject._support().then(setDriverSupport, reject);
+                  } else {
+                    setDriverSupport(!!driverObject._support);
+                  }
+                } else {
+                  setDriverSupport(true);
+                }
+              } catch (e) {
+                reject(e);
+              }
+            });
+            executeTwoCallbacks(promise, callback, errorCallback);
+            return promise;
+          };
+          LocalForage3.prototype.driver = function driver() {
+            return this._driver || null;
+          };
+          LocalForage3.prototype.getDriver = function getDriver(driverName, callback, errorCallback) {
+            var getDriverPromise = DefinedDrivers[driverName] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error("Driver not found."));
+            executeTwoCallbacks(getDriverPromise, callback, errorCallback);
+            return getDriverPromise;
+          };
+          LocalForage3.prototype.getSerializer = function getSerializer(callback) {
+            var serializerPromise = Promise$1.resolve(localforageSerializer);
+            executeTwoCallbacks(serializerPromise, callback);
+            return serializerPromise;
+          };
+          LocalForage3.prototype.ready = function ready(callback) {
+            var self2 = this;
+            var promise = self2._driverSet.then(function() {
+              if (self2._ready === null) {
+                self2._ready = self2._initDriver();
+              }
+              return self2._ready;
+            });
+            executeTwoCallbacks(promise, callback, callback);
+            return promise;
+          };
+          LocalForage3.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {
+            var self2 = this;
+            if (!isArray(drivers)) {
+              drivers = [drivers];
+            }
+            var supportedDrivers = this._getSupportedDrivers(drivers);
+            function setDriverToConfig() {
+              self2._config.driver = self2.driver();
+            }
+            function extendSelfWithDriver(driver) {
+              self2._extend(driver);
+              setDriverToConfig();
+              self2._ready = self2._initStorage(self2._config);
+              return self2._ready;
+            }
+            function initDriver(supportedDrivers2) {
+              return function() {
+                var currentDriverIndex = 0;
+                function driverPromiseLoop() {
+                  while (currentDriverIndex < supportedDrivers2.length) {
+                    var driverName = supportedDrivers2[currentDriverIndex];
+                    currentDriverIndex++;
+                    self2._dbInfo = null;
+                    self2._ready = null;
+                    return self2.getDriver(driverName).then(extendSelfWithDriver)["catch"](driverPromiseLoop);
+                  }
+                  setDriverToConfig();
+                  var error = new Error("No available storage method found.");
+                  self2._driverSet = Promise$1.reject(error);
+                  return self2._driverSet;
+                }
+                return driverPromiseLoop();
+              };
+            }
+            var oldDriverSetDone = this._driverSet !== null ? this._driverSet["catch"](function() {
+              return Promise$1.resolve();
+            }) : Promise$1.resolve();
+            this._driverSet = oldDriverSetDone.then(function() {
+              var driverName = supportedDrivers[0];
+              self2._dbInfo = null;
+              self2._ready = null;
+              return self2.getDriver(driverName).then(function(driver) {
+                self2._driver = driver._driver;
+                setDriverToConfig();
+                self2._wrapLibraryMethodsWithReady();
+                self2._initDriver = initDriver(supportedDrivers);
+              });
+            })["catch"](function() {
+              setDriverToConfig();
+              var error = new Error("No available storage method found.");
+              self2._driverSet = Promise$1.reject(error);
+              return self2._driverSet;
+            });
+            executeTwoCallbacks(this._driverSet, callback, errorCallback);
+            return this._driverSet;
+          };
+          LocalForage3.prototype.supports = function supports(driverName) {
+            return !!DriverSupport[driverName];
+          };
+          LocalForage3.prototype._extend = function _extend(libraryMethodsAndProperties) {
+            extend(this, libraryMethodsAndProperties);
+          };
+          LocalForage3.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) {
+            var supportedDrivers = [];
+            for (var i = 0, len = drivers.length; i < len; i++) {
+              var driverName = drivers[i];
+              if (this.supports(driverName)) {
+                supportedDrivers.push(driverName);
+              }
+            }
+            return supportedDrivers;
+          };
+          LocalForage3.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() {
+            for (var i = 0, len = LibraryMethods.length; i < len; i++) {
+              callWhenReady(this, LibraryMethods[i]);
+            }
+          };
+          LocalForage3.prototype.createInstance = function createInstance(options) {
+            return new LocalForage3(options);
+          };
+          return LocalForage3;
+        }();
+        var localforage_js = new LocalForage2();
+        module3.exports = localforage_js;
+      }, { "3": 3 }] }, {}, [4])(4);
+    });
+  }
+});
+
+// ../../packages/document-drive/dist/src/utils/migrations.js
+function migrateDocumentOperationSignatures(document) {
+  let legacy = false;
+  const operations = Object.entries(document.operations).reduce((acc, [key, operations2]) => {
+    const scope = key;
+    for (const op of operations2) {
+      const newOp = migrateLegacyOperationSignature(op);
+      acc[scope].push(newOp);
+      if (newOp !== op) {
+        legacy = true;
+      }
+    }
+    return acc;
+  }, { global: [], local: [] });
+  return legacy ? { ...document, operations } : document;
+}
+function migrateLegacyOperationSignature(operation) {
+  if (!operation.context?.signer || operation.context.signer.signatures) {
+    return operation;
+  }
+  const { signer } = operation.context;
+  if ("signature" in signer) {
+    const signature = signer.signature;
+    return {
+      ...operation,
+      context: {
+        ...operation.context,
+        signer: {
+          user: signer.user,
+          app: signer.app,
+          signatures: signature?.length ? [signature] : []
+        }
+      }
+    };
+  } else {
+    return operation;
+  }
+}
+
+// ../../packages/document-drive/dist/src/storage/browser.js
+var import_localforage = __toESM(require_localforage(), 1);
+var BrowserStorage = class _BrowserStorage {
+  db;
+  static DBName = "DOCUMENT_DRIVES";
+  static SEP = ":";
+  static DOCUMENT_KEY = "DOCUMENT";
+  static MANIFEST_KEY = "MANIFEST";
+  constructor(namespace) {
+    this.db = import_localforage.default.ready().then(() => import_localforage.default.createInstance({
+      name: namespace ? `${namespace}:${_BrowserStorage.DBName}` : _BrowserStorage.DBName
+    }));
+  }
+  async clear() {
+    const db = await this.db;
+    await db.clear();
+  }
+  ////////////////////////////////
+  // IDocumentStorage
+  ////////////////////////////////
+  async exists(documentId) {
+    const db = await this.db;
+    const document = await db.getItem(this.buildDocumentKey(documentId));
+    return !!document;
+  }
+  async create(documentId, document) {
+    const db = await this.db;
+    await db.setItem(this.buildDocumentKey(documentId), document);
+  }
+  async get(documentId) {
+    const db = await this.db;
+    const document = await db.getItem(this.buildDocumentKey(documentId));
+    if (!document) {
+      throw new Error(`Document with id ${documentId} not found`);
+    }
+    return document;
+  }
+  async delete(documentId) {
+    const db = await this.db;
+    const document = await db.getItem(this.buildDocumentKey(documentId));
+    if (!document) {
+      return false;
+    }
+    const drives = await this.getDrives();
+    for (const driveId of drives) {
+      if (driveId === documentId)
+        continue;
+      await this.removeChild(driveId, documentId);
+    }
+    await db.removeItem(this.buildManifestKey(documentId));
+    await db.removeItem(this.buildDocumentKey(documentId));
+    return true;
+  }
+  async removeChild(parentId, childId) {
+    const manifest = await this.getManifest(parentId);
+    const docIndex = manifest.documentIds.indexOf(childId);
+    if (docIndex !== -1) {
+      manifest.documentIds.splice(docIndex, 1);
+      await this.updateDriveManifest(parentId, manifest);
+      return true;
+    }
+    return false;
+  }
+  async addChild(parentId, childId) {
+    if (parentId === childId) {
+      throw new Error("Cannot associate a document with itself");
+    }
+    const children = await this.getChildren(childId);
+    if (children.includes(parentId)) {
+      throw new Error("Cannot associate a document with its child");
+    }
+    const manifest = await this.getManifest(parentId);
+    if (!manifest.documentIds.includes(childId)) {
+      manifest.documentIds.push(childId);
+      await this.updateDriveManifest(parentId, manifest);
+    }
+  }
+  async getChildren(parentId) {
+    const manifest = await this.getManifest(parentId);
+    return manifest.documentIds;
+  }
+  ////////////////////////////////
+  // IDriveStorage
+  ////////////////////////////////
+  checkDocumentExists(drive, documentId) {
+    return this.exists(documentId);
+  }
+  async getManifest(driveId) {
+    const db = await this.db;
+    const manifest = await db.getItem(this.buildManifestKey(driveId));
+    return manifest || { documentIds: [] };
+  }
+  async updateDriveManifest(driveId, manifest) {
+    const db = await this.db;
+    await db.setItem(this.buildManifestKey(driveId), manifest);
+  }
+  async getDocuments(drive) {
+    const manifest = await this.getManifest(drive);
+    return manifest.documentIds;
+  }
+  async getDocument(driveId, id) {
+    return this.get(id);
+  }
+  async createDocument(drive, id, document) {
+    await this.create(id, document);
+    const manifest = await this.getManifest(drive);
+    if (!manifest.documentIds.includes(id)) {
+      manifest.documentIds.push(id);
+      await this.updateDriveManifest(drive, manifest);
+    }
+  }
+  async deleteDocument(drive, id) {
+    await (await this.db).removeItem(this.buildDocumentKey(id));
+    const manifest = await this.getManifest(drive);
+    const docIndex = manifest.documentIds.indexOf(id);
+    if (docIndex !== -1) {
+      manifest.documentIds.splice(docIndex, 1);
+      await this.updateDriveManifest(drive, manifest);
+    }
+  }
+  async clearStorage() {
+    return (await this.db).clear();
+  }
+  async addDocumentOperations(drive, id, operations, header) {
+    const document = await this.getDocument(drive, id);
+    if (!document) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+    const mergedOperations = mergeOperations(document.operations, operations);
+    const db = await this.db;
+    await db.setItem(this.buildDocumentKey(id), {
+      ...document,
+      ...header,
+      operations: mergedOperations
+    });
+  }
+  async getDrives() {
+    const db = await this.db;
+    const keys = await db.keys();
+    return keys.filter((key) => key.startsWith(_BrowserStorage.MANIFEST_KEY)).map((key) => key.slice(_BrowserStorage.MANIFEST_KEY.length + _BrowserStorage.SEP.length));
+  }
+  async getDrive(id) {
+    let drive;
+    try {
+      drive = await this.get(id);
+    } catch {
+      throw new DriveNotFoundError(id);
+    }
+    return drive;
+  }
+  async getDriveBySlug(slug) {
+    const drives = (await this.getDrives()).reverse();
+    for (const drive of drives) {
+      const driveData = await this.getDrive(drive);
+      if (driveData.initialState.state.global.slug === slug) {
+        return this.getDrive(drive);
+      }
+    }
+    throw new Error(`Drive with slug ${slug} not found`);
+  }
+  async createDrive(id, drive) {
+    const slug = drive.initialState.state.global.slug;
+    if (slug) {
+      let existingDrive;
+      try {
+        existingDrive = await this.getDriveBySlug(slug);
+      } catch {
+      }
+      if (existingDrive) {
+        throw new Error(`Drive with slug ${slug} already exists`);
+      }
+    }
+    await this.create(id, drive);
+    await this.updateDriveManifest(id, { documentIds: [] });
+  }
+  async deleteDrive(id) {
+    const documents = await this.getDocuments(id);
+    await Promise.all(documents.map((doc) => this.deleteDocument(id, doc)));
+    const db = await this.db;
+    await db.removeItem(this.buildManifestKey(id));
+    return db.removeItem(this.buildDocumentKey(id));
+  }
+  async addDriveOperations(id, operations, header) {
+    const drive = await this.getDrive(id);
+    const mergedOperations = mergeOperations(drive.operations, operations);
+    const db = await this.db;
+    await db.setItem(this.buildDocumentKey(id), {
+      ...drive,
+      ...header,
+      operations: mergedOperations
+    });
+  }
+  async getSynchronizationUnitsRevision(units) {
+    const results = await Promise.allSettled(units.map(async (unit) => {
+      try {
+        const document = await this.get(unit.documentId);
+        if (!document) {
+          return void 0;
+        }
+        const operation = document.operations[unit.scope].at(-1);
+        if (operation) {
+          return {
+            documentId: unit.documentId,
+            scope: unit.scope,
+            branch: unit.branch,
+            lastUpdated: operation.timestamp,
+            revision: operation.index
+          };
+        }
+      } catch {
+        return void 0;
+      }
+    }));
+    return results.reduce((acc, curr) => {
+      if (curr.status === "fulfilled" && curr.value !== void 0) {
+        acc.push(curr.value);
+      }
+      return acc;
+    }, []);
+  }
+  // migrates all stored operations from legacy signature to signatures array
+  async migrateOperationSignatures() {
+    const drives = await this.getDrives();
+    for (const drive of drives) {
+      await this.migrateDrive(drive);
+      const documents = await this.getDocuments(drive);
+      await Promise.all(documents.map(async (docId) => this.migrateDocument(drive, docId)));
+    }
+  }
+  async migrateDrive(driveId) {
+    const drive = await this.getDrive(driveId);
+    const migratedDrive = migrateDocumentOperationSignatures(drive);
+    if (migratedDrive !== drive) {
+      return (await this.db).setItem(this.buildDocumentKey(driveId), migratedDrive);
+    }
+  }
+  async migrateDocument(drive, id) {
+    const document = await this.getDocument(drive, id);
+    const migratedDocument = migrateDocumentOperationSignatures(document);
+    if (migratedDocument !== document) {
+      return (await this.db).setItem(this.buildDocumentKey(id), migratedDocument);
+    }
+  }
+  ////////////////////////////////
+  // Private methods
+  ////////////////////////////////
+  buildDocumentKey(documentId) {
+    return `${_BrowserStorage.DOCUMENT_KEY}${_BrowserStorage.SEP}${documentId}`;
+  }
+  buildManifestKey(driveId) {
+    return `${_BrowserStorage.MANIFEST_KEY}${_BrowserStorage.SEP}${driveId}`;
+  }
+};
+
+// ../../packages/reactor-browser/dist/src/reactor.js
+var getReactorDefaultDrivesConfig = (config = {}) => {
+  const defaultDrivesUrl = config.defaultDrivesUrl || [];
+  const remoteDrives = defaultDrivesUrl.map((driveUrl) => ({
+    url: driveUrl,
+    options: {
+      sharingType: "PUBLIC",
+      availableOffline: true,
+      listeners: [
+        {
+          block: true,
+          callInfo: {
+            data: driveUrl,
+            name: "switchboard-push",
+            transmitterType: "SwitchboardPush"
+          },
+          filter: {
+            branch: ["main"],
+            documentId: ["*"],
+            documentType: ["*"],
+            scope: ["global"]
+          },
+          label: "Switchboard Sync",
+          listenerId: "1",
+          system: true
+        }
+      ],
+      triggers: []
+    }
+  }));
+  return {
+    defaultDrives: {
+      remoteDrives,
+      removeOldRemoteDrives: defaultDrivesUrl.length > 0 ? {
+        strategy: "preserve-by-url-and-detach",
+        urls: defaultDrivesUrl
+      } : { strategy: "preserve-all" }
+    }
+  };
+};
+function createBrowserDocumentDriveServer(documentModelModules, routerBasename, documentDriveServerOptions) {
+  const builder = new ReactorBuilder(documentModelModules).withStorage(new BrowserStorage(routerBasename)).withCache(new memory_default()).withQueueManager(new BaseQueueManager(1, 10));
+  if (documentDriveServerOptions) {
+    builder.withOptions(documentDriveServerOptions);
+  }
+  return builder.build();
+}
+
+export {
+  getReactorDefaultDrivesConfig,
+  createBrowserDocumentDriveServer
+};
+/*! Bundled license information:
+
+localforage/dist/localforage.js:
+  (*!
+      localForage -- Offline Storage, Improved
+      Version 1.10.0
+      https://localforage.github.io/localForage
+      (c) 2013-2017 Mozilla, Apache License 2.0
+  *)
+*/