@basictech/react 0.1.1-beta.0 → 0.2.0-beta.2

package/dist/index.mjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_dexie = __commonJS({
   "../../node_modules/dexie/dist/dexie.js"(exports, module) {
     "use strict";
-    (function(global2, factory) {
-      typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.Dexie = factory());
+    (function(global3, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global3 = typeof globalThis !== "undefined" ? globalThis : global3 || self, global3.Dexie = factory());
     })(exports, function() {
       "use strict";
       var extendStatics = function(d, b) {
@@ -125,7 +125,7 @@ var require_dexie = __commonJS({
       function slice(args, start, end) {
         return _slice.call(args, start, end);
       }
-      function override(origFunc, overridedFactory) {
+      function override3(origFunc, overridedFactory) {
         return overridedFactory(origFunc);
       }
       function assert(b) {
@@ -460,7 +460,7 @@ var require_dexie = __commonJS({
       fullNameExceptions.ModifyError = ModifyError;
       fullNameExceptions.DexieError = DexieError;
       fullNameExceptions.BulkError = BulkError;
-      function nop() {
+      function nop2() {
       }
       function mirror(val) {
         return val;
@@ -479,7 +479,7 @@ var require_dexie = __commonJS({
         };
       }
       function hookCreatingChain(f1, f2) {
-        if (f1 === nop)
+        if (f1 === nop2)
           return f2;
         return function() {
           var res = f1.apply(this, arguments);
@@ -497,7 +497,7 @@ var require_dexie = __commonJS({
         };
       }
       function hookDeletingChain(f1, f2) {
-        if (f1 === nop)
+        if (f1 === nop2)
           return f2;
         return function() {
           f1.apply(this, arguments);
@@ -511,7 +511,7 @@ var require_dexie = __commonJS({
         };
       }
       function hookUpdatingChain(f1, f2) {
-        if (f1 === nop)
+        if (f1 === nop2)
           return f2;
         return function(modifications) {
           var res = f1.apply(this, arguments);
@@ -528,7 +528,7 @@ var require_dexie = __commonJS({
         };
       }
       function reverseStoppableEventChain(f1, f2) {
-        if (f1 === nop)
+        if (f1 === nop2)
           return f2;
         return function() {
           if (f2.apply(this, arguments) === false)
@@ -536,8 +536,8 @@ var require_dexie = __commonJS({
           return f1.apply(this, arguments);
         };
       }
-      function promisableChain(f1, f2) {
-        if (f1 === nop)
+      function promisableChain2(f1, f2) {
+        if (f1 === nop2)
           return f2;
         return function() {
           var res = f1.apply(this, arguments);
@@ -586,10 +586,10 @@ var require_dexie = __commonJS({
         global: true,
         ref: 0,
         unhandleds: [],
-        onunhandled: nop,
+        onunhandled: nop2,
         pgp: false,
         env: {},
-        finalize: nop
+        finalize: nop2
       };
       var PSD = globalPSD;
       var microtickQueue = [];
@@ -1027,7 +1027,7 @@ var require_dexie = __commonJS({
         return true;
       }
       if (("" + nativePromiseThen).indexOf("[native code]") === -1) {
-        incrementExpectedAwaits = decrementExpectedAwaits = nop;
+        incrementExpectedAwaits = decrementExpectedAwaits = nop2;
       }
       function onPossibleParallellAsync(possiblePromise) {
         if (task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) {
@@ -1138,7 +1138,7 @@ var require_dexie = __commonJS({
           if (!db._state.isBeingOpened) {
             if (!db._state.autoOpen)
               return rejection(new exceptions.DatabaseClosed());
-            db.open().catch(nop);
+            db.open().catch(nop2);
           }
           return db._state.dbReadyPromise.then(function() {
             return tempTransaction(db, mode, storeNames, fn);
@@ -1685,7 +1685,7 @@ var require_dexie = __commonJS({
           if (!chainFunction)
             chainFunction = reverseStoppableEventChain;
           if (!defaultFunction)
-            defaultFunction = nop;
+            defaultFunction = nop2;
           var context = {
             subscribers: [],
             fire: defaultFunction,
@@ -1737,10 +1737,10 @@ var require_dexie = __commonJS({
           this.name = name;
           this.schema = tableSchema;
           this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, {
-            "creating": [hookCreatingChain, nop],
+            "creating": [hookCreatingChain, nop2],
             "reading": [pureFunctionChain, mirror],
-            "updating": [hookUpdatingChain, nop],
-            "deleting": [hookDeletingChain, nop]
+            "updating": [hookUpdatingChain, nop2],
+            "deleting": [hookDeletingChain, nop2]
           });
         });
       }
@@ -1824,10 +1824,10 @@ var require_dexie = __commonJS({
                 return c = advancer;
               }, function(val) {
                 cursor.stop(val);
-                c = nop;
+                c = nop2;
               }, function(e) {
                 cursor.fail(e);
-                c = nop;
+                c = nop2;
               }))
                 wrappedFn(cursor.value, cursor, function(advancer) {
                   return c = advancer;
@@ -3767,7 +3767,7 @@ var require_dexie = __commonJS({
           return this;
         };
         Version2.prototype.upgrade = function(upgradeFunction) {
-          this._cfg.contentUpgrade = promisableChain(this._cfg.contentUpgrade || nop, upgradeFunction);
+          this._cfg.contentUpgrade = promisableChain2(this._cfg.contentUpgrade || nop2, upgradeFunction);
           return this;
         };
         return Version2;
@@ -3811,11 +3811,11 @@ var require_dexie = __commonJS({
       }
       function _onDatabaseCreated(_a2, name) {
         var indexedDB2 = _a2.indexedDB, IDBKeyRange = _a2.IDBKeyRange;
-        !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).put({ name }).catch(nop);
+        !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).put({ name }).catch(nop2);
       }
       function _onDatabaseDeleted(_a2, name) {
         var indexedDB2 = _a2.indexedDB, IDBKeyRange = _a2.IDBKeyRange;
-        !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).delete(name).catch(nop);
+        !hasDatabasesNative(indexedDB2) && name !== DBNAMES_DB && getDbNamesTable(indexedDB2, IDBKeyRange).delete(name).catch(nop2);
       }
       function vip(fn) {
         return newScope(function() {
@@ -4187,7 +4187,7 @@ var require_dexie = __commonJS({
             return db.on.ready.fire(db.vip);
           })).then(function fireRemainders() {
             if (state.onReadyBeingFired.length > 0) {
-              var remainders_1 = state.onReadyBeingFired.reduce(promisableChain, nop);
+              var remainders_1 = state.onReadyBeingFired.reduce(promisableChain2, nop2);
               state.onReadyBeingFired = [];
               return DexiePromise.resolve(vip(function() {
                 return remainders_1(db.vip);
@@ -4467,25 +4467,25 @@ var require_dexie = __commonJS({
               var _a2 = dxTrans.table(tableName).hook, deleting = _a2.deleting, creating = _a2.creating, updating = _a2.updating;
               switch (req.type) {
                 case "add":
-                  if (creating.fire === nop)
+                  if (creating.fire === nop2)
                     break;
                   return dxTrans._promise("readwrite", function() {
                     return addPutOrDelete(req);
                   }, true);
                 case "put":
-                  if (creating.fire === nop && updating.fire === nop)
+                  if (creating.fire === nop2 && updating.fire === nop2)
                     break;
                   return dxTrans._promise("readwrite", function() {
                     return addPutOrDelete(req);
                   }, true);
                 case "delete":
-                  if (deleting.fire === nop)
+                  if (deleting.fire === nop2)
                     break;
                   return dxTrans._promise("readwrite", function() {
                     return addPutOrDelete(req);
                   }, true);
                 case "deleteRange":
-                  if (deleting.fire === nop)
+                  if (deleting.fire === nop2)
                     break;
                   return dxTrans._promise("readwrite", function() {
                     return deleteRange(req);
@@ -5280,9 +5280,9 @@ var require_dexie = __commonJS({
             isBeingOpened: false,
             onReadyBeingFired: null,
             openComplete: false,
-            dbReadyResolve: nop,
+            dbReadyResolve: nop2,
             dbReadyPromise: null,
-            cancelOpen: nop,
+            cancelOpen: nop2,
             openCanceller: null,
             autoSchema: true,
             PR1398_maxLoop: 3,
@@ -5296,8 +5296,8 @@ var require_dexie = __commonJS({
           });
           this._state = state;
           this.name = name;
-          this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain, nop] });
-          this.on.ready.subscribe = override(this.on.ready.subscribe, function(subscribe) {
+          this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain2, nop2] });
+          this.on.ready.subscribe = override3(this.on.ready.subscribe, function(subscribe) {
             return function(subscriber, bSticky) {
               Dexie3.vip(function() {
                 var state2 = _this._state;
@@ -5416,7 +5416,7 @@ var require_dexie = __commonJS({
                 reject(new exceptions.DatabaseClosed());
                 return;
               }
-              _this.open().catch(nop);
+              _this.open().catch(nop2);
             }
             _this._state.dbReadyPromise.then(resolve, reject);
           }).then(fn);
@@ -5606,17 +5606,17 @@ var require_dexie = __commonJS({
         return Dexie3;
       }();
       var symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol ? Symbol.observable : "@@observable";
-      var Observable = function() {
-        function Observable2(subscribe) {
+      var Observable3 = function() {
+        function Observable4(subscribe) {
           this._subscribe = subscribe;
         }
-        Observable2.prototype.subscribe = function(x, error, complete) {
+        Observable4.prototype.subscribe = function(x, error, complete) {
           return this._subscribe(!x || typeof x === "function" ? { next: x, error, complete } : x);
         };
-        Observable2.prototype[symbolObservable] = function() {
+        Observable4.prototype[symbolObservable] = function() {
           return this;
         };
-        return Observable2;
+        return Observable4;
       }();
       var domDeps;
       try {
@@ -5630,7 +5630,7 @@ var require_dexie = __commonJS({
       function liveQuery2(querier) {
         var hasValue = false;
         var currentValue;
-        var observable = new Observable(function(observer) {
+        var observable = new Observable3(function(observer) {
           var scopeFuncIsAsync = isAsyncFunction(querier);
           function execute(ctx) {
             var wasRootExec = beginMicroTickScope();
@@ -5808,7 +5808,7 @@ var require_dexie = __commonJS({
         derive,
         extend,
         props,
-        override,
+        override: override3,
         Events,
         on: globalEvents,
         liveQuery: liveQuery2,
@@ -5942,7 +5942,2029 @@ var require_dexie = __commonJS({
 // src/AuthContext.tsx
 import { createContext, useContext, useEffect, useState, useRef } from "react";
 import { jwtDecode } from "jwt-decode";
-import { BasicSync } from "@repo/sync";
+
+// ../../node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/uuid/dist/esm-node/rng.js
+import crypto2 from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto2.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm-node/v7.js
+var _seqLow = null;
+var _seqHigh = null;
+var _msecs = 0;
+function v7(options, buf, offset) {
+  options = options || {};
+  let i = buf && offset || 0;
+  const b = buf || new Uint8Array(16);
+  const rnds = options.random || (options.rng || rng)();
+  const msecs = options.msecs !== void 0 ? options.msecs : Date.now();
+  let seq = options.seq !== void 0 ? options.seq : null;
+  let seqHigh = _seqHigh;
+  let seqLow = _seqLow;
+  if (msecs > _msecs && options.msecs === void 0) {
+    _msecs = msecs;
+    if (seq !== null) {
+      seqHigh = null;
+      seqLow = null;
+    }
+  }
+  if (seq !== null) {
+    if (seq > 2147483647) {
+      seq = 2147483647;
+    }
+    seqHigh = seq >>> 19 & 4095;
+    seqLow = seq & 524287;
+  }
+  if (seqHigh === null || seqLow === null) {
+    seqHigh = rnds[6] & 127;
+    seqHigh = seqHigh << 8 | rnds[7];
+    seqLow = rnds[8] & 63;
+    seqLow = seqLow << 8 | rnds[9];
+    seqLow = seqLow << 5 | rnds[10] >>> 3;
+  }
+  if (msecs + 1e4 > _msecs && seq === null) {
+    if (++seqLow > 524287) {
+      seqLow = 0;
+      if (++seqHigh > 4095) {
+        seqHigh = 0;
+        _msecs++;
+      }
+    }
+  } else {
+    _msecs = msecs;
+  }
+  _seqHigh = seqHigh;
+  _seqLow = seqLow;
+  b[i++] = _msecs / 1099511627776 & 255;
+  b[i++] = _msecs / 4294967296 & 255;
+  b[i++] = _msecs / 16777216 & 255;
+  b[i++] = _msecs / 65536 & 255;
+  b[i++] = _msecs / 256 & 255;
+  b[i++] = _msecs & 255;
+  b[i++] = seqHigh >>> 4 & 15 | 112;
+  b[i++] = seqHigh & 255;
+  b[i++] = seqLow >>> 13 & 63 | 128;
+  b[i++] = seqLow >>> 5 & 255;
+  b[i++] = seqLow << 3 & 255 | rnds[10] & 7;
+  b[i++] = rnds[11];
+  b[i++] = rnds[12];
+  b[i++] = rnds[13];
+  b[i++] = rnds[14];
+  b[i++] = rnds[15];
+  return buf || unsafeStringify(b);
+}
+var v7_default = v7;
+
+// ../../node_modules/dexie/import-wrapper.mjs
+var import_dexie = __toESM(require_dexie(), 1);
+var DexieSymbol = Symbol.for("Dexie");
+var Dexie = globalThis[DexieSymbol] || (globalThis[DexieSymbol] = import_dexie.default);
+if (import_dexie.default.semVer !== Dexie.semVer) {
+  throw new Error(`Two different versions of Dexie loaded in the same app: ${import_dexie.default.semVer} and ${Dexie.semVer}`);
+}
+var {
+  liveQuery,
+  mergeRanges,
+  rangesOverlap,
+  RangeSet,
+  cmp,
+  Entity,
+  PropModSymbol,
+  PropModification,
+  replacePrefix,
+  add,
+  remove
+} = Dexie;
+var import_wrapper_default = Dexie;
+
+// ../../node_modules/dexie-observable/dist/dexie-observable.es.js
+function nop() {
+}
+function promisableChain(f1, f2) {
+  if (f1 === nop)
+    return f2;
+  return function() {
+    var res = f1.apply(this, arguments);
+    if (res && typeof res.then === "function") {
+      var thiz = this, args = arguments;
+      return res.then(function() {
+        return f2.apply(thiz, args);
+      });
+    }
+    return f2.apply(this, arguments);
+  };
+}
+function createUUID() {
+  var d = Date.now();
+  var uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    var r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === "x" ? r : r & 7 | 8).toString(16);
+  });
+  return uuid;
+}
+function initOverrideCreateTransaction(db, wakeupObservers) {
+  return function overrideCreateTransaction(origFunc) {
+    return function(mode, storenames, dbschema, parent) {
+      if (db.dynamicallyOpened())
+        return origFunc.apply(this, arguments);
+      var addChanges = false;
+      if (mode === "readwrite" && storenames.some(function(storeName) {
+        return dbschema[storeName] && dbschema[storeName].observable;
+      })) {
+        addChanges = true;
+        storenames = storenames.slice(0);
+        if (storenames.indexOf("_changes") === -1)
+          storenames.push("_changes");
+      }
+      var trans = origFunc.call(this, mode, storenames, dbschema, parent);
+      if (addChanges) {
+        trans._lastWrittenRevision = 0;
+        trans.on("complete", function() {
+          if (trans._lastWrittenRevision) {
+            if (!parent) {
+              if (wakeupObservers.timeoutHandle)
+                clearTimeout(wakeupObservers.timeoutHandle);
+              wakeupObservers.timeoutHandle = setTimeout(function() {
+                delete wakeupObservers.timeoutHandle;
+                wakeupObservers(trans._lastWrittenRevision);
+              }, 25);
+            } else {
+              var rootTransaction = function findRootTransaction(trans2) {
+                return trans2.parent ? findRootTransaction(trans2.parent) : trans2;
+              }(parent);
+              rootTransaction._lastWrittenRevision = Math.max(trans._lastWrittenRevision, rootTransaction.lastWrittenRevision || 0);
+            }
+          }
+        });
+        if (trans.parent && trans.parent.source)
+          trans.source = trans.parent.source;
+      }
+      return trans;
+    };
+  };
+}
+function initWakeupObservers(db, Observable3, localStorage) {
+  return function wakeupObservers(lastWrittenRevision) {
+    if (Observable3.latestRevision[db.name] < lastWrittenRevision) {
+      Observable3.latestRevision[db.name] = lastWrittenRevision;
+      import_wrapper_default.ignoreTransaction(function() {
+        Observable3.on("latestRevisionIncremented").fire(db.name, lastWrittenRevision);
+      });
+      if (localStorage)
+        localStorage.setItem("Dexie.Observable/latestRevision/" + db.name, lastWrittenRevision);
+    }
+  };
+}
+var CREATE = 1;
+var UPDATE = 2;
+var DELETE = 3;
+function initCreatingHook(db, table) {
+  return function creatingHook(primKey, obj, trans) {
+    var rv = void 0;
+    if (primKey === void 0 && table.schema.primKey.uuid) {
+      primKey = rv = import_wrapper_default.Observable.createUUID();
+      if (table.schema.primKey.keyPath) {
+        import_wrapper_default.setByKeyPath(obj, table.schema.primKey.keyPath, primKey);
+      }
+    }
+    var change = {
+      source: trans.source || null,
+      table: table.name,
+      key: primKey === void 0 ? null : primKey,
+      type: CREATE,
+      obj
+    };
+    var promise = db._changes.add(change).then(function(rev) {
+      trans._lastWrittenRevision = Math.max(trans._lastWrittenRevision, rev);
+      return rev;
+    });
+    this.onsuccess = function(resultKey) {
+      if (primKey != resultKey)
+        promise._then(function() {
+          change.key = resultKey;
+          db._changes.put(change);
+        });
+    };
+    this.onerror = function() {
+      promise._then(function(rev) {
+        db._changes.delete(rev);
+      });
+    };
+    return rv;
+  };
+}
+function initUpdatingHook(db, tableName) {
+  return function updatingHook(mods, primKey, oldObj, trans) {
+    var modsWithoutUndefined = {};
+    var anythingChanged = false;
+    var newObj = import_wrapper_default.deepClone(oldObj);
+    for (var propPath in mods) {
+      var mod = mods[propPath];
+      if (typeof mod === "undefined") {
+        import_wrapper_default.delByKeyPath(newObj, propPath);
+        modsWithoutUndefined[propPath] = null;
+        anythingChanged = true;
+      } else {
+        var currentValue = import_wrapper_default.getByKeyPath(oldObj, propPath);
+        if (mod !== currentValue && JSON.stringify(mod) !== JSON.stringify(currentValue)) {
+          import_wrapper_default.setByKeyPath(newObj, propPath, mod);
+          modsWithoutUndefined[propPath] = mod;
+          anythingChanged = true;
+        }
+      }
+    }
+    if (anythingChanged) {
+      var change = {
+        source: trans.source || null,
+        table: tableName,
+        key: primKey,
+        type: UPDATE,
+        mods: modsWithoutUndefined,
+        oldObj,
+        obj: newObj
+      };
+      var promise = db._changes.add(change);
+      this.onsuccess = function() {
+        promise._then(function(rev) {
+          trans._lastWrittenRevision = Math.max(trans._lastWrittenRevision, rev);
+        });
+      };
+      this.onerror = function() {
+        promise._then(function(rev) {
+          db._changes.delete(rev);
+        });
+      };
+    }
+  };
+}
+function initDeletingHook(db, tableName) {
+  return function deletingHook(primKey, obj, trans) {
+    var promise = db._changes.add({
+      source: trans.source || null,
+      table: tableName,
+      key: primKey,
+      type: DELETE,
+      oldObj: obj
+    }).then(function(rev) {
+      trans._lastWrittenRevision = Math.max(trans._lastWrittenRevision, rev);
+      return rev;
+    }).catch(function(e) {
+      console.log(obj);
+      console.log(e.stack);
+    });
+    this.onerror = function() {
+      promise._then(function(rev) {
+        db._changes.delete(rev);
+      });
+    };
+  };
+}
+function initCrudMonitor(db) {
+  return function crudMonitor(table) {
+    if (table.hook._observing)
+      return;
+    table.hook._observing = true;
+    var tableName = table.name;
+    table.hook("creating").subscribe(initCreatingHook(db, table));
+    table.hook("updating").subscribe(initUpdatingHook(db, tableName));
+    table.hook("deleting").subscribe(initDeletingHook(db, tableName));
+  };
+}
+function initOnStorage(Observable3) {
+  return function onStorage(event) {
+    if (event.key && event.key.indexOf("Dexie.Observable/") === 0) {
+      var parts = event.key.split("/");
+      var prop = parts[1];
+      var dbname = parts[2];
+      if (prop === "latestRevision") {
+        var rev = parseInt(event.newValue, 10);
+        if (!isNaN(rev) && rev > Observable3.latestRevision[dbname]) {
+          Observable3.latestRevision[dbname] = rev;
+          import_wrapper_default.ignoreTransaction(function() {
+            Observable3.on("latestRevisionIncremented").fire(dbname, rev);
+          });
+        }
+      } else if (prop.indexOf("deadnode:") === 0) {
+        var nodeID = parseInt(prop.split(":")[1], 10);
+        if (event.newValue) {
+          Observable3.on.suicideNurseCall.fire(dbname, nodeID);
+        }
+      } else if (prop === "intercomm") {
+        if (event.newValue) {
+          Observable3.on.intercomm.fire(dbname);
+        }
+      }
+    }
+  };
+}
+function initOverrideOpen(db, SyncNode, crudMonitor) {
+  return function overrideOpen(origOpen) {
+    return function() {
+      Object.keys(db._allTables).forEach(function(tableName) {
+        var table = db._allTables[tableName];
+        if (table.schema.observable) {
+          crudMonitor(table);
+        }
+        if (table.name === "_syncNodes") {
+          table.mapToClass(SyncNode);
+        }
+      });
+      return origOpen.apply(this, arguments);
+    };
+  };
+}
+var Promise$2 = import_wrapper_default.Promise;
+function initIntercomm(db, Observable3, SyncNode, mySyncNode, localStorage) {
+  var requestsWaitingForReply = {};
+  db.observable.sendMessage = function(type, message, destinationNode, options) {
+    options = options || {};
+    if (!mySyncNode.node)
+      return options.wantReply ? Promise$2.reject(new import_wrapper_default.DatabaseClosedError()) : Promise$2.resolve();
+    var msg = { message, destinationNode, sender: mySyncNode.node.id, type };
+    import_wrapper_default.extend(msg, options);
+    return import_wrapper_default.ignoreTransaction(function() {
+      var tables = ["_intercomm"];
+      if (options.wantReply)
+        tables.push("_syncNodes");
+      var promise = db.transaction("rw", tables, function() {
+        if (options.wantReply) {
+          return db._syncNodes.where("id").equals(destinationNode).count(function(receiverAlive) {
+            if (receiverAlive)
+              return db._intercomm.add(msg);
+            else
+              return db._syncNodes.where("isMaster").above(0).first(function(masterNode) {
+                msg.destinationNode = masterNode.id;
+                return db._intercomm.add(msg);
+              });
+          });
+        } else {
+          return db._intercomm.add(msg);
+        }
+      }).then(function(messageId) {
+        var rv = null;
+        if (options.wantReply) {
+          rv = new Promise$2(function(resolve, reject) {
+            requestsWaitingForReply[messageId.toString()] = { resolve, reject };
+          });
+        }
+        if (localStorage) {
+          localStorage.setItem("Dexie.Observable/intercomm/" + db.name, messageId.toString());
+        }
+        Observable3.on.intercomm.fire(db.name);
+        return rv;
+      });
+      if (!options.wantReply) {
+        promise.catch(function() {
+        });
+        return;
+      } else {
+        return promise;
+      }
+    });
+  };
+  db.observable.broadcastMessage = function(type, message, bIncludeSelf) {
+    if (!mySyncNode.node)
+      return;
+    var mySyncNodeId = mySyncNode.node.id;
+    import_wrapper_default.ignoreTransaction(function() {
+      db._syncNodes.toArray(function(nodes) {
+        return Promise$2.all(nodes.filter(function(node) {
+          return node.type === "local" && (bIncludeSelf || node.id !== mySyncNodeId);
+        }).map(function(node) {
+          return db.observable.sendMessage(type, message, node.id);
+        }));
+      }).catch(function() {
+      });
+    });
+  };
+  function consumeIntercommMessages() {
+    if (!mySyncNode.node)
+      return Promise$2.reject(new import_wrapper_default.DatabaseClosedError());
+    return import_wrapper_default.ignoreTransaction(function() {
+      return db.transaction("rw", "_intercomm", function() {
+        return db._intercomm.where({ destinationNode: mySyncNode.node.id }).toArray(function(messages) {
+          messages.forEach(function(msg) {
+            return consumeMessage(msg);
+          });
+          return db._intercomm.where("id").anyOf(messages.map(function(msg) {
+            return msg.id;
+          })).delete();
+        });
+      });
+    });
+  }
+  function consumeMessage(msg) {
+    if (msg.type === "response") {
+      var request = requestsWaitingForReply[msg.requestId.toString()];
+      if (request) {
+        if (msg.isFailure) {
+          request.reject(msg.message.error);
+        } else {
+          request.resolve(msg.message.result);
+        }
+        delete requestsWaitingForReply[msg.requestId.toString()];
+      }
+    } else {
+      msg.resolve = function(result) {
+        db.observable.sendMessage("response", { result }, msg.sender, { requestId: msg.id });
+      };
+      msg.reject = function(error) {
+        db.observable.sendMessage("response", { error: error.toString() }, msg.sender, { isFailure: true, requestId: msg.id });
+      };
+      db.on.message.fire(msg);
+    }
+  }
+  function onIntercomm(dbname) {
+    if (dbname === db.name) {
+      consumeIntercommMessages().catch("DatabaseClosedError", function() {
+      });
+    }
+  }
+  return {
+    onIntercomm,
+    consumeIntercommMessages
+  };
+}
+function overrideParseStoresSpec(origFunc) {
+  return function(stores, dbSchema) {
+    stores["_changes"] = "++rev";
+    stores["_syncNodes"] = "++id,myRevision,lastHeartBeat,&url,isMaster,type,status";
+    stores["_intercomm"] = "++id,destinationNode";
+    stores["_uncommittedChanges"] = "++id,node";
+    origFunc.call(this, stores, dbSchema);
+    Object.keys(dbSchema).forEach(function(tableName) {
+      var schema = dbSchema[tableName];
+      if (schema.primKey.name.indexOf("$$") === 0) {
+        schema.primKey.uuid = true;
+        schema.primKey.name = schema.primKey.name.substr(2);
+        schema.primKey.keyPath = schema.primKey.keyPath.substr(2);
+      }
+    });
+    Object.keys(dbSchema).forEach(function(tableName) {
+      if (tableName.indexOf("_") !== 0 && tableName.indexOf("$") !== 0) {
+        dbSchema[tableName].observable = true;
+      }
+    });
+  };
+}
+function deleteOldChanges(db) {
+  var CHUNK_SIZE = 100;
+  import_wrapper_default.ignoreTransaction(function() {
+    return db._syncNodes.orderBy("myRevision").first(function(oldestNode) {
+      return db._changes.where("rev").below(oldestNode.myRevision).limit(CHUNK_SIZE).primaryKeys();
+    }).then(function(keysToDelete) {
+      if (keysToDelete.length === 0)
+        return;
+      return db._changes.bulkDelete(keysToDelete).then(function() {
+        if (keysToDelete.length === CHUNK_SIZE) {
+          setTimeout(function() {
+            return db.isOpen() && deleteOldChanges(db);
+          }, 500);
+        }
+      });
+    });
+  }).catch(function() {
+  });
+}
+var global2 = self;
+var DatabaseChange = import_wrapper_default.defineClass({
+  rev: Number,
+  source: String,
+  table: String,
+  key: Object,
+  type: Number,
+  obj: Object,
+  mods: Object,
+  oldObj: Object
+  // DELETE: oldObj contains the object deleted. UPDATE: oldObj contains the old object before updates applied.
+});
+var override = import_wrapper_default.override;
+var Promise$1 = import_wrapper_default.Promise;
+var browserIsShuttingDown = false;
+function Observable(db) {
+  if (!/^(3|4)\./.test(import_wrapper_default.version))
+    throw new Error("Missing dexie version 3.x or 4.x");
+  if (db.observable) {
+    if (db.observable.version !== "{version}")
+      throw new Error("Mixed versions of dexie-observable");
+    return;
+  }
+  var NODE_TIMEOUT = 2e4, HIBERNATE_GRACE_PERIOD = 2e4, LOCAL_POLL = 500, HEARTBEAT_INTERVAL = NODE_TIMEOUT - 5e3;
+  var localStorage = Observable.localStorageImpl;
+  var SyncNode = import_wrapper_default.defineClass({
+    //id: Number,
+    myRevision: Number,
+    type: String,
+    lastHeartBeat: Number,
+    deleteTimeStamp: Number,
+    url: String,
+    isMaster: Number,
+    // Below properties should be extended in Dexie.Syncable. Not here. They apply to remote nodes only (type == "remote"):
+    syncProtocol: String,
+    syncContext: null,
+    syncOptions: Object,
+    connected: false,
+    status: Number,
+    appliedRemoteRevision: null,
+    remoteBaseRevisions: [{ local: Number, remote: null }],
+    dbUploadState: {
+      tablesToUpload: [String],
+      currentTable: String,
+      currentKey: null,
+      localBaseRevision: Number
+    }
+  });
+  db.observable = { version: "{version}" };
+  db.observable.SyncNode = SyncNode;
+  var wakeupObservers = initWakeupObservers(db, Observable, localStorage);
+  var overrideCreateTransaction = initOverrideCreateTransaction(db, wakeupObservers);
+  var crudMonitor = initCrudMonitor(db);
+  var overrideOpen = initOverrideOpen(db, SyncNode, crudMonitor);
+  var mySyncNode = { node: null };
+  var intercomm = initIntercomm(db, Observable, SyncNode, mySyncNode, localStorage);
+  var onIntercomm = intercomm.onIntercomm;
+  var consumeIntercommMessages = intercomm.consumeIntercommMessages;
+  Object.defineProperty(db, "_localSyncNode", {
+    get: function() {
+      return mySyncNode.node;
+    }
+  });
+  var pollHandle = null, heartbeatHandle = null;
+  if (import_wrapper_default.fake) {
+    db.version(1).stores({
+      _syncNodes: "++id,myRevision,lastHeartBeat",
+      _changes: "++rev",
+      _intercomm: "++id,destinationNode",
+      _uncommittedChanges: "++id,node"
+    });
+    db._syncNodes.mapToClass(SyncNode);
+    db._changes.mapToClass(DatabaseChange);
+    mySyncNode.node = new SyncNode({
+      myRevision: 0,
+      type: "local",
+      lastHeartBeat: Date.now(),
+      deleteTimeStamp: null
+    });
+  }
+  db.Version.prototype._parseStoresSpec = override(db.Version.prototype._parseStoresSpec, overrideParseStoresSpec);
+  db.on.addEventType({
+    changes: "asap",
+    cleanup: [promisableChain, nop],
+    message: "asap"
+  });
+  db._createTransaction = override(db._createTransaction, overrideCreateTransaction);
+  Observable.latestRevision[db.name] = Observable.latestRevision[db.name] || 0;
+  db.open = override(db.open, overrideOpen);
+  db.close = override(db.close, function(origClose) {
+    return function() {
+      if (db.dynamicallyOpened())
+        return origClose.apply(this, arguments);
+      if (wakeupObservers.timeoutHandle) {
+        clearTimeout(wakeupObservers.timeoutHandle);
+        delete wakeupObservers.timeoutHandle;
+      }
+      Observable.on("latestRevisionIncremented").unsubscribe(onLatestRevisionIncremented);
+      Observable.on("suicideNurseCall").unsubscribe(onSuicide);
+      Observable.on("intercomm").unsubscribe(onIntercomm);
+      Observable.on("beforeunload").unsubscribe(onBeforeUnload);
+      if (mySyncNode.node && mySyncNode.node.id) {
+        Observable.on.suicideNurseCall.fire(db.name, mySyncNode.node.id);
+        if (localStorage) {
+          localStorage.setItem("Dexie.Observable/deadnode:" + mySyncNode.node.id.toString() + "/" + db.name, "dead");
+        }
+        mySyncNode.node.deleteTimeStamp = 1;
+        mySyncNode.node.lastHeartBeat = 0;
+        db._syncNodes.put(mySyncNode.node);
+        mySyncNode.node = null;
+      }
+      if (pollHandle)
+        clearTimeout(pollHandle);
+      pollHandle = null;
+      if (heartbeatHandle)
+        clearTimeout(heartbeatHandle);
+      heartbeatHandle = null;
+      return origClose.apply(this, arguments);
+    };
+  });
+  db.delete = override(db.delete, function(origDelete) {
+    return function() {
+      return origDelete.apply(this, arguments).then(function(result) {
+        Observable.latestRevision[db.name] = 0;
+        return result;
+      });
+    };
+  });
+  db.on("ready", function startObserving() {
+    if (db.dynamicallyOpened())
+      return db;
+    return db.table("_changes").orderBy("rev").last(function(lastChange) {
+      var latestRevision = lastChange ? lastChange.rev : 0;
+      mySyncNode.node = new SyncNode({
+        myRevision: latestRevision,
+        type: "local",
+        lastHeartBeat: Date.now(),
+        deleteTimeStamp: null,
+        isMaster: 0
+      });
+      if (Observable.latestRevision[db.name] < latestRevision) {
+        Observable.latestRevision[db.name] = latestRevision;
+        import_wrapper_default.ignoreTransaction(function() {
+          Observable.on.latestRevisionIncremented.fire(latestRevision);
+        });
+      }
+      return db._syncNodes.put(mySyncNode.node).then(import_wrapper_default.ignoreTransaction(function() {
+        var mySyncNodeShouldBecomeMaster = 1;
+        return db._syncNodes.orderBy("isMaster").reverse().modify(function(existingNode) {
+          if (existingNode.isMaster) {
+            if (existingNode.lastHeartBeat < Date.now() - NODE_TIMEOUT) {
+              existingNode.isMaster = 0;
+            } else {
+              mySyncNodeShouldBecomeMaster = 0;
+            }
+          }
+          if (!mySyncNode.node)
+            return;
+          if (existingNode.id === mySyncNode.node.id) {
+            existingNode.isMaster = mySyncNode.node.isMaster = mySyncNodeShouldBecomeMaster;
+          }
+        });
+      })).then(function() {
+        Observable.on("latestRevisionIncremented", onLatestRevisionIncremented);
+        Observable.on("beforeunload", onBeforeUnload);
+        Observable.on("suicideNurseCall", onSuicide);
+        Observable.on("intercomm", onIntercomm);
+        pollHandle = setTimeout(poll, LOCAL_POLL);
+        heartbeatHandle = setTimeout(heartbeat, HEARTBEAT_INTERVAL);
+      }).then(function() {
+        cleanup();
+      });
+    });
+  }, true);
+  var handledRevision = 0;
+  function onLatestRevisionIncremented(dbname, latestRevision) {
+    if (dbname === db.name) {
+      if (handledRevision >= latestRevision)
+        return;
+      handledRevision = latestRevision;
+      import_wrapper_default.vip(function() {
+        readChanges().catch("DatabaseClosedError", function() {
+        });
+      });
+    }
+  }
+  function readChanges(latestRevision, recursion, wasPartial) {
+    if (!recursion && readChanges.ongoingOperation) {
+      return readChanges.ongoingOperation;
+    }
+    var partial = false;
+    var ourSyncNode = mySyncNode.node;
+    if (!ourSyncNode) {
+      return Promise$1.reject(new import_wrapper_default.DatabaseClosedError());
+    }
+    var LIMIT = 1e3;
+    var promise = db._changes.where("rev").above(ourSyncNode.myRevision).limit(LIMIT).toArray(function(changes) {
+      if (changes.length > 0) {
+        var lastChange = changes[changes.length - 1];
+        partial = changes.length === LIMIT;
+        db.on("changes").fire(changes, partial);
+        ourSyncNode.myRevision = lastChange.rev;
+      } else if (wasPartial) {
+        db.on("changes").fire([], false);
+      }
+      var ourNodeStillExists = false;
+      return db._syncNodes.where(":id").equals(ourSyncNode.id).modify(function(syncNode) {
+        ourNodeStillExists = true;
+        syncNode.lastHeartBeat = Date.now();
+        syncNode.deleteTimeStamp = null;
+        syncNode.myRevision = Math.max(syncNode.myRevision, ourSyncNode.myRevision);
+      }).then(function() {
+        return ourNodeStillExists;
+      });
+    }).then(function(ourNodeStillExists) {
+      if (!ourNodeStillExists) {
+        if (browserIsShuttingDown) {
+          throw new Error("Browser is shutting down");
+        } else {
+          db.close();
+          console.error("Out of sync");
+          if (global2.location)
+            global2.location.reload(true);
+          throw new Error("Out of sync");
+        }
+      }
+      if (partial || Observable.latestRevision[db.name] > ourSyncNode.myRevision) {
+        return readChanges(Observable.latestRevision[db.name], (recursion || 0) + 1, partial);
+      }
+    }).finally(function() {
+      delete readChanges.ongoingOperation;
+    });
+    if (!recursion) {
+      readChanges.ongoingOperation = promise;
+    }
+    return promise;
+  }
+  function heartbeat() {
+    heartbeatHandle = null;
+    var currentInstance = mySyncNode.node && mySyncNode.node.id;
+    if (!currentInstance)
+      return;
+    db.transaction("rw!", db._syncNodes, function() {
+      db._syncNodes.where({ id: currentInstance }).first(function(ourSyncNode) {
+        if (!ourSyncNode) {
+          if (db.isOpen())
+            db.close();
+          return;
+        }
+        ourSyncNode.lastHeartBeat = Date.now();
+        ourSyncNode.deleteTimeStamp = null;
+        return db._syncNodes.put(ourSyncNode);
+      });
+    }).catch("DatabaseClosedError", function() {
+    }).finally(function() {
+      if (mySyncNode.node && mySyncNode.node.id === currentInstance && db.isOpen()) {
+        heartbeatHandle = setTimeout(heartbeat, HEARTBEAT_INTERVAL);
+      }
+    });
+  }
+  function poll() {
+    pollHandle = null;
+    var currentInstance = mySyncNode.node && mySyncNode.node.id;
+    if (!currentInstance)
+      return;
+    import_wrapper_default.vip(function() {
+      readChanges(Observable.latestRevision[db.name]).then(cleanup).then(consumeIntercommMessages).catch("DatabaseClosedError", function() {
+      }).finally(function() {
+        if (mySyncNode.node && mySyncNode.node.id === currentInstance && db.isOpen()) {
+          pollHandle = setTimeout(poll, LOCAL_POLL);
+        }
+      });
+    });
+  }
+  function cleanup() {
+    var ourSyncNode = mySyncNode.node;
+    if (!ourSyncNode)
+      return Promise$1.reject(new import_wrapper_default.DatabaseClosedError());
+    return db.transaction("rw", "_syncNodes", "_changes", "_intercomm", function() {
+      var weBecameMaster = false;
+      db._syncNodes.where("lastHeartBeat").below(Date.now() - NODE_TIMEOUT).filter(function(node) {
+        return node.type === "local";
+      }).modify(function(node) {
+        if (node.deleteTimeStamp && node.deleteTimeStamp < Date.now()) {
+          delete this.value;
+          if (localStorage) {
+            localStorage.removeItem("Dexie.Observable/deadnode:" + node.id + "/" + db.name);
+          }
+          if (node.isMaster) {
+            db._syncNodes.update(ourSyncNode, { isMaster: 1 });
+            weBecameMaster = true;
+          }
+          db._intercomm.where({ destinationNode: node.id }).modify(function(msg) {
+            if (msg.wantReply)
+              msg.destinationNode = ourSyncNode.id;
+            else
+              delete this.value;
+          });
+        } else if (!node.deleteTimeStamp) {
+          node.deleteTimeStamp = Date.now() + HIBERNATE_GRACE_PERIOD;
+        }
+      }).then(function() {
+        Observable.deleteOldChanges(db);
+        return db.on("cleanup").fire(weBecameMaster);
+      });
+    });
+  }
+  function onBeforeUnload() {
+    if (!mySyncNode.node)
+      return;
+    browserIsShuttingDown = true;
+    mySyncNode.node.deleteTimeStamp = 1;
+    mySyncNode.node.lastHeartBeat = 0;
+    db._syncNodes.put(mySyncNode.node);
+    Observable.wereTheOneDying = true;
+    if (localStorage) {
+      localStorage.setItem("Dexie.Observable/deadnode:" + mySyncNode.node.id.toString() + "/" + db.name, "dead");
+    }
+  }
+  function onSuicide(dbname, nodeID) {
+    if (dbname === db.name && !Observable.wereTheOneDying) {
+      import_wrapper_default.vip(function() {
+        db._syncNodes.update(nodeID, { deleteTimeStamp: 1, lastHeartBeat: 0 }).then(cleanup);
+      });
+    }
+  }
+}
+Observable.version = "{version}";
+Observable.latestRevision = {};
+Observable.on = import_wrapper_default.Events(null, "latestRevisionIncremented", "suicideNurseCall", "intercomm", "beforeunload");
+Observable.createUUID = createUUID;
+Observable.deleteOldChanges = deleteOldChanges;
+Observable._onStorage = initOnStorage(Observable);
+Observable._onBeforeUnload = function() {
+  Observable.on.beforeunload.fire();
+};
+try {
+  Observable.localStorageImpl = global2.localStorage;
+} catch (ex) {
+}
+if (global2 === null || global2 === void 0 ? void 0 : global2.addEventListener) {
+  global2.addEventListener("storage", Observable._onStorage);
+  global2.addEventListener("beforeunload", Observable._onBeforeUnload);
+}
+if (import_wrapper_default.Observable) {
+  if (import_wrapper_default.Observable.version !== "{version}") {
+    throw new Error("Mixed versions of dexie-observable");
+  }
+} else {
+  import_wrapper_default.Observable = Observable;
+  import_wrapper_default.addons.push(Observable);
+}
+var Dexie_Observable = import_wrapper_default.Observable;
+
+// ../../node_modules/dexie-syncable/dist/dexie-syncable.es.js
+var Promise$3 = import_wrapper_default.Promise;
+function initSyncableConnect(db, connect) {
+  return function syncableConnect(protocolInstance, protocolName, url, options) {
+    if (db.isOpen()) {
+      if (!db._localSyncNode)
+        throw new Error("Precondition failed: local sync node is missing. Make sure Dexie.Observable is active!");
+      if (db._localSyncNode.isMaster) {
+        return connect(protocolInstance, protocolName, url, options, db._localSyncNode.id);
+      } else {
+        return db.table("_syncNodes").where("isMaster").above(0).first(function(masterNode) {
+          return db.observable.sendMessage("connect", {
+            protocolName,
+            url,
+            options
+          }, masterNode.id, { wantReply: true });
+        });
+      }
+    } else if (db.hasBeenClosed()) {
+      return Promise$3.reject(new import_wrapper_default.DatabaseClosedError());
+    } else if (db.hasFailed()) {
+      return Promise$3.reject(new import_wrapper_default.InvalidStateError("Dexie.Syncable: Cannot connect. Database has failed to open"));
+    } else {
+      var promise = new Promise$3(function(resolve, reject) {
+        db.on("ready", function() {
+          return db._syncNodes.get({ url }, function(node) {
+            var connectPromise = db.syncable.connect(protocolName, url, options);
+            connectPromise.then(resolve, reject);
+            if (node && node.appliedRemoteRevision) {
+              return;
+            }
+            return connectPromise;
+          });
+        });
+        db.open().catch(function(ex) {
+          reject(new import_wrapper_default.InvalidStateError("Dexie.Syncable: Couldn't connect. Database failed to open", ex));
+        });
+      });
+      return promise;
+    }
+  };
+}
+function initPersistedContext(node) {
+  return (
+    /** @class */
+    function() {
+      function PersistedContext(nodeID, otherProps) {
+        this.nodeID = nodeID;
+        if (otherProps)
+          import_wrapper_default.extend(this, otherProps);
+      }
+      PersistedContext.prototype.save = function() {
+        return import_wrapper_default.vip(function() {
+          return node.save();
+        });
+      };
+      return PersistedContext;
+    }()
+  );
+}
+function initGetOrCreateSyncNode(db, protocolName, url) {
+  return function getOrCreateSyncNode(options) {
+    return db.transaction("rw", db._syncNodes, db._changes, function() {
+      if (!url)
+        throw new Error("Url cannot be empty");
+      return db._syncNodes.where("url").equalsIgnoreCase(url).first(function(node) {
+        if (node) {
+          var PersistedContext = initPersistedContext(node);
+          node.syncContext = new PersistedContext(node.id, node.syncContext);
+          node.syncProtocol = protocolName;
+          node.syncOptions = options;
+          db._syncNodes.put(node);
+        } else {
+          node = new db.observable.SyncNode();
+          node.myRevision = -1;
+          node.appliedRemoteRevision = null;
+          node.remoteBaseRevisions = [];
+          node.type = "remote";
+          node.syncProtocol = protocolName;
+          node.url = url;
+          node.syncOptions = options;
+          node.lastHeartBeat = Date.now();
+          node.dbUploadState = null;
+          var PersistedContext_1 = initPersistedContext(node);
+          import_wrapper_default.Promise.resolve(function() {
+            if (options.initialUpload === false)
+              return db._changes.toCollection().lastKey(function(currentRevision) {
+                node.myRevision = currentRevision;
+              });
+          }()).then(function() {
+            db._syncNodes.add(node).then(function(nodeID) {
+              node.syncContext = new PersistedContext_1(nodeID);
+              db._syncNodes.put(node);
+            });
+          });
+        }
+        return node;
+      });
+    });
+  };
+}
+function initEnqueue(db) {
+  return function enqueue(context, fn, instanceID) {
+    function _enqueue() {
+      if (!context.ongoingOperation) {
+        context.ongoingOperation = import_wrapper_default.ignoreTransaction(function() {
+          return import_wrapper_default.vip(function() {
+            return fn();
+          });
+        }).finally(function() {
+          delete context.ongoingOperation;
+        });
+      } else {
+        context.ongoingOperation = context.ongoingOperation.then(function() {
+          return enqueue(context, fn, instanceID);
+        });
+      }
+      return context.ongoingOperation;
+    }
+    if (!instanceID) {
+      if (db.isOpen()) {
+        return _enqueue();
+      } else {
+        return import_wrapper_default.Promise.reject(new import_wrapper_default.DatabaseClosedError());
+      }
+    } else if (db._localSyncNode && instanceID === db._localSyncNode.id) {
+      return _enqueue();
+    } else {
+      return import_wrapper_default.Promise.reject(new import_wrapper_default.DatabaseClosedError());
+    }
+  };
+}
+function initSaveToUncommittedChanges(db, node) {
+  return function saveToUncommittedChanges(changes, remoteRevision) {
+    return db.transaction("rw!", db._uncommittedChanges, function() {
+      return db._uncommittedChanges.bulkAdd(changes.map(function(change) {
+        var changeWithNodeId = {
+          node: node.id,
+          type: change.type,
+          table: change.table,
+          key: change.key
+        };
+        if (change.obj)
+          changeWithNodeId.obj = change.obj;
+        if (change.mods)
+          changeWithNodeId.mods = change.mods;
+        return changeWithNodeId;
+      }));
+    }).then(function() {
+      node.appliedRemoteRevision = remoteRevision;
+      return node.save();
+    });
+  };
+}
+var CREATE2 = 1;
+var UPDATE2 = 2;
+var DELETE2 = 3;
+function bulkUpdate(table, changes) {
+  var keys = changes.map(function(c) {
+    return c.key;
+  });
+  var map = {};
+  return table.where(":id").anyOf(keys).raw().each(function(obj, cursor) {
+    map[cursor.primaryKey + ""] = obj;
+  }).then(function() {
+    var updatesThatApply = changes.filter(function(c) {
+      return map.hasOwnProperty(c.key + "");
+    });
+    var objsToPut = updatesThatApply.map(function(c) {
+      var curr = map[c.key + ""];
+      Object.keys(c.mods).forEach(function(keyPath) {
+        import_wrapper_default.setByKeyPath(curr, keyPath, c.mods[keyPath]);
+      });
+      return curr;
+    });
+    return table.bulkPut(objsToPut);
+  });
+}
+function initApplyChanges(db) {
+  return function applyChanges(changes) {
+    var collectedChanges = {};
+    changes.forEach(function(change) {
+      var _a;
+      if (!collectedChanges.hasOwnProperty(change.table)) {
+        collectedChanges[change.table] = (_a = {}, _a[CREATE2] = [], _a[DELETE2] = [], _a[UPDATE2] = [], _a);
+      }
+      collectedChanges[change.table][change.type].push(change);
+    });
+    var table_names = Object.keys(collectedChanges);
+    var tables = table_names.map(function(table) {
+      return db.table(table);
+    });
+    return db.transaction("rw", tables, function() {
+      table_names.forEach(function(table_name) {
+        var table = db.table(table_name);
+        var specifyKeys = !table.schema.primKey.keyPath;
+        var createChangesToApply = collectedChanges[table_name][CREATE2];
+        var deleteChangesToApply = collectedChanges[table_name][DELETE2];
+        var updateChangesToApply = collectedChanges[table_name][UPDATE2];
+        if (createChangesToApply.length > 0)
+          table.bulkPut(createChangesToApply.map(function(c) {
+            return c.obj;
+          }), specifyKeys ? createChangesToApply.map(function(c) {
+            return c.key;
+          }) : void 0);
+        if (updateChangesToApply.length > 0)
+          bulkUpdate(table, updateChangesToApply);
+        if (deleteChangesToApply.length > 0)
+          table.bulkDelete(deleteChangesToApply.map(function(c) {
+            return c.key;
+          }));
+      });
+    });
+  };
+}
+function initFinallyCommitAllChanges(db, node) {
+  var applyChanges = initApplyChanges(db);
+  return function finallyCommitAllChanges(changes, remoteRevision) {
+    var tablesToIncludeInTrans = db.tables.filter(function(table) {
+      return table.name === "_changes" || table.name === "_uncommittedChanges" || table.schema.observable;
+    });
+    return db.transaction("rw!", tablesToIncludeInTrans, function() {
+      var trans = import_wrapper_default.currentTransaction;
+      var localRevisionBeforeChanges = 0;
+      return db._changes.orderBy("rev").last(function(lastChange) {
+        localRevisionBeforeChanges = lastChange && lastChange.rev || 0;
+      }).then(function() {
+        trans.source = node.id;
+        return db._uncommittedChanges.where("node").equals(node.id).toArray();
+      }).then(function(uncommittedChanges) {
+        return applyChanges(uncommittedChanges);
+      }).then(function() {
+        return db._uncommittedChanges.where("node").equals(node.id).delete();
+      }).then(function() {
+        return applyChanges(changes);
+      }).then(function() {
+        return db._changes.orderBy("rev").last();
+      }).then(function(lastChange) {
+        var currentLocalRevision = lastChange && lastChange.rev || 0;
+        node.appliedRemoteRevision = remoteRevision;
+        node.remoteBaseRevisions.push({ remote: remoteRevision, local: currentLocalRevision });
+        if (node.myRevision === localRevisionBeforeChanges) {
+          node.myRevision = currentLocalRevision;
+        }
+        if (node.remoteBaseRevisions.length > 1) {
+          for (var i = node.remoteBaseRevisions.length - 1; i > 0; --i) {
+            if (node.myRevision >= node.remoteBaseRevisions[i].local) {
+              node.remoteBaseRevisions.splice(0, i);
+              break;
+            }
+          }
+        }
+        node.save().catch(function(err) {
+          console.warn("Dexie.Syncable: Unable to save SyncNode after applying remote changes: " + (err.stack || err));
+        });
+      });
+    });
+  };
+}
+function getBaseRevisionAndMaxClientRevision(node) {
+  if (node.remoteBaseRevisions.length === 0)
+    return {
+      // No remoteBaseRevisions have arrived yet. No limit on clientRevision and provide null as remoteBaseRevision:
+      maxClientRevision: Infinity,
+      remoteBaseRevision: null
+    };
+  for (var i = node.remoteBaseRevisions.length - 1; i >= 0; --i) {
+    if (node.myRevision >= node.remoteBaseRevisions[i].local) {
+      return {
+        maxClientRevision: i === node.remoteBaseRevisions.length - 1 ? Infinity : node.remoteBaseRevisions[i + 1].local,
+        remoteBaseRevision: node.remoteBaseRevisions[i].remote
+      };
+    }
+  }
+  return {
+    maxClientRevision: node.remoteBaseRevisions[0].local,
+    remoteBaseRevision: null
+  };
+}
+function combineCreateAndUpdate(prevChange, nextChange) {
+  var clonedChange = import_wrapper_default.deepClone(prevChange);
+  Object.keys(nextChange.mods).forEach(function(keyPath) {
+    import_wrapper_default.setByKeyPath(clonedChange.obj, keyPath, nextChange.mods[keyPath]);
+  });
+  return clonedChange;
+}
+function combineUpdateAndUpdate(prevChange, nextChange) {
+  var clonedChange = import_wrapper_default.deepClone(prevChange);
+  Object.keys(nextChange.mods).forEach(function(keyPath) {
+    var hadParentPath = false;
+    Object.keys(prevChange.mods).filter(function(parentPath) {
+      return keyPath.indexOf(parentPath + ".") === 0;
+    }).forEach(function(parentPath) {
+      import_wrapper_default.setByKeyPath(clonedChange.mods[parentPath], keyPath.substr(parentPath.length + 1), nextChange.mods[keyPath]);
+      hadParentPath = true;
+    });
+    if (!hadParentPath) {
+      clonedChange.mods[keyPath] = nextChange.mods[keyPath];
+    }
+    Object.keys(prevChange.mods).filter(function(subPath) {
+      return subPath.indexOf(keyPath + ".") === 0;
+    }).forEach(function(subPath) {
+      delete clonedChange.mods[subPath];
+    });
+  });
+  return clonedChange;
+}
+function mergeChange(prevChange, nextChange) {
+  switch (prevChange.type) {
+    case CREATE2:
+      switch (nextChange.type) {
+        case CREATE2:
+          return nextChange;
+        case UPDATE2:
+          return combineCreateAndUpdate(prevChange, nextChange);
+        case DELETE2:
+          return nextChange;
+      }
+      break;
+    case UPDATE2:
+      switch (nextChange.type) {
+        case CREATE2:
+          return nextChange;
+        case UPDATE2:
+          return combineUpdateAndUpdate(prevChange, nextChange);
+        case DELETE2:
+          return nextChange;
+      }
+      break;
+    case DELETE2:
+      switch (nextChange.type) {
+        case CREATE2:
+          return nextChange;
+        case UPDATE2:
+          return prevChange;
+        case DELETE2:
+          return prevChange;
+      }
+      break;
+  }
+}
+function initGetChangesSinceRevision(db, node, hasMoreToGive) {
+  return function getChangesSinceRevision(revision, maxChanges, maxRevision, cb) {
+    var changeSet = {};
+    var numChanges = 0;
+    var partial = false;
+    var ignoreSource = node.id;
+    var nextRevision = revision;
+    return db.transaction("r", db._changes, function() {
+      var query = db._changes.where("rev").between(revision, maxRevision, false, true);
+      return query.until(function() {
+        if (numChanges === maxChanges) {
+          partial = true;
+          return true;
+        }
+      }).each(function(change) {
+        nextRevision = change.rev;
+        if (change.source === ignoreSource)
+          return;
+        var changeToSend = {
+          type: change.type,
+          table: change.table,
+          key: change.key
+        };
+        if (change.type === CREATE2)
+          changeToSend.obj = change.obj;
+        else if (change.type === UPDATE2)
+          changeToSend.mods = change.mods;
+        var id = change.table + ":" + change.key;
+        var prevChange = changeSet[id];
+        if (!prevChange) {
+          changeSet[id] = changeToSend;
+          ++numChanges;
+        } else {
+          var nextChange = changeToSend;
+          var mergedChange = mergeChange(prevChange, nextChange);
+          changeSet[id] = mergedChange;
+        }
+      });
+    }).then(function() {
+      var changes = Object.keys(changeSet).map(function(key) {
+        return changeSet[key];
+      });
+      hasMoreToGive.hasMoreToGive = partial;
+      return cb(changes, partial, { myRevision: nextRevision });
+    });
+  };
+}
+function initGetTableObjectsAsChanges(db, node, MAX_CHANGES_PER_CHUNK, getChangesSinceRevision, hasMoreToGive, cb) {
+  return function getTableObjectsAsChanges(state, changes, collection) {
+    var limitReached = false;
+    return collection.until(function() {
+      if (changes.length === MAX_CHANGES_PER_CHUNK) {
+        limitReached = true;
+        return true;
+      }
+    }).each(function(item, cursor) {
+      changes.push({
+        type: CREATE2,
+        table: state.currentTable,
+        key: cursor.key,
+        obj: cursor.value
+      });
+      state.currentKey = cursor.key;
+    }).then(function() {
+      if (limitReached) {
+        hasMoreToGive.hasMoreToGive = true;
+        return cb(changes, null, true, { dbUploadState: state });
+      } else {
+        if (state.tablesToUpload.length === 0) {
+          var brmcr = getBaseRevisionAndMaxClientRevision(node);
+          return getChangesSinceRevision(state.localBaseRevision, MAX_CHANGES_PER_CHUNK - changes.length, brmcr.maxClientRevision, function(additionalChanges, partial, nodeModificationsOnAck) {
+            changes = changes.concat(additionalChanges);
+            nodeModificationsOnAck.dbUploadState = null;
+            return cb(changes, brmcr.remoteBaseRevision, partial, nodeModificationsOnAck);
+          });
+        } else {
+          state.currentTable = state.tablesToUpload.shift();
+          return getTableObjectsAsChanges(state, changes, db.table(state.currentTable).orderBy(":id"));
+        }
+      }
+    });
+  };
+}
+function initGetLocalChangesForNode(db, hasMoreToGive, partialsThreshold) {
+  var MAX_CHANGES_PER_CHUNK = partialsThreshold;
+  return function getLocalChangesForNode(node, cb) {
+    var getChangesSinceRevision = initGetChangesSinceRevision(db, node, hasMoreToGive);
+    var getTableObjectsAsChanges = initGetTableObjectsAsChanges(db, node, MAX_CHANGES_PER_CHUNK, getChangesSinceRevision, hasMoreToGive, cb);
+    if (node.myRevision >= 0) {
+      var brmcr = getBaseRevisionAndMaxClientRevision(node);
+      return getChangesSinceRevision(node.myRevision, MAX_CHANGES_PER_CHUNK, brmcr.maxClientRevision, function(changes, partial, nodeModificationsOnAck) {
+        return cb(changes, brmcr.remoteBaseRevision, partial, nodeModificationsOnAck);
+      });
+    } else {
+      if (node.dbUploadState === null) {
+        var tablesToUpload = db.tables.filter(function(table) {
+          return table.schema.observable;
+        }).map(function(table) {
+          return table.name;
+        });
+        if (tablesToUpload.length === 0)
+          return import_wrapper_default.Promise.resolve(cb([], null, false, {}));
+        var dbUploadState = {
+          tablesToUpload,
+          currentTable: tablesToUpload.shift(),
+          currentKey: null
+        };
+        return db._changes.orderBy("rev").last(function(lastChange) {
+          dbUploadState.localBaseRevision = lastChange && lastChange.rev || 0;
+          var collection2 = db.table(dbUploadState.currentTable).orderBy(":id");
+          return getTableObjectsAsChanges(dbUploadState, [], collection2);
+        });
+      } else if (node.dbUploadState.currentKey) {
+        var collection = db.table(node.dbUploadState.currentTable).where(":id").above(node.dbUploadState.currentKey);
+        return getTableObjectsAsChanges(import_wrapper_default.deepClone(node.dbUploadState), [], collection);
+      } else {
+        var collection = db.table(dbUploadState.currentTable).orderBy(":id");
+        return getTableObjectsAsChanges(import_wrapper_default.deepClone(node.dbUploadState), [], collection);
+      }
+    }
+  };
+}
+var Statuses = {
+  ERROR: -1,
+  OFFLINE: 0,
+  CONNECTING: 1,
+  ONLINE: 2,
+  SYNCING: 3,
+  ERROR_WILL_RETRY: 4
+  // An error occurred such as net down but the sync provider will retry to connect.
+};
+var StatusTexts = {
+  "-1": "ERROR",
+  "0": "OFFLINE",
+  "1": "CONNECTING",
+  "2": "ONLINE",
+  "3": "SYNCING",
+  "4": "ERROR_WILL_RETRY"
+};
+var Promise$22 = import_wrapper_default.Promise;
+function initConnectProtocol(db, protocolInstance, dbAliveID, options, rejectConnectPromise) {
+  var enqueue = initEnqueue(db);
+  var hasMoreToGive = { hasMoreToGive: true };
+  function stillAlive() {
+    return db._localSyncNode && db._localSyncNode.id === dbAliveID;
+  }
+  return function connectProtocol(node, activePeer) {
+    var getLocalChangesForNode = initGetLocalChangesForNode(db, hasMoreToGive, protocolInstance.partialsThreshold);
+    var url = activePeer.url;
+    function changeStatusTo(newStatus) {
+      if (node.status !== newStatus) {
+        node.status = newStatus;
+        node.save().then(function() {
+          db.syncable.on.statusChanged.fire(newStatus, url);
+          db.observable.broadcastMessage("syncStatusChanged", { newStatus, url }, false);
+        }).catch("DatabaseClosedError", function() {
+        });
+      }
+    }
+    activePeer.on("disconnect", function(newStatus) {
+      if (!isNaN(newStatus))
+        changeStatusTo(newStatus);
+    });
+    var connectedContinuation;
+    changeStatusTo(Statuses.CONNECTING);
+    return doSync();
+    function doSync() {
+      return enqueue(doSync, function() {
+        return getLocalChangesForNode_autoAckIfEmpty(node, sendChangesToProvider);
+      }, dbAliveID);
+    }
+    function sendChangesToProvider(changes, remoteBaseRevision, partial, nodeModificationsOnAck) {
+      var finalSyncPromise = new Promise$22(function(resolve, reject) {
+        rejectConnectPromise.p = function(err) {
+          reject(err);
+        };
+        import_wrapper_default.asap(function() {
+          try {
+            protocolInstance.sync(node.syncContext, url, options, remoteBaseRevision, node.appliedRemoteRevision, changes, partial, applyRemoteChanges, onChangesAccepted, function(continuation) {
+              resolve(continuation);
+            }, onError);
+          } catch (ex) {
+            onError(ex, Infinity);
+          }
+          function onError(error, again) {
+            reject(error);
+            if (stillAlive()) {
+              if (!isNaN(again) && again < Infinity) {
+                setTimeout(function() {
+                  if (stillAlive()) {
+                    changeStatusTo(Statuses.SYNCING);
+                    doSync().catch("DatabaseClosedError", abortTheProvider);
+                  }
+                }, again);
+                changeStatusTo(Statuses.ERROR_WILL_RETRY);
+                if (connectedContinuation && connectedContinuation.disconnect)
+                  connectedContinuation.disconnect();
+                connectedContinuation = null;
+              } else {
+                abortTheProvider(error);
+              }
+            }
+          }
+        });
+      });
+      return finalSyncPromise.then(function() {
+        return void 0;
+      }).finally(function() {
+        rejectConnectPromise.p = null;
+      });
+      function onChangesAccepted() {
+        Object.keys(nodeModificationsOnAck).forEach(function(keyPath) {
+          import_wrapper_default.setByKeyPath(node, keyPath, nodeModificationsOnAck[keyPath]);
+        });
+        finalSyncPromise.then(continueSendingChanges);
+        return node.save();
+      }
+    }
+    function abortTheProvider(error) {
+      activePeer.disconnect(Statuses.ERROR, error);
+    }
+    function getLocalChangesForNode_autoAckIfEmpty(node2, cb) {
+      return getLocalChangesForNode(node2, function autoAck(changes, remoteBaseRevision, partial, nodeModificationsOnAck) {
+        if (changes.length === 0 && "myRevision" in nodeModificationsOnAck && nodeModificationsOnAck.myRevision !== node2.myRevision) {
+          Object.keys(nodeModificationsOnAck).forEach(function(keyPath) {
+            import_wrapper_default.setByKeyPath(node2, keyPath, nodeModificationsOnAck[keyPath]);
+          });
+          node2.save().catch("DatabaseClosedError", function() {
+          });
+          return getLocalChangesForNode(node2, autoAck);
+        } else {
+          return cb(changes, remoteBaseRevision, partial, nodeModificationsOnAck);
+        }
+      });
+    }
+    function applyRemoteChanges(remoteChanges, remoteRevision, partial) {
+      var saveToUncommittedChanges = initSaveToUncommittedChanges(db, node);
+      var finallyCommitAllChanges = initFinallyCommitAllChanges(db, node);
+      return enqueue(applyRemoteChanges, function() {
+        if (!stillAlive())
+          return Promise$22.reject(new import_wrapper_default.DatabaseClosedError());
+        return (partial ? saveToUncommittedChanges(remoteChanges, remoteRevision) : finallyCommitAllChanges(remoteChanges, remoteRevision)).catch(function(error) {
+          abortTheProvider(error);
+          return Promise$22.reject(error);
+        });
+      }, dbAliveID);
+    }
+    function continueSendingChanges(continuation) {
+      if (!stillAlive()) {
+        if (continuation.disconnect)
+          continuation.disconnect();
+        return;
+      }
+      connectedContinuation = continuation;
+      activePeer.on("disconnect", function() {
+        if (connectedContinuation) {
+          if (connectedContinuation.react) {
+            try {
+              connectedContinuation.disconnect();
+            } catch (e) {
+            }
+          }
+          connectedContinuation = null;
+        }
+      });
+      if (continuation.react) {
+        continueUsingReactPattern(continuation);
+      } else {
+        continueUsingPollPattern();
+      }
+    }
+    function continueUsingReactPattern(continuation) {
+      var changesWaiting, isWaitingForServer;
+      function onChanges() {
+        if (connectedContinuation) {
+          changeStatusTo(Statuses.SYNCING);
+          if (isWaitingForServer)
+            changesWaiting = true;
+          else {
+            reactToChanges();
+          }
+        }
+      }
+      db.on("changes", onChanges);
+      activePeer.on("disconnect", function() {
+        db.on.changes.unsubscribe(onChanges);
+      });
+      function reactToChanges() {
+        if (!connectedContinuation)
+          return;
+        changesWaiting = false;
+        isWaitingForServer = true;
+        getLocalChangesForNode_autoAckIfEmpty(node, function(changes, remoteBaseRevision, partial, nodeModificationsOnAck) {
+          if (!connectedContinuation)
+            return;
+          if (changes.length > 0) {
+            continuation.react(changes, remoteBaseRevision, partial, function onChangesAccepted() {
+              Object.keys(nodeModificationsOnAck).forEach(function(keyPath) {
+                import_wrapper_default.setByKeyPath(node, keyPath, nodeModificationsOnAck[keyPath]);
+              });
+              node.save().catch("DatabaseClosedError", function() {
+              });
+              reactToChanges();
+            });
+          } else {
+            isWaitingForServer = false;
+            if (changesWaiting) {
+              reactToChanges();
+            } else {
+              changeStatusTo(Statuses.ONLINE);
+            }
+          }
+        }).catch(function(ex) {
+          console.error("Got ".concat(ex.message, " caught by reactToChanges"));
+          abortTheProvider(ex);
+        });
+      }
+      reactToChanges();
+    }
+    function continueUsingPollPattern() {
+      function syncAgain() {
+        getLocalChangesForNode_autoAckIfEmpty(node, function(changes, remoteBaseRevision, partial, nodeModificationsOnAck) {
+          protocolInstance.sync(node.syncContext, url, options, remoteBaseRevision, node.appliedRemoteRevision, changes, partial, applyRemoteChanges, onChangesAccepted, onSuccess, onError);
+          function onChangesAccepted() {
+            Object.keys(nodeModificationsOnAck).forEach(function(keyPath) {
+              import_wrapper_default.setByKeyPath(node, keyPath, nodeModificationsOnAck[keyPath]);
+            });
+            node.save().catch("DatabaseClosedError", function() {
+            });
+          }
+          function onSuccess(continuation) {
+            if (!connectedContinuation) {
+              return;
+            }
+            connectedContinuation = continuation;
+            if (partial) {
+              syncAgain();
+            } else {
+              if (!isNaN(continuation.again) && continuation.again < Infinity) {
+                changeStatusTo(Statuses.ONLINE);
+                setTimeout(function() {
+                  if (connectedContinuation) {
+                    changeStatusTo(Statuses.SYNCING);
+                    syncAgain();
+                  }
+                }, continuation.again);
+              } else {
+                activePeer.disconnect(Statuses.OFFLINE);
+              }
+            }
+          }
+          function onError(error, again) {
+            if (!isNaN(again) && again < Infinity) {
+              if (connectedContinuation) {
+                setTimeout(function() {
+                  if (connectedContinuation) {
+                    changeStatusTo(Statuses.SYNCING);
+                    syncAgain();
+                  }
+                }, again);
+                changeStatusTo(Statuses.ERROR_WILL_RETRY);
+              }
+            } else {
+              abortTheProvider(error);
+            }
+          }
+        }).catch(abortTheProvider);
+      }
+      if (hasMoreToGive.hasMoreToGive) {
+        syncAgain();
+      } else if (connectedContinuation && !isNaN(connectedContinuation.again) && connectedContinuation.again < Infinity) {
+        changeStatusTo(Statuses.ONLINE);
+        setTimeout(function() {
+          if (connectedContinuation) {
+            changeStatusTo(Statuses.SYNCING);
+            syncAgain();
+          }
+        }, connectedContinuation.again);
+      } else {
+        activePeer.disconnect(Statuses.OFFLINE);
+      }
+    }
+  };
+}
+function initConnectFn(db, activePeers) {
+  return function connect(protocolInstance, protocolName, url, options, dbAliveID) {
+    var existingPeer = activePeers.filter(function(peer) {
+      return peer.url === url;
+    });
+    if (existingPeer.length > 0) {
+      var activePeer = existingPeer[0];
+      var diffObject = {};
+      import_wrapper_default.getObjectDiff(activePeer.syncOptions, options, diffObject);
+      if (Object.keys(diffObject).length !== 0) {
+        return db.syncable.disconnect(url).then(function() {
+          return execConnect();
+        });
+      } else {
+        return existingPeer[0].connectPromise;
+      }
+    }
+    function execConnect() {
+      var rejectConnectPromise = { p: null };
+      var connectProtocol = initConnectProtocol(db, protocolInstance, dbAliveID, options, rejectConnectPromise);
+      var getOrCreateSyncNode = initGetOrCreateSyncNode(db, protocolName, url);
+      var connectPromise = getOrCreateSyncNode(options).then(function(node) {
+        return connectProtocol(node, activePeer2);
+      });
+      var disconnected = false;
+      var activePeer2 = {
+        url,
+        status: Statuses.OFFLINE,
+        connectPromise,
+        syncOptions: options,
+        on: import_wrapper_default.Events(null, "disconnect"),
+        disconnect: function(newStatus, error) {
+          var pos = activePeers.indexOf(activePeer2);
+          if (pos >= 0)
+            activePeers.splice(pos, 1);
+          if (error && rejectConnectPromise.p)
+            rejectConnectPromise.p(error);
+          if (!disconnected) {
+            activePeer2.on.disconnect.fire(newStatus, error);
+          }
+          disconnected = true;
+        }
+      };
+      activePeers.push(activePeer2);
+      return connectPromise;
+    }
+    return execConnect();
+  };
+}
+var override2 = import_wrapper_default.override;
+var Promise$12 = import_wrapper_default.Promise;
+var Observable2 = import_wrapper_default.Observable;
+function Syncable(db) {
+  if (!/^(3|4)\./.test(import_wrapper_default.version))
+    throw new Error("Missing dexie version 3.x or 4.x");
+  if (!db.observable || db.observable.version !== "{version}" && !/^(3|4)\./.test(db.observable.version))
+    throw new Error("Missing dexie-observable version 3.x or 4.x");
+  if (db.syncable) {
+    if (db.syncable.version !== "{version}")
+      throw new Error("Mixed versions of dexie-syncable");
+    return;
+  }
+  var activePeers = [];
+  var connectFn = initConnectFn(db, activePeers);
+  var syncableConnect = initSyncableConnect(db, connectFn);
+  db.on("message", function(msg) {
+    import_wrapper_default.vip(function() {
+      if (msg.type === "connect") {
+        db.syncable.connect(msg.message.protocolName, msg.message.url, msg.message.options).then(msg.resolve, msg.reject);
+      } else if (msg.type === "disconnect") {
+        db.syncable.disconnect(msg.message.url).then(msg.resolve, msg.reject);
+      } else if (msg.type === "syncStatusChanged") {
+        db.syncable.on.statusChanged.fire(msg.message.newStatus, msg.message.url);
+      }
+    });
+  });
+  db.on("cleanup", function(weBecameMaster) {
+    if (weBecameMaster) {
+      import_wrapper_default.ignoreTransaction(function() {
+        return import_wrapper_default.vip(function() {
+          return db._syncNodes.where({ type: "remote" }).filter(function(node) {
+            return node.status !== Statuses.OFFLINE;
+          }).toArray(function(connectedRemoteNodes) {
+            return Promise$12.all(connectedRemoteNodes.map(function(node) {
+              return db.syncable.connect(node.syncProtocol, node.url, node.syncOptions).catch(function(e) {
+                console.warn("Dexie.Syncable: Could not connect to ".concat(node.url, ". ").concat(e.stack || e));
+              });
+            }));
+          });
+        });
+      }).catch("DatabaseClosedError", function() {
+      });
+    }
+  });
+  db.on("ready", function onReady() {
+    if (db._localSyncNode && db._localSyncNode.isMaster) {
+      db._syncNodes.where("type").equals("remote").and(function(node) {
+        return node.status !== Statuses.OFFLINE;
+      }).toArray(function(connectedRemoteNodes) {
+        connectedRemoteNodes.forEach(
+          function(node) {
+            return db.syncable.connect(node.syncProtocol, node.url, node.syncOptions).catch(function() {
+            });
+          }
+          // A failure will be triggered in on('statusChanged'). We can ignore.
+        );
+      }).catch("DatabaseClosedError", function() {
+      });
+    }
+  }, true);
+  db.syncable = {
+    version: "{version}"
+  };
+  db.syncable.getStatus = function(url, cb) {
+    if (db.isOpen()) {
+      return import_wrapper_default.vip(function() {
+        return db._syncNodes.where("url").equals(url).first(function(node) {
+          return node ? node.status : Statuses.OFFLINE;
+        });
+      }).then(cb);
+    } else {
+      return Promise$12.resolve(Syncable.Statuses.OFFLINE).then(cb);
+    }
+  };
+  db.syncable.getOptions = function(url, cb) {
+    return db.transaction("r?", db._syncNodes, function() {
+      return db._syncNodes.where("url").equals(url).first(function(node) {
+        return node.syncOptions;
+      }).then(cb);
+    });
+  };
+  db.syncable.list = function() {
+    return db.transaction("r?", db._syncNodes, function() {
+      return db._syncNodes.where("type").equals("remote").toArray(function(a) {
+        return a.map(function(node) {
+          return node.url;
+        });
+      });
+    });
+  };
+  db.syncable.on = import_wrapper_default.Events(db, { statusChanged: "asap" });
+  db.syncable.disconnect = function(url) {
+    return import_wrapper_default.ignoreTransaction(function() {
+      return Promise$12.resolve().then(function() {
+        if (db._localSyncNode && db._localSyncNode.isMaster) {
+          return Promise$12.all(activePeers.filter(function(peer) {
+            return peer.url === url;
+          }).map(function(peer) {
+            return peer.disconnect(Statuses.OFFLINE);
+          }));
+        } else {
+          return db._syncNodes.where("isMaster").above(0).first(function(masterNode) {
+            return db.observable.sendMessage("disconnect", { url }, masterNode.id, { wantReply: true });
+          });
+        }
+      }).then(function() {
+        return db._syncNodes.where("url").equals(url).modify(function(node) {
+          node.status = Statuses.OFFLINE;
+        });
+      });
+    });
+  };
+  db.syncable.connect = function(protocolName, url, options) {
+    options = options || {};
+    var protocolInstance = Syncable.registeredProtocols[protocolName];
+    if (protocolInstance) {
+      return syncableConnect(protocolInstance, protocolName, url, options);
+    } else {
+      return Promise$12.reject(new Error("ISyncProtocol '" + protocolName + "' is not registered in Dexie.Syncable.registerSyncProtocol()"));
+    }
+  };
+  db.syncable.delete = function(url) {
+    return db.syncable.disconnect(url).then(function() {
+      return db.transaction("rw!", db._syncNodes, db._changes, db._uncommittedChanges, function() {
+        var nodeIDsToDelete;
+        return db._syncNodes.where("url").equals(url).toArray(function(nodes) {
+          return nodes.map(function(node) {
+            return node.id;
+          });
+        }).then(function(nodeIDs) {
+          nodeIDsToDelete = nodeIDs;
+          return db._syncNodes.where("id").anyOf(nodeIDs).delete();
+        }).then(function() {
+          return db._uncommittedChanges.where("node").anyOf(nodeIDsToDelete).delete();
+        });
+      }).then(function() {
+        Observable2.deleteOldChanges(db);
+      });
+    });
+  };
+  db.syncable.unsyncedChanges = function(url) {
+    return db._syncNodes.where("url").equals(url).first(function(node) {
+      return db._changes.where("rev").above(node.myRevision).toArray();
+    });
+  };
+  db.close = override2(db.close, function(origClose) {
+    return function() {
+      activePeers.forEach(function(peer) {
+        peer.disconnect();
+      });
+      return origClose.apply(this, arguments);
+    };
+  });
+  Object.defineProperty(db.observable.SyncNode.prototype, "save", {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: function() {
+      var _this = this;
+      return db.transaction("rw?", db._syncNodes, function() {
+        return db._syncNodes.put(_this);
+      });
+    }
+  });
+}
+Syncable.version = "{version}";
+Syncable.Statuses = Statuses;
+Syncable.StatusTexts = StatusTexts;
+Syncable.registeredProtocols = {};
+Syncable.registerSyncProtocol = function(name, protocolInstance) {
+  var partialsThreshold = protocolInstance.partialsThreshold;
+  if (typeof partialsThreshold === "number") {
+    if (isNaN(partialsThreshold) || partialsThreshold < 0) {
+      throw new Error("The given number for the threshold is not supported");
+    }
+  } else {
+    protocolInstance.partialsThreshold = Infinity;
+  }
+  Syncable.registeredProtocols[name] = protocolInstance;
+};
+if (import_wrapper_default.Syncable) {
+  if (import_wrapper_default.Syncable.version !== "{version}") {
+    throw new Error("Mixed versions of dexie-syncable");
+  }
+} else {
+  import_wrapper_default.Syncable = Syncable;
+  import_wrapper_default.addons.push(Syncable);
+}
+var Dexie_Syncable = import_wrapper_default.Syncable;
+
+// ../sync/src/syncProtocol.js
+var syncProtocol = function() {
+  console.log("Initializing syncProtocol");
+  var RECONNECT_DELAY = 5e3;
+  Dexie.Syncable.registerSyncProtocol("websocket", {
+    sync: function(context, url, options, baseRevision, syncedRevision, changes, partial, applyRemoteChanges, onChangesAccepted, onSuccess, onError) {
+      var requestId = 0;
+      var acceptCallbacks = {};
+      var ws = new WebSocket(url);
+      function sendChanges(changes2, baseRevision2, partial2, onChangesAccepted2) {
+        console.log("sendChanges", changes2.length, baseRevision2);
+        ++requestId;
+        acceptCallbacks[requestId.toString()] = onChangesAccepted2;
+        ws.send(
+          JSON.stringify({
+            type: "changes",
+            changes: changes2,
+            partial: partial2,
+            baseRevision: baseRevision2,
+            requestId
+          })
+        );
+      }
+      ws.onopen = function(event) {
+        console.log("Opening socket - sending clientIdentity", context.clientIdentity);
+        ws.send(
+          JSON.stringify({
+            type: "clientIdentity",
+            clientIdentity: context.clientIdentity || null,
+            authToken: options.authToken
+          })
+        );
+      };
+      ws.onerror = function(event) {
+        ws.close();
+        console.log("ws.onerror", event);
+        onError(event?.message, RECONNECT_DELAY);
+      };
+      ws.onclose = function(event) {
+        onError("Socket closed: " + event.reason, RECONNECT_DELAY);
+      };
+      var isFirstRound = true;
+      ws.onmessage = function(event) {
+        try {
+          var requestFromServer = JSON.parse(event.data);
+          console.log("requestFromServer", requestFromServer, { acceptCallback, isFirstRound });
+          if (requestFromServer.type == "clientIdentity") {
+            context.clientIdentity = requestFromServer.clientIdentity;
+            context.save();
+            sendChanges(changes, baseRevision, partial, onChangesAccepted);
+            ws.send(
+              JSON.stringify({
+                type: "subscribe",
+                syncedRevision
+              })
+            );
+          } else if (requestFromServer.type == "error") {
+          } else if (requestFromServer.type == "changes") {
+            applyRemoteChanges(
+              requestFromServer.changes,
+              requestFromServer.currentRevision,
+              requestFromServer.partial
+            );
+            if (isFirstRound && !requestFromServer.partial) {
+              onSuccess({
+                // Specify a react function that will react on additional client changes
+                react: function(changes2, baseRevision2, partial2, onChangesAccepted2) {
+                  sendChanges(
+                    changes2,
+                    baseRevision2,
+                    partial2,
+                    onChangesAccepted2
+                  );
+                },
+                // Specify a disconnect function that will close our socket so that we dont continue to monitor changes.
+                disconnect: function() {
+                  ws.close();
+                }
+              });
+              isFirstRound = false;
+            }
+          } else if (requestFromServer.type == "ack") {
+            var requestId2 = requestFromServer.requestId;
+            var acceptCallback = acceptCallbacks[requestId2.toString()];
+            acceptCallback();
+            delete acceptCallbacks[requestId2.toString()];
+          } else if (requestFromServer.type == "error") {
+            var requestId2 = requestFromServer.requestId;
+            ws.close();
+            onError(requestFromServer.message, Infinity);
+          } else {
+            console.log("unknown message", requestFromServer);
+            ws.close();
+            onError("unknown message", Infinity);
+          }
+        } catch (e) {
+          ws.close();
+          onError(e, Infinity);
+        }
+      };
+    }
+  });
+};
+
+// ../sync/src/index.ts
+syncProtocol();
+var BasicSync = class extends Dexie {
+  basic_schema;
+  constructor(name, options) {
+    super(name, options);
+    this.basic_schema = options.schema;
+    this.version(1).stores(this._convertSchemaToDxSchema(this.basic_schema));
+    this.version(2).stores({});
+    this.Collection.prototype.get = this.Collection.prototype.toArray;
+  }
+  async connect({ access_token }) {
+    const WS_URL = "ws://localhost:3003/ws";
+    await this.updateSyncNodes();
+    console.log("Starting connection...");
+    return this.syncable.connect("websocket", WS_URL, { authToken: access_token });
+  }
+  async updateSyncNodes() {
+    try {
+      const syncNodes = await this.table("_syncNodes").toArray();
+      const localSyncNodes = syncNodes.filter((node) => node.type === "local");
+      console.log("Local sync nodes:", localSyncNodes);
+      if (localSyncNodes.length > 1) {
+        const largestNodeId = Math.max(...localSyncNodes.map((node) => node.id));
+        const largestNode = localSyncNodes.find((node) => node.id === largestNodeId);
+        if (largestNode && largestNode.isMaster === 1) {
+          console.log("Largest node is already the master. No changes needed.");
+          return;
+        }
+        console.log("Largest node id:", largestNodeId);
+        console.error("HEISENBUG: More than one local sync node found.");
+        for (const node of localSyncNodes) {
+          console.log(`Local sync node keys:`, node.id, node.isMaster);
+          await this.table("_syncNodes").update(node.id, { isMaster: node.id === largestNodeId ? 1 : 0 });
+          console.log(`HEISENBUG: Setting ${node.id} to ${node.id === largestNodeId ? "master" : "0"}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      console.log("Sync nodes updated");
+    } catch (error) {
+      console.error("Error updating _syncNodes table:", error);
+    }
+  }
+  handleStatusChange(fn) {
+    this.syncable.on("statusChanged", fn);
+  }
+  _convertSchemaToDxSchema(schema) {
+    const stores = Object.entries(schema.tables).map(([key, table]) => {
+      const indexedFields = Object.entries(table.fields).filter(([key2, field]) => field.indexed).map(([key2, field]) => `,${key2}`).join("");
+      return {
+        [key]: "id" + indexedFields
+      };
+    });
+    return Object.assign({}, ...stores);
+  }
+  debugeroo() {
+    return this.syncable;
+  }
+  collection(name) {
+    return {
+      /**
+       * Returns the underlying Dexie table
+       * @type {Dexie.Table}
+       */
+      ref: this.table(name),
+      // --- WRITE ---- // 
+      add: (data) => {
+        console.log("Adding data to", name, data);
+        return this.table(name).add({
+          id: v7_default(),
+          ...data
+        });
+      },
+      put: (data) => {
+        return this.table(name).put({
+          id: v7_default(),
+          ...data
+        });
+      },
+      update: (id, data) => {
+        return this.table(name).update(id, data);
+      },
+      delete: (id) => {
+        return this.table(name).delete(id);
+      },
+      // --- READ ---- // 
+      get: (id) => {
+        return this.table(name).get(id);
+      },
+      getAll: () => {
+        return this.table(name).toArray();
+      },
+      // --- QUERY ---- // 
+      // TODO: lots to do here. simplifing creating querie,  filtering/ordering/limit, and execute
+      query: () => this.table(name),
+      filter: (fn) => this.table(name).filter(fn).toArray()
+    };
+  }
+};
 
 // src/db.ts
 var baseUrl = "https://api.basic.tech";
@@ -5955,7 +7977,7 @@ async function get({ projectId, accountId, tableName, token }) {
   });
   return response.json();
 }
-async function add({ projectId, accountId, tableName, value, token }) {
+async function add2({ projectId, accountId, tableName, value, token }) {
   const url = `${baseUrl}/project/${projectId}/db/${accountId}/${tableName}`;
   const response = await fetch(url, {
     method: "POST",
@@ -6196,7 +8218,7 @@ function BasicProvider({ children, project_id, schema }) {
       add: async (value) => {
         checkSignIn();
         const tok = await getToken();
-        return add({ projectId: project_id, accountId: user.id, tableName, value, token: tok });
+        return add2({ projectId: project_id, accountId: user.id, tableName, value, token: tok });
       },
       update: async (id, value) => {
         checkSignIn();
@@ -6227,110 +8249,12 @@ function useBasic() {
   return useContext(BasicContext);
 }
 
-// ../../node_modules/dexie/import-wrapper.mjs
-var import_dexie = __toESM(require_dexie(), 1);
-var DexieSymbol = Symbol.for("Dexie");
-var Dexie = globalThis[DexieSymbol] || (globalThis[DexieSymbol] = import_dexie.default);
-if (import_dexie.default.semVer !== Dexie.semVer) {
-  throw new Error(`Two different versions of Dexie loaded in the same app: ${import_dexie.default.semVer} and ${Dexie.semVer}`);
-}
-var {
-  liveQuery,
-  mergeRanges,
-  rangesOverlap,
-  RangeSet,
-  cmp,
-  Entity,
-  PropModSymbol,
-  PropModification,
-  replacePrefix,
-  add: add2,
-  remove
-} = Dexie;
-
-// ../../node_modules/dexie-react-hooks/dist/dexie-react-hooks.mjs
-import React2 from "react";
-function useObservable(observableFactory, arg2, arg3) {
-  var deps;
-  var defaultResult;
-  if (typeof observableFactory === "function") {
-    deps = arg2 || [];
-    defaultResult = arg3;
-  } else {
-    deps = [];
-    defaultResult = arg2;
-  }
-  var monitor = React2.useRef({
-    hasResult: false,
-    result: defaultResult,
-    error: null
-  });
-  var _a = React2.useReducer(function(x) {
-    return x + 1;
-  }, 0);
-  _a[0];
-  var triggerUpdate = _a[1];
-  var observable = React2.useMemo(function() {
-    var observable2 = typeof observableFactory === "function" ? observableFactory() : observableFactory;
-    if (!observable2 || typeof observable2.subscribe !== "function") {
-      if (observableFactory === observable2) {
-        throw new TypeError("Given argument to useObservable() was neither a valid observable nor a function.");
-      } else {
-        throw new TypeError("Observable factory given to useObservable() did not return a valid observable.");
-      }
-    }
-    if (!monitor.current.hasResult && typeof window !== "undefined") {
-      if (typeof observable2.hasValue !== "function" || observable2.hasValue()) {
-        if (typeof observable2.getValue === "function") {
-          monitor.current.result = observable2.getValue();
-          monitor.current.hasResult = true;
-        } else {
-          var subscription = observable2.subscribe(function(val) {
-            monitor.current.result = val;
-            monitor.current.hasResult = true;
-          });
-          if (typeof subscription === "function") {
-            subscription();
-          } else {
-            subscription.unsubscribe();
-          }
-        }
-      }
-    }
-    return observable2;
-  }, deps);
-  React2.useDebugValue(monitor.current.result);
-  React2.useEffect(function() {
-    var subscription = observable.subscribe(function(val) {
-      var current = monitor.current;
-      if (current.error !== null || current.result !== val) {
-        current.error = null;
-        current.result = val;
-        current.hasResult = true;
-        triggerUpdate();
-      }
-    }, function(err) {
-      var current = monitor.current;
-      if (current.error !== err) {
-        current.error = err;
-        triggerUpdate();
-      }
-    });
-    return typeof subscription === "function" ? subscription : subscription.unsubscribe.bind(subscription);
-  }, deps);
-  if (monitor.current.error)
-    throw monitor.current.error;
-  return monitor.current.result;
-}
-function useLiveQuery(querier, deps, defaultResult) {
-  return useObservable(function() {
-    return liveQuery(querier);
-  }, deps || [], defaultResult);
-}
+// src/index.ts
+import { useLiveQuery as useQuery } from "dexie-react-hooks";
 export {
   BasicProvider,
   useBasic,
-  useLiveQuery as useQuery
+  useQuery
 };
 /*! Bundled license information: