dexie-cloud-addon 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/modern/service-worker.js

@@ -2120,1234 +2120,1218 @@ function timeout(due, scheduler) {
     return timeoutWith(due, throwError(new TimeoutError()), scheduler);
 }
 
-const { toString: toStr } = {};
-function getToStringTag(val) {
-    return toStr.call(val).slice(8, -1);
-}
-function escapeDollarProps(value) {
-    const keys = Object.keys(value);
-    let dollarKeys = null;
-    for (let i = 0, l = keys.length; i < l; ++i) {
-        if (keys[i][0] === "$") {
-            dollarKeys = dollarKeys || [];
-            dollarKeys.push(keys[i]);
+//const hasSW = 'serviceWorker' in navigator;
+let hasComplainedAboutSyncEvent = false;
+async function registerSyncEvent(db, purpose) {
+    try {
+        // Send sync event to SW:
+        const sw = await navigator.serviceWorker.ready;
+        if (purpose === "push" && sw.sync) {
+            await sw.sync.register(`dexie-cloud:${db.name}`);
+        }
+        if (sw.active) {
+            // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
+            // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
+            sw.active.postMessage({
+                type: 'dexie-cloud-sync',
+                dbName: db.name,
+                purpose
+            });
         }
+        else {
+            console.error(`Dexie Cloud: There's no active service worker. Can this ever happen??`);
+        }
+        return;
     }
-    if (!dollarKeys)
-        return value;
-    const clone = { ...value };
-    for (const k of dollarKeys) {
-        delete clone[k];
-        clone["$" + k] = value[k];
+    catch (e) {
+        if (!hasComplainedAboutSyncEvent) {
+            console.debug(`Dexie Cloud: Could not register sync event`, e);
+            hasComplainedAboutSyncEvent = true;
+        }
     }
-    return clone;
 }
-const ObjectDef = {
-    replace: escapeDollarProps,
-};
-function TypesonSimplified(...typeDefsInputs) {
-    const typeDefs = typeDefsInputs.reduce((p, c) => ({ ...p, ...c }), typeDefsInputs.reduce((p, c) => ({ ...c, ...p }), {}));
-    const protoMap = new WeakMap();
-    return {
-        stringify(value, alternateChannel, space) {
-            const json = JSON.stringify(value, function (key) {
-                const realVal = this[key];
-                const typeDef = getTypeDef(realVal);
-                return typeDef
-                    ? typeDef.replace(realVal, alternateChannel, typeDefs)
-                    : realVal;
-            }, space);
-            return json;
-        },
-        parse(tson, alternateChannel) {
-            let parent = null;
-            let unescapeParentKeys = [];
-            return JSON.parse(tson, function (key, value) {
-                //
-                // Parent Part
-                //
-                const type = value === null || value === void 0 ? void 0 : value.$t;
-                if (type) {
-                    const typeDef = typeDefs[type];
-                    value = typeDef
-                        ? typeDef.revive(value, alternateChannel, typeDefs)
-                        : value;
-                }
-                if (value === parent) {
-                    // Do what the kid told us to
-                    if (unescapeParentKeys.length > 0) {
-                        // Unescape dollar props
-                        value = { ...value };
-                        for (const k of unescapeParentKeys) {
-                            value[k.substr(1)] = value[k];
-                            delete value[k];
-                        }
-                    }
-                    unescapeParentKeys = [];
-                    return value;
-                }
-                //
-                // Child part
-                //
-                if (key[0] === "$" && key !== "$t") {
-                    parent = this;
-                    unescapeParentKeys.push(key);
-                }
-                return value;
-            });
-        },
-    };
-    function getTypeDef(realVal) {
-        const type = typeof realVal;
-        switch (typeof realVal) {
-            case "object":
-            case "function": {
-                // "object", "function", null
-                if (realVal === null)
-                    return null;
-                const proto = Object.getPrototypeOf(realVal);
-                if (!proto)
-                    return ObjectDef;
-                let typeDef = protoMap.get(proto);
-                if (typeDef !== undefined)
-                    return typeDef; // Null counts to! So the caching of Array.prototype also counts.
-                const toStringTag = getToStringTag(realVal);
-                const entry = Object.entries(typeDefs).find(([typeName, typeDef]) => { var _a, _b; return (_b = (_a = typeDef === null || typeDef === void 0 ? void 0 : typeDef.test) === null || _a === void 0 ? void 0 : _a.call(typeDef, realVal, toStringTag)) !== null && _b !== void 0 ? _b : typeName === toStringTag; });
-                typeDef = entry === null || entry === void 0 ? void 0 : entry[1];
-                if (!typeDef) {
-                    typeDef = Array.isArray(realVal)
-                        ? null
-                        : typeof realVal === "function"
-                            ? typeDefs.function || null
-                            : ObjectDef;
-                }
-                protoMap.set(proto, typeDef);
-                return typeDef;
+async function registerPeriodicSyncEvent(db) {
+    var _a;
+    try {
+        // Register periodicSync event to SW:
+        // @ts-ignore
+        const { periodicSync } = await navigator.serviceWorker.ready;
+        if (periodicSync) {
+            try {
+                await periodicSync.register(`dexie-cloud:${db.name}`, (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.periodicSync);
+                console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
+            }
+            catch (e) {
+                console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
             }
-            default:
-                return typeDefs[type];
         }
+        else {
+            console.debug(`Dexie Cloud: periodicSync not supported.`);
+        }
+    }
+    catch (e) {
+        console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
     }
 }
 
-const BisonBinaryTypes = {
-    Blob: {
-        test: (blob, toStringTag) => toStringTag === "Blob",
-        replace: (blob, altChannel) => {
-            const i = altChannel.length;
-            altChannel.push(blob);
-            return {
-                $t: "Blob",
-                mimeType: blob.type,
-                i,
-            };
-        },
-        revive: ({ i, mimeType }, altChannel) => new Blob([altChannel[i]], { type: mimeType }),
-    },
-};
-
-var numberDef = {
-    number: {
-        replace: (num) => {
-            switch (true) {
-                case isNaN(num):
-                    return { $t: "number", v: "NaN" };
-                case num === Infinity:
-                    return { $t: "number", v: "Infinity" };
-                case num === -Infinity:
-                    return { $t: "number", v: "-Infinity" };
-                default:
-                    return num;
-            }
-        },
-        revive: ({ v }) => Number(v),
-    },
-};
+function triggerSync(db, purpose) {
+    if (db.cloud.usingServiceWorker) {
+        registerSyncEvent(db, purpose);
+    }
+    else {
+        db.localSyncEvent.next({ purpose });
+    }
+}
 
-const bigIntDef = {
-    bigint: {
-        replace: (realVal) => {
-            return { $t: "bigint", v: "" + realVal };
-        },
-        revive: (obj) => BigInt(obj.v),
-    },
-};
+const b64decode = typeof Buffer !== "undefined"
+    ? (base64) => Buffer.from(base64, "base64")
+    : (base64) => {
+        const binary_string = atob(base64);
+        const len = binary_string.length;
+        const bytes = new Uint8Array(len);
+        for (var i = 0; i < len; i++) {
+            bytes[i] = binary_string.charCodeAt(i);
+        }
+        return bytes;
+    };
+const b64encode = typeof Buffer !== "undefined"
+    ? (b) => ArrayBuffer.isView(b)
+        ? Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64")
+        : Buffer.from(b).toString("base64")
+    : (b) => btoa(String.fromCharCode.apply(null, b));
 
-var DateDef = {
-    Date: {
-        replace: (date) => ({
-            $t: "Date",
-            v: isNaN(date.getTime()) ? "NaN" : date.toISOString(),
-        }),
-        revive: ({ v }) => new Date(v === "NaN" ? NaN : Date.parse(v)),
-    },
-};
+async function computeRealmSetHash({ realms, inviteRealms, }) {
+    const data = JSON.stringify([
+        ...realms.map((realmId) => ({ realmId, accepted: true })),
+        ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
+    ].sort((a, b) => a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0));
+    const byteArray = new TextEncoder().encode(data);
+    const digestBytes = await crypto.subtle.digest('SHA-1', byteArray);
+    const base64 = b64encode(digestBytes);
+    return base64;
+}
 
-var SetDef = {
-    Set: {
-        replace: (set) => ({
-            $t: "Set",
-            v: Array.from(set.entries()),
-        }),
-        revive: ({ v }) => new Set(v),
-    },
-};
+function getSyncableTables(db) {
+    return Object.entries(db.cloud.schema || {})
+        .filter(([, { markedForSync }]) => markedForSync)
+        .map(([tbl]) => db.table(tbl));
+}
 
-var MapDef = {
-    Map: {
-        replace: (map) => ({
-            $t: "Map",
-            v: Array.from(map.entries()),
-        }),
-        revive: ({ v }) => new Map(v),
-    },
-};
+function getMutationTable(tableName) {
+    return `$${tableName}_mutations`;
+}
 
-const _global = typeof globalThis !== "undefined"
-    ? globalThis
-    : typeof self !== "undefined"
-        ? self
-        : typeof global === "undefined"
-            ? global
-            : undefined;
+function getTableFromMutationTable(mutationTable) {
+    var _a;
+    const tableName = (_a = /^\$(.*)_mutations$/.exec(mutationTable)) === null || _a === void 0 ? void 0 : _a[1];
+    if (!tableName)
+        throw new Error(`Given mutationTable ${mutationTable} is not correct`);
+    return tableName;
+}
 
-var TypedArraysDefs = [
-    "Int8Array",
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "Int16Array",
-    "Uint16Array",
-    "Int32Array",
-    "Uint32Array",
-    "Float32Array",
-    "Float64Array",
-    "DataView",
-    "BigInt64Array",
-    "BigUint64Array",
-].reduce((specs, typeName) => ({
-    ...specs,
-    [typeName]: {
-        // Replace passes the the typed array into $t, buffer so that
-        // the ArrayBuffer typedef takes care of further handling of the buffer:
-        // {$t:"Uint8Array",buffer:{$t:"ArrayBuffer",idx:0}}
-        // CHANGED ABOVE! Now shortcutting that for more sparse format of the typed arrays
-        // to contain the b64 property directly.
-        replace: (a, _, typeDefs) => {
-            const result = {
-                $t: typeName,
-                v: typeDefs.ArrayBuffer.replace(a.byteOffset === 0 && a.byteLength === a.buffer.byteLength
-                    ? a.buffer
-                    : a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength), _, typeDefs).v,
-            };
-            return result;
-        },
-        revive: ({ v }, _, typeDefs) => {
-            const TypedArray = _global[typeName];
-            return (TypedArray &&
-                new TypedArray(typeDefs.ArrayBuffer.revive({ v }, _, typeDefs)));
-        },
-    },
-}), {});
+async function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
+    const allMutsOnTables = await Promise.all(mutationTables.map(async (mutationTable) => {
+        const tableName = getTableFromMutationTable(mutationTable.name);
+        const lastRevision = since[tableName];
+        let query = lastRevision
+            ? mutationTable.where("rev").above(lastRevision)
+            : mutationTable;
+        if (limit < Infinity)
+            query = query.limit(limit);
+        const muts = await query.toArray();
+        //const objTable = db.table(tableName);
+        /*for (const mut of muts) {
+          if (mut.type === "insert" || mut.type === "upsert") {
+            mut.values = await objTable.bulkGet(mut.keys);
+          }
+        }*/
+        return {
+            table: tableName,
+            muts,
+        };
+    }));
+    // Filter out those tables that doesn't have any mutations:
+    return allMutsOnTables.filter(({ muts }) => muts.length > 0);
+}
 
-const b64decode = typeof Buffer !== "undefined"
-    ? (base64) => Buffer.from(base64, "base64")
-    : (base64) => {
-        const binary_string = atob(base64);
-        const len = binary_string.length;
-        const bytes = new Uint8Array(len);
-        for (var i = 0; i < len; i++) {
-            bytes[i] = binary_string.charCodeAt(i);
-        }
-        return bytes;
-    };
-const b64encode = typeof Buffer !== "undefined"
-    ? (b) => ArrayBuffer.isView(b)
-        ? Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64")
-        : Buffer.from(b).toString("base64")
-    : (b) => btoa(String.fromCharCode.apply(null, b));
+//@ts-check
+const randomFillSync = crypto.getRandomValues;
 
-function b64LexEncode(b) {
-    return b64ToLex(b64encode(b));
-}
-function b64LexDecode(b64Lex) {
-    return b64decode(lexToB64(b64Lex));
-}
-function b64ToLex(base64) {
-    var encoded = "";
-    for (var i = 0, length = base64.length; i < length; i++) {
-        encoded += ENCODE_TABLE[base64[i]];
-    }
-    return encoded;
+function assert(b) {
+    if (!b)
+        throw new Error('Assertion Failed');
 }
-function lexToB64(base64lex) {
-    // only accept string input
-    if (typeof base64lex !== "string") {
-        throw new Error("invalid decoder input: " + base64lex);
+function setByKeyPath(obj, keyPath, value) {
+    if (!obj || keyPath === undefined)
+        return;
+    if ('isFrozen' in Object && Object.isFrozen(obj))
+        return;
+    if (typeof keyPath !== 'string' && 'length' in keyPath) {
+        assert(typeof value !== 'string' && 'length' in value);
+        for (var i = 0, l = keyPath.length; i < l; ++i) {
+            setByKeyPath(obj, keyPath[i], value[i]);
+        }
     }
-    var base64 = "";
-    for (var i = 0, length = base64lex.length; i < length; i++) {
-        base64 += DECODE_TABLE[base64lex[i]];
+    else {
+        var period = keyPath.indexOf('.');
+        if (period !== -1) {
+            var currentKeyPath = keyPath.substr(0, period);
+            var remainingKeyPath = keyPath.substr(period + 1);
+            if (remainingKeyPath === '')
+                if (value === undefined) {
+                    if (Array.isArray(obj)) {
+                        if (!isNaN(parseInt(currentKeyPath)))
+                            obj.splice(parseInt(currentKeyPath), 1);
+                    }
+                    else
+                        delete obj[currentKeyPath];
+                    // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                }
+                else
+                    obj[currentKeyPath] = value;
+            else {
+                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                var innerObj = obj[currentKeyPath];
+                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                if (!innerObj)
+                    innerObj = obj[currentKeyPath] = {};
+                setByKeyPath(innerObj, remainingKeyPath, value);
+            }
+        }
+        else {
+            if (value === undefined) {
+                if (Array.isArray(obj) && !isNaN(parseInt(keyPath)))
+                    // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                    obj.splice(keyPath, 1);
+                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                else
+                    delete obj[keyPath];
+                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+            }
+            else
+                obj[keyPath] = value;
+        }
     }
-    return base64;
 }
-const DECODE_TABLE = {
-    "-": "=",
-    "0": "A",
-    "1": "B",
-    "2": "C",
-    "3": "D",
-    "4": "E",
-    "5": "F",
-    "6": "G",
-    "7": "H",
-    "8": "I",
-    "9": "J",
-    A: "K",
-    B: "L",
-    C: "M",
-    D: "N",
-    E: "O",
-    F: "P",
-    G: "Q",
-    H: "R",
-    I: "S",
-    J: "T",
-    K: "U",
-    L: "V",
-    M: "W",
-    N: "X",
-    O: "Y",
-    P: "Z",
-    Q: "a",
-    R: "b",
-    S: "c",
-    T: "d",
-    U: "e",
-    V: "f",
-    W: "g",
-    X: "h",
-    Y: "i",
-    Z: "j",
-    _: "k",
-    a: "l",
-    b: "m",
-    c: "n",
-    d: "o",
-    e: "p",
-    f: "q",
-    g: "r",
-    h: "s",
-    i: "t",
-    j: "u",
-    k: "v",
-    l: "w",
-    m: "x",
-    n: "y",
-    o: "z",
-    p: "0",
-    q: "1",
-    r: "2",
-    s: "3",
-    t: "4",
-    u: "5",
-    v: "6",
-    w: "7",
-    x: "8",
-    y: "9",
-    z: "+",
-    "|": "/",
+const randomString$1 = typeof self === 'undefined' ? (bytes) => {
+    // Node
+    const buf = Buffer.alloc(bytes);
+    randomFillSync(buf);
+    return buf.toString("base64");
+} : (bytes) => {
+    // Web
+    const buf = new Uint8Array(bytes);
+    crypto.getRandomValues(buf);
+    return btoa(String.fromCharCode.apply(null, buf));
 };
-const ENCODE_TABLE = {};
-for (const c of Object.keys(DECODE_TABLE)) {
-    ENCODE_TABLE[DECODE_TABLE[c]] = c;
-}
 
-var ArrayBufferDef = {
-    ArrayBuffer: {
-        replace: (ab) => ({
-            $t: "ArrayBuffer",
-            v: b64LexEncode(ab),
-        }),
-        revive: ({ v }) => {
-            const ba = b64LexDecode(v);
-            return ba.buffer.byteLength === ba.byteLength
-                ? ba.buffer
-                : ba.buffer.slice(ba.byteOffset, ba.byteOffset + ba.byteLength);
-        },
-    },
-};
-
-class FakeBlob {
-    constructor(buf, type) {
-        this.buf = buf;
-        this.type = type;
-    }
+/** Verifies that given primary key is valid.
+ * The reason we narrow validity for valid keys are twofold:
+ *  1: Make sure to only support types that can be used as an object index in DBKeyMutationSet.
+ *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
+ *     used (gives comma-delimited list of included bytes).
+ *  2: Avoid using plain numbers and Dates as keys when they are synced, as they are not globally unique.
+ *  3: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
+ *
+ * @param id
+ * @returns
+ */
+function isValidSyncableID(id) {
+    if (typeof id === "string")
+        return true;
+    //if (validIDTypes[toStringTag(id)]) return true;
+    //if (Array.isArray(id)) return id.every((part) => isValidSyncableID(part));
+    if (Array.isArray(id) && id.some(key => isValidSyncableID(key)) && id.every(isValidSyncableIDPart))
+        return true;
+    return false;
+}
+/** Verifies that given key part is valid.
+ *  1: Make sure that arrays of this types are stringified correclty and works with DBKeyMutationSet.
+ *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
+ *     used (gives comma-delimited list of included bytes).
+ *  2: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
+*/
+function isValidSyncableIDPart(part) {
+    return typeof part === "string" || typeof part === "number" || Array.isArray(part) && part.every(isValidSyncableIDPart);
+}
+function isValidAtID(id, idPrefix) {
+    return !idPrefix || (typeof id === "string" && id.startsWith(idPrefix));
 }
 
-function readBlobSync(b) {
-    const req = new XMLHttpRequest();
-    req.overrideMimeType("text/plain; charset=x-user-defined");
-    req.open("GET", URL.createObjectURL(b), false); // Sync
-    req.send();
-    if (req.status !== 200 && req.status !== 0) {
-        throw new Error("Bad Blob access: " + req.status);
+function applyOperation(target, table, op) {
+    const tbl = target[table] || (target[table] = {});
+    switch (op.type) {
+        case "insert":
+        // TODO: Don't treat insert and upsert the same?
+        case "upsert":
+            op.keys.forEach((key, idx) => {
+                tbl[key] = {
+                    type: "ups",
+                    val: op.values[idx],
+                };
+            });
+            break;
+        case "update":
+        case "modify": {
+            op.keys.forEach((key, idx) => {
+                const changeSpec = op.type === "update"
+                    ? op.changeSpecs[idx]
+                    : op.changeSpec;
+                const entry = tbl[key];
+                if (!entry) {
+                    tbl[key] = {
+                        type: "upd",
+                        mod: changeSpec,
+                    };
+                }
+                else {
+                    switch (entry.type) {
+                        case "ups":
+                            // Adjust the existing upsert with additional updates
+                            for (const [propPath, value] of Object.entries(changeSpec)) {
+                                setByKeyPath(entry.val, propPath, value);
+                            }
+                            break;
+                        case "del":
+                            // No action.
+                            break;
+                        case "upd":
+                            // Adjust existing update with additional updates
+                            Object.assign(entry.mod, changeSpec); // May work for deep props as well - new keys is added later, right? Does the prop order persist along TSON and all? But it will not be 100% when combined with some server code (seach for "address.city": "Stockholm" comment)
+                            break;
+                    }
+                }
+            });
+            break;
+        }
+        case "delete":
+            op.keys.forEach((key) => {
+                tbl[key] = {
+                    type: "del",
+                };
+            });
+            break;
     }
-    return req.responseText;
+    return target;
 }
 
-function string2ArrayBuffer(str) {
-    const array = new Uint8Array(str.length);
-    for (let i = 0; i < str.length; ++i) {
-        array[i] = str.charCodeAt(i); // & 0xff;
+function applyOperations(target, ops) {
+    for (const { table, muts } of ops) {
+        for (const mut of muts) {
+            applyOperation(target, table, mut);
+        }
     }
-    return array.buffer;
 }
 
-var BlobDef = {
-    Blob: {
-        test: (blob, toStringTag) => toStringTag === "Blob" || blob instanceof FakeBlob,
-        replace: (blob) => ({
-            $t: "Blob",
-            v: blob instanceof FakeBlob
-                ? b64encode(blob.buf)
-                : b64encode(string2ArrayBuffer(readBlobSync(blob))),
-            type: blob.type,
-        }),
-        revive: ({ type, v }) => {
-            const ab = b64decode(v);
-            return typeof Blob !== undefined
-                ? new Blob([ab])
-                : new FakeBlob(ab.buffer, type);
-        },
-    },
-};
-
-const builtin = {
-    ...numberDef,
-    ...bigIntDef,
-    ...DateDef,
-    ...SetDef,
-    ...MapDef,
-    ...TypedArraysDefs,
-    ...ArrayBufferDef,
-    ...BlobDef,
-};
-
-function Bison(...typeDefsInputs) {
-    const tson = TypesonSimplified(builtin, BisonBinaryTypes, ...typeDefsInputs);
-    return {
-        toBinary(value) {
-            const [blob, json] = this.stringify(value);
-            const lenBuf = new ArrayBuffer(4);
-            new DataView(lenBuf).setUint32(0, blob.size);
-            return new Blob([lenBuf, blob, json]);
-        },
-        stringify(value) {
-            const binaries = [];
-            const json = tson.stringify(value, binaries);
-            const blob = new Blob(binaries.map((b) => {
-                const lenBuf = new ArrayBuffer(4);
-                new DataView(lenBuf).setUint32(0, "byteLength" in b ? b.byteLength : b.size);
-                return new Blob([lenBuf, b]);
-            }));
-            return [blob, json];
-        },
-        async parse(json, binData) {
-            let pos = 0;
-            const arrayBuffers = [];
-            const buf = await readBlobBinary(binData);
-            const view = new DataView(buf);
-            while (pos < buf.byteLength) {
-                const len = view.getUint32(pos);
-                pos += 4;
-                const ab = buf.slice(pos, pos + len);
-                pos += len;
-                arrayBuffers.push(ab);
+function subtractChanges(target, // Server change set
+changesToSubtract // additional mutations on client during syncWithServer()
+) {
+    var _a, _b, _c;
+    for (const [table, mutationSet] of Object.entries(changesToSubtract)) {
+        for (const [key, mut] of Object.entries(mutationSet)) {
+            switch (mut.type) {
+                case 'ups':
+                    {
+                        const targetMut = (_a = target[table]) === null || _a === void 0 ? void 0 : _a[key];
+                        if (targetMut) {
+                            switch (targetMut.type) {
+                                case 'ups':
+                                    delete target[table][key];
+                                    break;
+                                case 'del':
+                                    // Leave delete operation.
+                                    // (Don't resurrect objects unintenionally (using tx(get, put) pattern locally))
+                                    break;
+                                case 'upd':
+                                    delete target[table][key];
+                                    break;
+                            }
+                        }
+                    }
+                    break;
+                case 'del':
+                    (_b = target[table]) === null || _b === void 0 ? true : delete _b[key];
+                    break;
+                case 'upd': {
+                    const targetMut = (_c = target[table]) === null || _c === void 0 ? void 0 : _c[key];
+                    if (targetMut) {
+                        switch (targetMut.type) {
+                            case 'ups':
+                                // Adjust the server upsert with locally updated values.
+                                for (const [propPath, value] of Object.entries(mut.mod)) {
+                                    setByKeyPath(targetMut.val, propPath, value);
+                                }
+                                break;
+                            case 'del':
+                                // Leave delete.
+                                break;
+                            case 'upd':
+                                // Remove the local update props from the server update mutation.
+                                for (const propPath of Object.keys(mut.mod)) {
+                                    delete targetMut.mod[propPath];
+                                }
+                                break;
+                        }
+                    }
+                    break;
+                }
             }
-            return tson.parse(json, arrayBuffers);
-        },
-        async fromBinary(blob) {
-            const len = new DataView(await readBlobBinary(blob.slice(0, 4))).getUint32(0);
-            const binData = blob.slice(4, len + 4);
-            const json = await readBlob(blob.slice(len + 4));
-            return await this.parse(json, binData);
-        },
-    };
-}
-function readBlob(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onabort = (ev) => reject(new Error("file read aborted"));
-        reader.onerror = (ev) => reject(ev.target.error);
-        reader.onload = (ev) => resolve(ev.target.result);
-        reader.readAsText(blob);
-    });
-}
-function readBlobBinary(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onabort = (ev) => reject(new Error("file read aborted"));
-        reader.onerror = (ev) => reject(ev.target.error);
-        reader.onload = (ev) => resolve(ev.target.result);
-        reader.readAsArrayBuffer(blob);
-    });
+        }
+    }
 }
 
-/** The undefined type is not part of builtin but can be manually added.
- * The reason for supporting undefined is if the following object should be revived correctly:
- *
- *    {foo: undefined}
+/** Convert a DBKeyMutationSet (which is an internal format capable of looking up changes per ID)
+ * ...into a DBOperationsSet (which is more optimal for performing DB operations into DB (bulkAdd() etc))
  *
- * Without including this typedef, the revived object would just be {}.
- * If including this typedef, the revived object would be {foo: undefined}.
+ * @param inSet
+ * @returns DBOperationsSet representing inSet
  */
-var undefinedDef = {
-    undefined: {
-        replace: () => {
-        },
-        revive: () => undefined,
-    },
-};
-
-// Since server revisions are stored in bigints, we need to handle clients without
-// bigint support to not fail when serverRevision is passed over to client.
-// We need to not fail when reviving it and we need to somehow store the information.
-// Since the revived version will later on be put into indexedDB we have another
-// issue: When reading it back from indexedDB we will get a poco object that we
-// cannot replace correctly when sending it to server. So we will also need
-// to do an explicit workaround in the protocol where a bigint is supported.
-// The workaround should be there regardless if browser supports BigInt or not, because
-// the serverRev might have been stored in IDB before the browser was upgraded to support bigint.
-//
-// if (typeof serverRev.rev !== "bigint")
-//   if (hasBigIntSupport)
-//     serverRev.rev = bigIntDef.bigint.revive(server.rev)
-//   else
-//     serverRev.rev = new FakeBigInt(server.rev)
-const hasBigIntSupport = typeof BigInt(0) === 'bigint';
-function getValueOfBigInt(x) {
-    if (typeof x === 'bigint') {
-        return x;
-    }
-    if (hasBigIntSupport) {
-        return typeof x === 'string' ? BigInt(x) : BigInt(x.v);
-    }
-    else {
-        return typeof x === 'string' ? Number(x) : Number(x.v);
-    }
-}
-function compareBigInts(a, b) {
-    const valA = getValueOfBigInt(a);
-    const valB = getValueOfBigInt(b);
-    return valA < valB ? -1 : valA > valB ? 1 : 0;
-}
-class FakeBigInt {
-    constructor(value) {
-        this.v = value;
-    }
-    toString() {
-        return this.v;
-    }
-}
-const defs = {
-    ...undefinedDef,
-    ...(hasBigIntSupport
-        ? {}
-        : {
-            bigint: {
-                test: (val) => val instanceof FakeBigInt,
-                replace: (fakeBigInt) => {
-                    return {
-                        $t: 'bigint',
-                        ...fakeBigInt
-                    };
-                },
-                revive: ({ v, }) => new FakeBigInt(v)
-            }
-        })
-};
-const TSON = TypesonSimplified(builtin, defs);
-const BISON = Bison(defs);
-
-//const hasSW = 'serviceWorker' in navigator;
-let hasComplainedAboutSyncEvent = false;
-async function registerSyncEvent(db, purpose) {
-    try {
-        // Send sync event to SW:
-        const sw = await navigator.serviceWorker.ready;
-        if (purpose === "push" && sw.sync) {
-            await sw.sync.register(`dexie-cloud:${db.name}`);
-        }
-        if (sw.active) {
-            // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
-            // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
-            sw.active.postMessage({
-                type: 'dexie-cloud-sync',
-                dbName: db.name,
-                purpose
-            });
-        }
-        else {
-            console.error(`Dexie Cloud: There's no active service worker. Can this ever happen??`);
-        }
-        return;
-    }
-    catch (e) {
-        if (!hasComplainedAboutSyncEvent) {
-            console.debug(`Dexie Cloud: Could not register sync event`, e);
-            hasComplainedAboutSyncEvent = true;
+function toDBOperationSet(inSet) {
+    // Fictive transaction:
+    const txid = randomString$1(16);
+    // Convert data into a temporary map to collect mutations of same table and type
+    const map = {};
+    for (const [table, ops] of Object.entries(inSet)) {
+        for (const [key, op] of Object.entries(ops)) {
+            const mapEntry = map[table] || (map[table] = {});
+            const ops = mapEntry[op.type] || (mapEntry[op.type] = []);
+            ops.push(Object.assign({ key }, op)); // DBKeyMutation doesn't contain key, so we need to bring it in.
         }
     }
-}
-async function registerPeriodicSyncEvent(db) {
-    var _a;
-    try {
-        // Register periodicSync event to SW:
-        // @ts-ignore
-        const { periodicSync } = await navigator.serviceWorker.ready;
-        if (periodicSync) {
-            try {
-                await periodicSync.register(`dexie-cloud:${db.name}`, (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.periodicSync);
-                console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
-            }
-            catch (e) {
-                console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
+    // Start computing the resulting format:
+    const result = [];
+    for (const [table, ops] of Object.entries(map)) {
+        const resultEntry = {
+            table,
+            muts: [],
+        };
+        for (const [optype, muts] of Object.entries(ops)) {
+            switch (optype) {
+                case "ups": {
+                    const op = {
+                        type: "upsert",
+                        keys: muts.map(mut => mut.key),
+                        values: muts.map(mut => mut.val),
+                        txid
+                    };
+                    resultEntry.muts.push(op);
+                    break;
+                }
+                case "upd": {
+                    const op = {
+                        type: "update",
+                        keys: muts.map(mut => mut.key),
+                        changeSpecs: muts.map(mut => mut.mod),
+                        txid
+                    };
+                    resultEntry.muts.push(op);
+                    break;
+                }
+                case "del": {
+                    const op = {
+                        type: "delete",
+                        keys: muts.map(mut => mut.key),
+                        txid,
+                    };
+                    resultEntry.muts.push(op);
+                    break;
+                }
             }
         }
-        else {
-            console.debug(`Dexie Cloud: periodicSync not supported.`);
-        }
-    }
-    catch (e) {
-        console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
+        result.push(resultEntry);
     }
+    return result;
 }
 
-function triggerSync(db, purpose) {
-    if (db.cloud.usingServiceWorker) {
-        registerSyncEvent(db, purpose);
-    }
-    else {
-        db.localSyncEvent.next({ purpose });
-    }
+function getDbNameFromDbUrl(dbUrl) {
+    const url = new URL(dbUrl);
+    return url.pathname === "/"
+        ? url.hostname.split('.')[0]
+        : url.pathname.split('/')[1];
 }
 
-async function computeRealmSetHash({ realms, inviteRealms, }) {
-    const data = JSON.stringify([
-        ...realms.map((realmId) => ({ realmId, accepted: true })),
-        ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
-    ].sort((a, b) => a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0));
-    const byteArray = new TextEncoder().encode(data);
-    const digestBytes = await crypto.subtle.digest('SHA-1', byteArray);
-    const base64 = b64encode(digestBytes);
-    return base64;
+async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
+    if (currentUser.isLoggedIn) {
+        if (tablesToSyncify.length > 0) {
+            const ignoredRealms = new Set(alreadySyncedRealms || []);
+            const inserts = await Promise.all(tablesToSyncify.map(async (table) => {
+                const { extractKey } = table.core.schema.primaryKey;
+                if (!extractKey)
+                    return { table: table.name, muts: [] }; // Outbound tables are not synced.
+                const dexieCloudTableSchema = schema[table.name];
+                const query = (dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
+                    ? table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidSyncableID(extractKey(item)))
+                    : table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix));
+                const unsyncedObjects = await query.toArray();
+                if (unsyncedObjects.length > 0) {
+                    const mut = {
+                        type: "insert",
+                        values: unsyncedObjects,
+                        keys: unsyncedObjects.map(extractKey),
+                        userId: currentUser.userId,
+                    };
+                    return {
+                        table: table.name,
+                        muts: [mut],
+                    };
+                }
+                else {
+                    return {
+                        table: table.name,
+                        muts: []
+                    };
+                }
+            }));
+            return inserts.filter(op => op.muts.length > 0);
+        }
+    }
+    return [];
 }
 
-function getSyncableTables(db) {
-    return Object.entries(db.cloud.schema || {})
-        .filter(([, { markedForSync }]) => markedForSync)
-        .map(([tbl]) => db.table(tbl));
+function getTablesToSyncify(db, syncState) {
+    const syncedTables = (syncState === null || syncState === void 0 ? void 0 : syncState.syncedTables) || [];
+    const syncableTables = getSyncableTables(db);
+    const tablesToSyncify = syncableTables.filter((tbl) => !syncedTables.includes(tbl.name));
+    return tablesToSyncify;
 }
 
-function getMutationTable(tableName) {
-    return `$${tableName}_mutations`;
+function interactWithUser(userInteraction, req) {
+    return new Promise((resolve, reject) => {
+        const interactionProps = {
+            ...req,
+            onSubmit: (res) => {
+                userInteraction.next(undefined);
+                resolve(res);
+            },
+            onCancel: () => {
+                userInteraction.next(undefined);
+                reject(new Dexie.AbortError("User cancelled"));
+            },
+        };
+        userInteraction.next(interactionProps);
+        // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
+        /*const subscription = userInteraction.subscribe((currentInteractionProps) => {
+          if (currentInteractionProps !== interactionProps) {
+            if (subscription) subscription.unsubscribe();
+            if (!done) {
+              reject(new Dexie.AbortError("User cancelled"));
+            }
+          }
+        });*/
+    });
 }
-
-function getTableFromMutationTable(mutationTable) {
-    var _a;
-    const tableName = (_a = /^\$(.*)_mutations$/.exec(mutationTable)) === null || _a === void 0 ? void 0 : _a[1];
-    if (!tableName)
-        throw new Error(`Given mutationTable ${mutationTable} is not correct`);
-    return tableName;
+function alertUser(userInteraction, title, ...alerts) {
+    return interactWithUser(userInteraction, {
+        type: 'message-alert',
+        title,
+        alerts,
+        fields: {}
+    });
 }
-
-async function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
-    const allMutsOnTables = await Promise.all(mutationTables.map(async (mutationTable) => {
-        const tableName = getTableFromMutationTable(mutationTable.name);
-        const lastRevision = since[tableName];
-        let query = lastRevision
-            ? mutationTable.where("rev").above(lastRevision)
-            : mutationTable;
-        if (limit < Infinity)
-            query = query.limit(limit);
-        const muts = await query.toArray();
-        //const objTable = db.table(tableName);
-        /*for (const mut of muts) {
-          if (mut.type === "insert" || mut.type === "upsert") {
-            mut.values = await objTable.bulkGet(mut.keys);
-          }
-        }*/
-        return {
-            table: tableName,
-            muts,
-        };
-    }));
-    // Filter out those tables that doesn't have any mutations:
-    return allMutsOnTables.filter(({ muts }) => muts.length > 0);
+async function promptForEmail(userInteraction, title, emailHint) {
+    let email = emailHint || '';
+    while (!email || !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,10}$/.test(email)) {
+        email = (await interactWithUser(userInteraction, {
+            type: 'email',
+            title,
+            alerts: email
+                ? [
+                    {
+                        type: 'error',
+                        messageCode: 'INVALID_EMAIL',
+                        message: 'Please enter a valid email address',
+                        messageParams: {},
+                    },
+                ]
+                : [],
+            fields: {
+                email: {
+                    type: 'email',
+                    placeholder: 'you@somedomain.com',
+                },
+            },
+        })).email;
+    }
+    return email;
 }
-
-//@ts-check
-const randomFillSync = crypto.getRandomValues;
-
-function assert(b) {
-    if (!b)
-        throw new Error('Assertion Failed');
+async function promptForOTP(userInteraction, email, alert) {
+    const alerts = [
+        {
+            type: 'info',
+            messageCode: 'OTP_SENT',
+            message: `A One-Time password has been sent to {email}`,
+            messageParams: { email },
+        },
+    ];
+    if (alert) {
+        alerts.push(alert);
+    }
+    const { otp } = await interactWithUser(userInteraction, {
+        type: 'otp',
+        title: 'Enter OTP',
+        alerts,
+        fields: {
+            otp: {
+                type: 'otp',
+                label: 'OTP',
+                placeholder: 'Paste OTP here',
+            },
+        },
+    });
+    return otp;
 }
-function setByKeyPath(obj, keyPath, value) {
-    if (!obj || keyPath === undefined)
-        return;
-    if ('isFrozen' in Object && Object.isFrozen(obj))
+
+async function loadAccessToken(db) {
+    var _a, _b;
+    const currentUser = await db.getCurrentUser();
+    const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
+    if (!accessToken)
         return;
-    if (typeof keyPath !== 'string' && 'length' in keyPath) {
-        assert(typeof value !== 'string' && 'length' in value);
-        for (var i = 0, l = keyPath.length; i < l; ++i) {
-            setByKeyPath(obj, keyPath[i], value[i]);
-        }
+    const expTime = (_a = accessTokenExpiration === null || accessTokenExpiration === void 0 ? void 0 : accessTokenExpiration.getTime()) !== null && _a !== void 0 ? _a : Infinity;
+    if (expTime > Date.now()) {
+        return accessToken;
+    }
+    if (!refreshToken) {
+        throw new Error(`Refresh token missing`);
+    }
+    const refreshExpTime = (_b = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _b !== void 0 ? _b : Infinity;
+    if (refreshExpTime <= Date.now()) {
+        throw new Error(`Refresh token has expired`);
+    }
+    const refreshedLogin = await refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
+    await db.table('$logins').update(claims.sub, {
+        accessToken: refreshedLogin.accessToken,
+        accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+    });
+    return refreshedLogin.accessToken;
+}
+async function authenticate(url, context, fetchToken, userInteraction, hints) {
+    if (context.accessToken &&
+        context.accessTokenExpiration.getTime() > Date.now()) {
+        return context;
+    }
+    else if (context.refreshToken &&
+        (!context.refreshTokenExpiration ||
+            context.refreshTokenExpiration.getTime() > Date.now())) {
+        return await refreshAccessToken(url, context);
     }
     else {
-        var period = keyPath.indexOf('.');
-        if (period !== -1) {
-            var currentKeyPath = keyPath.substr(0, period);
-            var remainingKeyPath = keyPath.substr(period + 1);
-            if (remainingKeyPath === '')
-                if (value === undefined) {
-                    if (Array.isArray(obj)) {
-                        if (!isNaN(parseInt(currentKeyPath)))
-                            obj.splice(parseInt(currentKeyPath), 1);
-                    }
-                    else
-                        delete obj[currentKeyPath];
-                    // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                }
-                else
-                    obj[currentKeyPath] = value;
-            else {
-                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                var innerObj = obj[currentKeyPath];
-                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                if (!innerObj)
-                    innerObj = obj[currentKeyPath] = {};
-                setByKeyPath(innerObj, remainingKeyPath, value);
-            }
+        return await userAuthenticate(context, fetchToken, userInteraction, hints);
+    }
+}
+async function refreshAccessToken(url, login) {
+    if (!login.refreshToken)
+        throw new Error(`Cannot refresh token - refresh token is missing.`);
+    if (!login.nonExportablePrivateKey)
+        throw new Error(`login.nonExportablePrivateKey is missing - cannot sign refresh token without a private key.`);
+    const time_stamp = Date.now();
+    const signing_algorithm = 'RSASSA-PKCS1-v1_5';
+    const textEncoder = new TextEncoder();
+    const data = textEncoder.encode(login.refreshToken + time_stamp);
+    const binarySignature = await crypto.subtle.sign(signing_algorithm, login.nonExportablePrivateKey, data);
+    const signature = b64encode(binarySignature);
+    const tokenRequest = {
+        grant_type: 'refresh_token',
+        refresh_token: login.refreshToken,
+        scopes: ['ACCESS_DB'],
+        signature,
+        signing_algorithm,
+        time_stamp,
+    };
+    const res = await fetch(`${url}/token`, {
+        body: JSON.stringify(tokenRequest),
+        method: 'post',
+        headers: { 'Content-Type': 'application/json' },
+        mode: 'cors',
+    });
+    if (res.status !== 200)
+        throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
+    const response = await res.json();
+    login.accessToken = response.accessToken;
+    login.accessTokenExpiration = response.accessTokenExpiration
+        ? new Date(response.accessTokenExpiration)
+        : undefined;
+    return login;
+}
+async function userAuthenticate(context, fetchToken, userInteraction, hints) {
+    const { privateKey, publicKey } = await crypto.subtle.generateKey({
+        name: 'RSASSA-PKCS1-v1_5',
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+        hash: { name: 'SHA-256' },
+    }, false, // Non-exportable...
+    ['sign', 'verify']);
+    context.nonExportablePrivateKey = privateKey; //...but storable!
+    const publicKeySPKI = await crypto.subtle.exportKey('spki', publicKey);
+    const publicKeyPEM = spkiToPEM(publicKeySPKI);
+    context.publicKey = publicKey;
+    try {
+        const response2 = await fetchToken({
+            public_key: publicKeyPEM,
+            hints,
+        });
+        if (response2.type !== 'tokens')
+            throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
+        context.accessToken = response2.accessToken;
+        context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
+        context.refreshToken = response2.refreshToken;
+        if (response2.refreshTokenExpiration) {
+            context.refreshTokenExpiration = new Date(response2.refreshTokenExpiration);
         }
-        else {
-            if (value === undefined) {
-                if (Array.isArray(obj) && !isNaN(parseInt(keyPath)))
-                    // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                    obj.splice(keyPath, 1);
-                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                else
-                    delete obj[keyPath];
-                //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-            }
-            else
-                obj[keyPath] = value;
+        context.userId = response2.claims.sub;
+        context.email = response2.claims.email;
+        context.name = response2.claims.name;
+        context.claims = response2.claims;
+        if (response2.alerts && response2.alerts.length > 0) {
+            await interactWithUser(userInteraction, {
+                type: 'message-alert',
+                title: 'Authentication Alert',
+                fields: {},
+                alerts: response2.alerts,
+            });
         }
+        return context;
+    }
+    catch (error) {
+        await alertUser(userInteraction, 'Authentication Failed', {
+            type: 'error',
+            messageCode: 'GENERIC_ERROR',
+            message: `We're having a problem to authenticate rigth now.`,
+            messageParams: {}
+        }).catch(() => { });
+        throw error;
     }
 }
-const randomString$1 = typeof self === 'undefined' ? (bytes) => {
-    // Node
-    const buf = Buffer.alloc(bytes);
-    randomFillSync(buf);
-    return buf.toString("base64");
-} : (bytes) => {
-    // Web
-    const buf = new Uint8Array(bytes);
-    crypto.getRandomValues(buf);
-    return btoa(String.fromCharCode.apply(null, buf));
-};
-
-/** Verifies that given primary key is valid.
- * The reason we narrow validity for valid keys are twofold:
- *  1: Make sure to only support types that can be used as an object index in DBKeyMutationSet.
- *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
- *     used (gives comma-delimited list of included bytes).
- *  2: Avoid using plain numbers and Dates as keys when they are synced, as they are not globally unique.
- *  3: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
- *
- * @param id
- * @returns
- */
-function isValidSyncableID(id) {
-    if (typeof id === "string")
-        return true;
-    //if (validIDTypes[toStringTag(id)]) return true;
-    //if (Array.isArray(id)) return id.every((part) => isValidSyncableID(part));
-    if (Array.isArray(id) && id.some(key => isValidSyncableID(key)) && id.every(isValidSyncableIDPart))
-        return true;
-    return false;
-}
-/** Verifies that given key part is valid.
- *  1: Make sure that arrays of this types are stringified correclty and works with DBKeyMutationSet.
- *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
- *     used (gives comma-delimited list of included bytes).
- *  2: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
-*/
-function isValidSyncableIDPart(part) {
-    return typeof part === "string" || typeof part === "number" || Array.isArray(part) && part.every(isValidSyncableIDPart);
+function spkiToPEM(keydata) {
+    const keydataB64 = b64encode(keydata);
+    const keydataB64Pem = formatAsPem(keydataB64);
+    return keydataB64Pem;
 }
-function isValidAtID(id, idPrefix) {
-    return !idPrefix || (typeof id === "string" && id.startsWith(idPrefix));
+function formatAsPem(str) {
+    let finalString = '-----BEGIN PUBLIC KEY-----\n';
+    while (str.length > 0) {
+        finalString += str.substring(0, 64) + '\n';
+        str = str.substring(64);
+    }
+    finalString = finalString + '-----END PUBLIC KEY-----';
+    return finalString;
 }
 
-function applyOperation(target, table, op) {
-    const tbl = target[table] || (target[table] = {});
-    switch (op.type) {
-        case "insert":
-        // TODO: Don't treat insert and upsert the same?
-        case "upsert":
-            op.keys.forEach((key, idx) => {
-                tbl[key] = {
-                    type: "ups",
-                    val: op.values[idx],
-                };
-            });
-            break;
-        case "update":
-        case "modify": {
-            op.keys.forEach((key, idx) => {
-                const changeSpec = op.type === "update"
-                    ? op.changeSpecs[idx]
-                    : op.changeSpec;
-                const entry = tbl[key];
-                if (!entry) {
-                    tbl[key] = {
-                        type: "upd",
-                        mod: changeSpec,
-                    };
+const { toString: toStr } = {};
+function getToStringTag(val) {
+    return toStr.call(val).slice(8, -1);
+}
+function escapeDollarProps(value) {
+    const keys = Object.keys(value);
+    let dollarKeys = null;
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        if (keys[i][0] === "$") {
+            dollarKeys = dollarKeys || [];
+            dollarKeys.push(keys[i]);
+        }
+    }
+    if (!dollarKeys)
+        return value;
+    const clone = { ...value };
+    for (const k of dollarKeys) {
+        delete clone[k];
+        clone["$" + k] = value[k];
+    }
+    return clone;
+}
+const ObjectDef = {
+    replace: escapeDollarProps,
+};
+function TypesonSimplified(...typeDefsInputs) {
+    const typeDefs = typeDefsInputs.reduce((p, c) => ({ ...p, ...c }), typeDefsInputs.reduce((p, c) => ({ ...c, ...p }), {}));
+    const protoMap = new WeakMap();
+    return {
+        stringify(value, alternateChannel, space) {
+            const json = JSON.stringify(value, function (key) {
+                const realVal = this[key];
+                const typeDef = getTypeDef(realVal);
+                return typeDef
+                    ? typeDef.replace(realVal, alternateChannel, typeDefs)
+                    : realVal;
+            }, space);
+            return json;
+        },
+        parse(tson, alternateChannel) {
+            let parent = null;
+            let unescapeParentKeys = [];
+            return JSON.parse(tson, function (key, value) {
+                //
+                // Parent Part
+                //
+                const type = value === null || value === void 0 ? void 0 : value.$t;
+                if (type) {
+                    const typeDef = typeDefs[type];
+                    value = typeDef
+                        ? typeDef.revive(value, alternateChannel, typeDefs)
+                        : value;
                 }
-                else {
-                    switch (entry.type) {
-                        case "ups":
-                            // Adjust the existing upsert with additional updates
-                            for (const [propPath, value] of Object.entries(changeSpec)) {
-                                setByKeyPath(entry.val, propPath, value);
-                            }
-                            break;
-                        case "del":
-                            // No action.
-                            break;
-                        case "upd":
-                            // Adjust existing update with additional updates
-                            Object.assign(entry.mod, changeSpec); // May work for deep props as well - new keys is added later, right? Does the prop order persist along TSON and all? But it will not be 100% when combined with some server code (seach for "address.city": "Stockholm" comment)
-                            break;
+                if (value === parent) {
+                    // Do what the kid told us to
+                    if (unescapeParentKeys.length > 0) {
+                        // Unescape dollar props
+                        value = { ...value };
+                        for (const k of unescapeParentKeys) {
+                            value[k.substr(1)] = value[k];
+                            delete value[k];
+                        }
                     }
+                    unescapeParentKeys = [];
+                    return value;
                 }
+                //
+                // Child part
+                //
+                if (key[0] === "$" && key !== "$t") {
+                    parent = this;
+                    unescapeParentKeys.push(key);
+                }
+                return value;
             });
-            break;
+        },
+    };
+    function getTypeDef(realVal) {
+        const type = typeof realVal;
+        switch (typeof realVal) {
+            case "object":
+            case "function": {
+                // "object", "function", null
+                if (realVal === null)
+                    return null;
+                const proto = Object.getPrototypeOf(realVal);
+                if (!proto)
+                    return ObjectDef;
+                let typeDef = protoMap.get(proto);
+                if (typeDef !== undefined)
+                    return typeDef; // Null counts to! So the caching of Array.prototype also counts.
+                const toStringTag = getToStringTag(realVal);
+                const entry = Object.entries(typeDefs).find(([typeName, typeDef]) => { var _a, _b; return (_b = (_a = typeDef === null || typeDef === void 0 ? void 0 : typeDef.test) === null || _a === void 0 ? void 0 : _a.call(typeDef, realVal, toStringTag)) !== null && _b !== void 0 ? _b : typeName === toStringTag; });
+                typeDef = entry === null || entry === void 0 ? void 0 : entry[1];
+                if (!typeDef) {
+                    typeDef = Array.isArray(realVal)
+                        ? null
+                        : typeof realVal === "function"
+                            ? typeDefs.function || null
+                            : ObjectDef;
+                }
+                protoMap.set(proto, typeDef);
+                return typeDef;
+            }
+            default:
+                return typeDefs[type];
         }
-        case "delete":
-            op.keys.forEach((key) => {
-                tbl[key] = {
-                    type: "del",
-                };
-            });
-            break;
     }
-    return target;
 }
 
-function applyOperations(target, ops) {
-    for (const { table, muts } of ops) {
-        for (const mut of muts) {
-            applyOperation(target, table, mut);
-        }
-    }
-}
+const BisonBinaryTypes = {
+    Blob: {
+        test: (blob, toStringTag) => toStringTag === "Blob",
+        replace: (blob, altChannel) => {
+            const i = altChannel.length;
+            altChannel.push(blob);
+            return {
+                $t: "Blob",
+                mimeType: blob.type,
+                i,
+            };
+        },
+        revive: ({ i, mimeType }, altChannel) => new Blob([altChannel[i]], { type: mimeType }),
+    },
+};
 
-function subtractChanges(target, // Server change set
-changesToSubtract // additional mutations on client during syncWithServer()
-) {
-    var _a, _b, _c;
-    for (const [table, mutationSet] of Object.entries(changesToSubtract)) {
-        for (const [key, mut] of Object.entries(mutationSet)) {
-            switch (mut.type) {
-                case 'ups':
-                    {
-                        const targetMut = (_a = target[table]) === null || _a === void 0 ? void 0 : _a[key];
-                        if (targetMut) {
-                            switch (targetMut.type) {
-                                case 'ups':
-                                    delete target[table][key];
-                                    break;
-                                case 'del':
-                                    // Leave delete operation.
-                                    // (Don't resurrect objects unintenionally (using tx(get, put) pattern locally))
-                                    break;
-                                case 'upd':
-                                    delete target[table][key];
-                                    break;
-                            }
-                        }
-                    }
-                    break;
-                case 'del':
-                    (_b = target[table]) === null || _b === void 0 ? true : delete _b[key];
-                    break;
-                case 'upd': {
-                    const targetMut = (_c = target[table]) === null || _c === void 0 ? void 0 : _c[key];
-                    if (targetMut) {
-                        switch (targetMut.type) {
-                            case 'ups':
-                                // Adjust the server upsert with locally updated values.
-                                for (const [propPath, value] of Object.entries(mut.mod)) {
-                                    setByKeyPath(targetMut.val, propPath, value);
-                                }
-                                break;
-                            case 'del':
-                                // Leave delete.
-                                break;
-                            case 'upd':
-                                // Remove the local update props from the server update mutation.
-                                for (const propPath of Object.keys(mut.mod)) {
-                                    delete targetMut.mod[propPath];
-                                }
-                                break;
-                        }
-                    }
-                    break;
-                }
+var numberDef = {
+    number: {
+        replace: (num) => {
+            switch (true) {
+                case isNaN(num):
+                    return { $t: "number", v: "NaN" };
+                case num === Infinity:
+                    return { $t: "number", v: "Infinity" };
+                case num === -Infinity:
+                    return { $t: "number", v: "-Infinity" };
+                default:
+                    return num;
             }
-        }
+        },
+        revive: ({ v }) => Number(v),
+    },
+};
+
+const bigIntDef = {
+    bigint: {
+        replace: (realVal) => {
+            return { $t: "bigint", v: "" + realVal };
+        },
+        revive: (obj) => BigInt(obj.v),
+    },
+};
+
+var DateDef = {
+    Date: {
+        replace: (date) => ({
+            $t: "Date",
+            v: isNaN(date.getTime()) ? "NaN" : date.toISOString(),
+        }),
+        revive: ({ v }) => new Date(v === "NaN" ? NaN : Date.parse(v)),
+    },
+};
+
+var SetDef = {
+    Set: {
+        replace: (set) => ({
+            $t: "Set",
+            v: Array.from(set.entries()),
+        }),
+        revive: ({ v }) => new Set(v),
+    },
+};
+
+var MapDef = {
+    Map: {
+        replace: (map) => ({
+            $t: "Map",
+            v: Array.from(map.entries()),
+        }),
+        revive: ({ v }) => new Map(v),
+    },
+};
+
+const _global = typeof globalThis !== "undefined"
+    ? globalThis
+    : typeof self !== "undefined"
+        ? self
+        : typeof global === "undefined"
+            ? global
+            : undefined;
+
+var TypedArraysDefs = [
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "DataView",
+    "BigInt64Array",
+    "BigUint64Array",
+].reduce((specs, typeName) => ({
+    ...specs,
+    [typeName]: {
+        // Replace passes the the typed array into $t, buffer so that
+        // the ArrayBuffer typedef takes care of further handling of the buffer:
+        // {$t:"Uint8Array",buffer:{$t:"ArrayBuffer",idx:0}}
+        // CHANGED ABOVE! Now shortcutting that for more sparse format of the typed arrays
+        // to contain the b64 property directly.
+        replace: (a, _, typeDefs) => {
+            const result = {
+                $t: typeName,
+                v: typeDefs.ArrayBuffer.replace(a.byteOffset === 0 && a.byteLength === a.buffer.byteLength
+                    ? a.buffer
+                    : a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength), _, typeDefs).v,
+            };
+            return result;
+        },
+        revive: ({ v }, _, typeDefs) => {
+            const TypedArray = _global[typeName];
+            return (TypedArray &&
+                new TypedArray(typeDefs.ArrayBuffer.revive({ v }, _, typeDefs)));
+        },
+    },
+}), {});
+
+function b64LexEncode(b) {
+    return b64ToLex(b64encode(b));
+}
+function b64LexDecode(b64Lex) {
+    return b64decode(lexToB64(b64Lex));
+}
+function b64ToLex(base64) {
+    var encoded = "";
+    for (var i = 0, length = base64.length; i < length; i++) {
+        encoded += ENCODE_TABLE[base64[i]];
     }
+    return encoded;
+}
+function lexToB64(base64lex) {
+    // only accept string input
+    if (typeof base64lex !== "string") {
+        throw new Error("invalid decoder input: " + base64lex);
+    }
+    var base64 = "";
+    for (var i = 0, length = base64lex.length; i < length; i++) {
+        base64 += DECODE_TABLE[base64lex[i]];
+    }
+    return base64;
+}
+const DECODE_TABLE = {
+    "-": "=",
+    "0": "A",
+    "1": "B",
+    "2": "C",
+    "3": "D",
+    "4": "E",
+    "5": "F",
+    "6": "G",
+    "7": "H",
+    "8": "I",
+    "9": "J",
+    A: "K",
+    B: "L",
+    C: "M",
+    D: "N",
+    E: "O",
+    F: "P",
+    G: "Q",
+    H: "R",
+    I: "S",
+    J: "T",
+    K: "U",
+    L: "V",
+    M: "W",
+    N: "X",
+    O: "Y",
+    P: "Z",
+    Q: "a",
+    R: "b",
+    S: "c",
+    T: "d",
+    U: "e",
+    V: "f",
+    W: "g",
+    X: "h",
+    Y: "i",
+    Z: "j",
+    _: "k",
+    a: "l",
+    b: "m",
+    c: "n",
+    d: "o",
+    e: "p",
+    f: "q",
+    g: "r",
+    h: "s",
+    i: "t",
+    j: "u",
+    k: "v",
+    l: "w",
+    m: "x",
+    n: "y",
+    o: "z",
+    p: "0",
+    q: "1",
+    r: "2",
+    s: "3",
+    t: "4",
+    u: "5",
+    v: "6",
+    w: "7",
+    x: "8",
+    y: "9",
+    z: "+",
+    "|": "/",
+};
+const ENCODE_TABLE = {};
+for (const c of Object.keys(DECODE_TABLE)) {
+    ENCODE_TABLE[DECODE_TABLE[c]] = c;
 }
 
-/** Convert a DBKeyMutationSet (which is an internal format capable of looking up changes per ID)
- * ...into a DBOperationsSet (which is more optimal for performing DB operations into DB (bulkAdd() etc))
- *
- * @param inSet
- * @returns DBOperationsSet representing inSet
- */
-function toDBOperationSet(inSet) {
-    // Fictive transaction:
-    const txid = randomString$1(16);
-    // Convert data into a temporary map to collect mutations of same table and type
-    const map = {};
-    for (const [table, ops] of Object.entries(inSet)) {
-        for (const [key, op] of Object.entries(ops)) {
-            const mapEntry = map[table] || (map[table] = {});
-            const ops = mapEntry[op.type] || (mapEntry[op.type] = []);
-            ops.push(Object.assign({ key }, op)); // DBKeyMutation doesn't contain key, so we need to bring it in.
-        }
-    }
-    // Start computing the resulting format:
-    const result = [];
-    for (const [table, ops] of Object.entries(map)) {
-        const resultEntry = {
-            table,
-            muts: [],
-        };
-        for (const [optype, muts] of Object.entries(ops)) {
-            switch (optype) {
-                case "ups": {
-                    const op = {
-                        type: "upsert",
-                        keys: muts.map(mut => mut.key),
-                        values: muts.map(mut => mut.val),
-                        txid
-                    };
-                    resultEntry.muts.push(op);
-                    break;
-                }
-                case "upd": {
-                    const op = {
-                        type: "update",
-                        keys: muts.map(mut => mut.key),
-                        changeSpecs: muts.map(mut => mut.mod),
-                        txid
-                    };
-                    resultEntry.muts.push(op);
-                    break;
-                }
-                case "del": {
-                    const op = {
-                        type: "delete",
-                        keys: muts.map(mut => mut.key),
-                        txid,
-                    };
-                    resultEntry.muts.push(op);
-                    break;
-                }
-            }
-        }
-        result.push(resultEntry);
+var ArrayBufferDef = {
+    ArrayBuffer: {
+        replace: (ab) => ({
+            $t: "ArrayBuffer",
+            v: b64LexEncode(ab),
+        }),
+        revive: ({ v }) => {
+            const ba = b64LexDecode(v);
+            return ba.buffer.byteLength === ba.byteLength
+                ? ba.buffer
+                : ba.buffer.slice(ba.byteOffset, ba.byteOffset + ba.byteLength);
+        },
+    },
+};
+
+class FakeBlob {
+    constructor(buf, type) {
+        this.buf = buf;
+        this.type = type;
     }
-    return result;
 }
 
-function getDbNameFromDbUrl(dbUrl) {
-    const url = new URL(dbUrl);
-    return url.pathname === "/"
-        ? url.hostname.split('.')[0]
-        : url.pathname.split('/')[1];
+function readBlobSync(b) {
+    const req = new XMLHttpRequest();
+    req.overrideMimeType("text/plain; charset=x-user-defined");
+    req.open("GET", URL.createObjectURL(b), false); // Sync
+    req.send();
+    if (req.status !== 200 && req.status !== 0) {
+        throw new Error("Bad Blob access: " + req.status);
+    }
+    return req.responseText;
 }
 
-async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
-    if (currentUser.isLoggedIn) {
-        if (tablesToSyncify.length > 0) {
-            const ignoredRealms = new Set(alreadySyncedRealms || []);
-            const inserts = await Promise.all(tablesToSyncify.map(async (table) => {
-                const { extractKey } = table.core.schema.primaryKey;
-                if (!extractKey)
-                    return { table: table.name, muts: [] }; // Outbound tables are not synced.
-                const dexieCloudTableSchema = schema[table.name];
-                const query = (dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
-                    ? table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidSyncableID(extractKey(item)))
-                    : table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix));
-                const unsyncedObjects = await query.toArray();
-                if (unsyncedObjects.length > 0) {
-                    const mut = {
-                        type: "insert",
-                        values: unsyncedObjects,
-                        keys: unsyncedObjects.map(extractKey),
-                        userId: currentUser.userId,
-                    };
-                    return {
-                        table: table.name,
-                        muts: [mut],
-                    };
-                }
-                else {
-                    return {
-                        table: table.name,
-                        muts: []
-                    };
-                }
-            }));
-            return inserts.filter(op => op.muts.length > 0);
-        }
+function string2ArrayBuffer(str) {
+    const array = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; ++i) {
+        array[i] = str.charCodeAt(i); // & 0xff;
     }
-    return [];
+    return array.buffer;
 }
 
-function getTablesToSyncify(db, syncState) {
-    const syncedTables = (syncState === null || syncState === void 0 ? void 0 : syncState.syncedTables) || [];
-    const syncableTables = getSyncableTables(db);
-    const tablesToSyncify = syncableTables.filter((tbl) => !syncedTables.includes(tbl.name));
-    return tablesToSyncify;
-}
+var BlobDef = {
+    Blob: {
+        test: (blob, toStringTag) => toStringTag === "Blob" || blob instanceof FakeBlob,
+        replace: (blob) => ({
+            $t: "Blob",
+            v: blob instanceof FakeBlob
+                ? b64encode(blob.buf)
+                : b64encode(string2ArrayBuffer(readBlobSync(blob))),
+            type: blob.type,
+        }),
+        revive: ({ type, v }) => {
+            const ab = b64decode(v);
+            return typeof Blob !== undefined
+                ? new Blob([ab])
+                : new FakeBlob(ab.buffer, type);
+        },
+    },
+};
 
-function interactWithUser(userInteraction, req) {
-    return new Promise((resolve, reject) => {
-        const interactionProps = {
-            ...req,
-            onSubmit: (res) => {
-                userInteraction.next(undefined);
-                resolve(res);
-            },
-            onCancel: () => {
-                userInteraction.next(undefined);
-                reject(new Dexie.AbortError("User cancelled"));
-            },
-        };
-        userInteraction.next(interactionProps);
-        // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
-        /*const subscription = userInteraction.subscribe((currentInteractionProps) => {
-          if (currentInteractionProps !== interactionProps) {
-            if (subscription) subscription.unsubscribe();
-            if (!done) {
-              reject(new Dexie.AbortError("User cancelled"));
-            }
-          }
-        });*/
-    });
-}
-function alertUser(userInteraction, title, ...alerts) {
-    return interactWithUser(userInteraction, {
-        type: 'message-alert',
-        title,
-        alerts,
-        fields: {}
-    });
-}
-async function promptForEmail(userInteraction, title, emailHint) {
-    let email = emailHint || '';
-    while (!email || !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,10}$/.test(email)) {
-        email = (await interactWithUser(userInteraction, {
-            type: 'email',
-            title,
-            alerts: email
-                ? [
-                    {
-                        type: 'error',
-                        messageCode: 'INVALID_EMAIL',
-                        message: 'Please enter a valid email address',
-                        messageParams: {},
-                    },
-                ]
-                : [],
-            fields: {
-                email: {
-                    type: 'email',
-                    placeholder: 'you@somedomain.com',
-                },
-            },
-        })).email;
-    }
-    return email;
-}
-async function promptForOTP(userInteraction, email, alert) {
-    const alerts = [
-        {
-            type: 'info',
-            messageCode: 'OTP_SENT',
-            message: `A One-Time password has been sent to {email}`,
-            messageParams: { email },
+const builtin = {
+    ...numberDef,
+    ...bigIntDef,
+    ...DateDef,
+    ...SetDef,
+    ...MapDef,
+    ...TypedArraysDefs,
+    ...ArrayBufferDef,
+    ...BlobDef,
+};
+
+function Bison(...typeDefsInputs) {
+    const tson = TypesonSimplified(builtin, BisonBinaryTypes, ...typeDefsInputs);
+    return {
+        toBinary(value) {
+            const [blob, json] = this.stringify(value);
+            const lenBuf = new ArrayBuffer(4);
+            new DataView(lenBuf).setUint32(0, blob.size);
+            return new Blob([lenBuf, blob, json]);
+        },
+        stringify(value) {
+            const binaries = [];
+            const json = tson.stringify(value, binaries);
+            const blob = new Blob(binaries.map((b) => {
+                const lenBuf = new ArrayBuffer(4);
+                new DataView(lenBuf).setUint32(0, "byteLength" in b ? b.byteLength : b.size);
+                return new Blob([lenBuf, b]);
+            }));
+            return [blob, json];
         },
-    ];
-    if (alert) {
-        alerts.push(alert);
-    }
-    const { otp } = await interactWithUser(userInteraction, {
-        type: 'otp',
-        title: 'Enter OTP',
-        alerts,
-        fields: {
-            otp: {
-                type: 'otp',
-                label: 'OTP',
-                placeholder: 'Paste OTP here',
-            },
+        async parse(json, binData) {
+            let pos = 0;
+            const arrayBuffers = [];
+            const buf = await readBlobBinary(binData);
+            const view = new DataView(buf);
+            while (pos < buf.byteLength) {
+                const len = view.getUint32(pos);
+                pos += 4;
+                const ab = buf.slice(pos, pos + len);
+                pos += len;
+                arrayBuffers.push(ab);
+            }
+            return tson.parse(json, arrayBuffers);
         },
-    });
-    return otp;
+        async fromBinary(blob) {
+            const len = new DataView(await readBlobBinary(blob.slice(0, 4))).getUint32(0);
+            const binData = blob.slice(4, len + 4);
+            const json = await readBlob(blob.slice(len + 4));
+            return await this.parse(json, binData);
+        },
+    };
 }
-
-async function loadAccessToken(db) {
-    var _a, _b;
-    const currentUser = await db.getCurrentUser();
-    const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
-    if (!accessToken)
-        return;
-    const expTime = (_a = accessTokenExpiration === null || accessTokenExpiration === void 0 ? void 0 : accessTokenExpiration.getTime()) !== null && _a !== void 0 ? _a : Infinity;
-    if (expTime > Date.now()) {
-        return accessToken;
-    }
-    if (!refreshToken) {
-        throw new Error(`Refresh token missing`);
-    }
-    const refreshExpTime = (_b = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _b !== void 0 ? _b : Infinity;
-    if (refreshExpTime <= Date.now()) {
-        throw new Error(`Refresh token has expired`);
-    }
-    const refreshedLogin = await refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
-    await db.table('$logins').update(claims.sub, {
-        accessToken: refreshedLogin.accessToken,
-        accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+function readBlob(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onabort = (ev) => reject(new Error("file read aborted"));
+        reader.onerror = (ev) => reject(ev.target.error);
+        reader.onload = (ev) => resolve(ev.target.result);
+        reader.readAsText(blob);
     });
-    return refreshedLogin.accessToken;
-}
-async function authenticate(url, context, fetchToken, userInteraction, hints) {
-    if (context.accessToken &&
-        context.accessTokenExpiration.getTime() > Date.now()) {
-        return context;
-    }
-    else if (context.refreshToken &&
-        (!context.refreshTokenExpiration ||
-            context.refreshTokenExpiration.getTime() > Date.now())) {
-        return await refreshAccessToken(url, context);
-    }
-    else {
-        return await userAuthenticate(context, fetchToken, userInteraction, hints);
-    }
 }
-async function refreshAccessToken(url, login) {
-    if (!login.refreshToken)
-        throw new Error(`Cannot refresh token - refresh token is missing.`);
-    if (!login.nonExportablePrivateKey)
-        throw new Error(`login.nonExportablePrivateKey is missing - cannot sign refresh token without a private key.`);
-    const time_stamp = Date.now();
-    const signing_algorithm = 'RSASSA-PKCS1-v1_5';
-    const textEncoder = new TextEncoder();
-    const data = textEncoder.encode(login.refreshToken + time_stamp);
-    const binarySignature = await crypto.subtle.sign(signing_algorithm, login.nonExportablePrivateKey, data);
-    const signature = b64encode(binarySignature);
-    const tokenRequest = {
-        grant_type: 'refresh_token',
-        refresh_token: login.refreshToken,
-        scopes: ['ACCESS_DB'],
-        signature,
-        signing_algorithm,
-        time_stamp,
-    };
-    const res = await fetch(`${url}/token`, {
-        body: JSON.stringify(tokenRequest),
-        method: 'post',
-        headers: { 'Content-Type': 'application/json' },
-        mode: 'cors',
+function readBlobBinary(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onabort = (ev) => reject(new Error("file read aborted"));
+        reader.onerror = (ev) => reject(ev.target.error);
+        reader.onload = (ev) => resolve(ev.target.result);
+        reader.readAsArrayBuffer(blob);
     });
-    if (res.status !== 200)
-        throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
-    const response = await res.json();
-    login.accessToken = response.accessToken;
-    login.accessTokenExpiration = response.accessTokenExpiration
-        ? new Date(response.accessTokenExpiration)
-        : undefined;
-    return login;
 }
-async function userAuthenticate(context, fetchToken, userInteraction, hints) {
-    const { privateKey, publicKey } = await crypto.subtle.generateKey({
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-        hash: { name: 'SHA-256' },
-    }, false, // Non-exportable...
-    ['sign', 'verify']);
-    context.nonExportablePrivateKey = privateKey; //...but storable!
-    const publicKeySPKI = await crypto.subtle.exportKey('spki', publicKey);
-    const publicKeyPEM = spkiToPEM(publicKeySPKI);
-    context.publicKey = publicKey;
-    try {
-        const response2 = await fetchToken({
-            public_key: publicKeyPEM,
-            hints,
-        });
-        if (response2.type !== 'tokens')
-            throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
-        context.accessToken = response2.accessToken;
-        context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
-        context.refreshToken = response2.refreshToken;
-        if (response2.refreshTokenExpiration) {
-            context.refreshTokenExpiration = new Date(response2.refreshTokenExpiration);
-        }
-        context.userId = response2.claims.sub;
-        context.email = response2.claims.email;
-        context.name = response2.claims.name;
-        context.claims = response2.claims;
-        if (response2.alerts && response2.alerts.length > 0) {
-            await interactWithUser(userInteraction, {
-                type: 'message-alert',
-                title: 'Authentication Alert',
-                fields: {},
-                alerts: response2.alerts,
-            });
-        }
-        return context;
-    }
-    catch (error) {
-        await alertUser(userInteraction, 'Authentication Failed', {
-            type: 'error',
-            messageCode: 'GENERIC_ERROR',
-            message: `We're having a problem to authenticate rigth now.`,
-            messageParams: {}
-        }).catch(() => { });
-        throw error;
+
+/** The undefined type is not part of builtin but can be manually added.
+ * The reason for supporting undefined is if the following object should be revived correctly:
+ *
+ *    {foo: undefined}
+ *
+ * Without including this typedef, the revived object would just be {}.
+ * If including this typedef, the revived object would be {foo: undefined}.
+ */
+var undefinedDef = {
+    undefined: {
+        replace: () => {
+        },
+        revive: () => undefined,
+    },
+};
+
+// Since server revisions are stored in bigints, we need to handle clients without
+// bigint support to not fail when serverRevision is passed over to client.
+// We need to not fail when reviving it and we need to somehow store the information.
+// Since the revived version will later on be put into indexedDB we have another
+// issue: When reading it back from indexedDB we will get a poco object that we
+// cannot replace correctly when sending it to server. So we will also need
+// to do an explicit workaround in the protocol where a bigint is supported.
+// The workaround should be there regardless if browser supports BigInt or not, because
+// the serverRev might have been stored in IDB before the browser was upgraded to support bigint.
+//
+// if (typeof serverRev.rev !== "bigint")
+//   if (hasBigIntSupport)
+//     serverRev.rev = bigIntDef.bigint.revive(server.rev)
+//   else
+//     serverRev.rev = new FakeBigInt(server.rev)
+const hasBigIntSupport = typeof BigInt(0) === 'bigint';
+class FakeBigInt {
+    constructor(value) {
+        this.v = value;
     }
-}
-function spkiToPEM(keydata) {
-    const keydataB64 = b64encode(keydata);
-    const keydataB64Pem = formatAsPem(keydataB64);
-    return keydataB64Pem;
-}
-function formatAsPem(str) {
-    let finalString = '-----BEGIN PUBLIC KEY-----\n';
-    while (str.length > 0) {
-        finalString += str.substring(0, 64) + '\n';
-        str = str.substring(64);
+    toString() {
+        return this.v;
     }
-    finalString = finalString + '-----END PUBLIC KEY-----';
-    return finalString;
 }
+const defs = {
+    ...undefinedDef,
+    ...(hasBigIntSupport
+        ? {}
+        : {
+            bigint: {
+                test: (val) => val instanceof FakeBigInt,
+                replace: (fakeBigInt) => {
+                    return {
+                        $t: 'bigint',
+                        ...fakeBigInt
+                    };
+                },
+                revive: ({ v, }) => new FakeBigInt(v)
+            }
+        })
+};
+const TSON = TypesonSimplified(builtin, defs);
+const BISON = Bison(defs);
 
 class HttpError extends Error {
     constructor(res, message) {
@@ -3373,6 +3357,7 @@ async function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, sch
         headers.Authorization = `Bearer ${accessToken}`;
     }
     const syncRequest = {
+        v: 2,
         dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
         clientIdentity,
         schema: schema || {},
@@ -3499,8 +3484,8 @@ async function updateBaseRevs(db, schema, latestRevisions, serverRev) {
 
 function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
     for (const { table, muts } of clientChangeSet) {
-        const lastRev = muts.length > 0 ? muts[muts.length - 1].rev || 0 : 0;
-        lastRevisions[table] = lastRev;
+        const lastRev = muts.length > 0 ? muts[muts.length - 1].rev : null;
+        lastRevisions[table] = lastRev || lastRevisions[table] || 0;
     }
     return lastRevisions;
 }
@@ -3821,16 +3806,35 @@ function MessagesFromServerConsumer(db) {
     const readyToServe = new BehaviorSubject(true);
     const event = new BehaviorSubject(null);
     let isWorking = false;
+    let loopWarning = 0;
+    let loopDetection = [0, 0, 0, 0, 0, 0, 0, 0, 0, Date.now()];
     event.subscribe(async () => {
         if (isWorking)
             return;
         if (queue.length > 0) {
             isWorking = true;
+            loopDetection.shift();
+            loopDetection.push(Date.now());
             readyToServe.next(false);
             try {
                 await consumeQueue();
             }
             finally {
+                if (loopDetection[loopDetection.length - 1] - loopDetection[0] < 10000) {
+                    // Ten loops within 10 seconds. Slow down!
+                    if (Date.now() - loopWarning < 5000) {
+                        // Last time we did this, we ended up here too. Wait for a minute.
+                        console.warn(`Slowing down websocket loop for one minute`);
+                        loopWarning = Date.now() + 60000;
+                        await new Promise(resolve => setTimeout(resolve, 60000));
+                    }
+                    else {
+                        // This is a one-time event. Just pause 10 seconds.
+                        console.warn(`Slowing down websocket loop for 10 seconds`);
+                        loopWarning = Date.now() + 10000;
+                        await new Promise(resolve => setTimeout(resolve, 10000));
+                    }
+                }
                 isWorking = false;
                 readyToServe.next(true);
             }
@@ -3846,6 +3850,9 @@ function MessagesFromServerConsumer(db) {
             const msg = queue.shift();
             try {
                 console.debug('processing msg', msg);
+                // If the sync worker or service worker is syncing, wait 'til thei're done.
+                // It's no need to have two channels at the same time - even though it wouldnt
+                // be a problem - this is an optimization.
                 await db.cloud.syncState
                     .pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
                     .toPromise();
@@ -3869,26 +3876,23 @@ function MessagesFromServerConsumer(db) {
                         // in turn will lead to that connectWebSocket.ts will reconnect the socket with the
                         // new token. So we don't need to do anything more here.
                         break;
-                    case 'rev':
-                        if (!(persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.serverRevision) ||
-                            compareBigInts(persistedSyncState.serverRevision, msg.rev) < 0) {
-                            triggerSync(db, "pull");
-                        }
-                        break;
                     case 'realm-added':
                         if (!((_a = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _a === void 0 ? void 0 : _a.includes(msg.realm))) {
-                            triggerSync(db, "pull");
+                            triggerSync(db, 'pull');
                         }
                         break;
                     case 'realm-removed':
                         if ((_b = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _b === void 0 ? void 0 : _b.includes(msg.realm)) {
-                            triggerSync(db, "pull");
+                            triggerSync(db, 'pull');
                         }
                         break;
+                    case 'realms-changed':
+                        triggerSync(db, 'pull');
+                        break;
                     case 'changes':
                         console.debug('changes');
                         if (((_c = db.cloud.syncState.value) === null || _c === void 0 ? void 0 : _c.phase) === 'error') {
-                            triggerSync(db, "pull");
+                            triggerSync(db, 'pull');
                             break;
                         }
                         await db.transaction('rw', db.dx.tables, async (tx) => {
@@ -3911,16 +3915,34 @@ function MessagesFromServerConsumer(db) {
                                 return; // Initial sync must have taken place - otherwise, ignore this.
                             }
                             // Verify again in ACID tx that we're on same server revision.
-                            if (compareBigInts(msg.baseRev, syncState.serverRevision) !== 0) {
+                            if (msg.baseRev !== syncState.serverRevision) {
                                 console.debug(`baseRev (${msg.baseRev}) differs from our serverRevision in syncState (${syncState.serverRevision})`);
+                                // Should we trigger a sync now? No. This is a normal case
+                                // when another local peer (such as the SW or a websocket channel on other tab) has
+                                // updated syncState from new server information but we are not aware yet. It would
+                                // be unnescessary to do a sync in that case. Instead, the caller of this consumeQueue()
+                                // function will do readyToServe.next(true) right after this return, which will lead
+                                // to a "ready" message being sent to server with the new accurate serverRev we have,
+                                // so that the next message indeed will be correct.
+                                if (typeof msg.baseRev === 'string' && // v2 format
+                                    (typeof syncState.serverRevision === 'bigint' || // v1 format
+                                        typeof syncState.serverRevision === 'object') // v1 format old browser
+                                ) {
+                                    // The reason for the diff seems to be that server has migrated the revision format.
+                                    // Do a full sync to update revision format.
+                                    // If we don't do a sync request now, we could stuck in an endless loop.
+                                    triggerSync(db, 'pull');
+                                }
                                 return; // Ignore message
                             }
                             // Verify also that the message is based on the exact same set of realms
-                            const ourRealmSetHash = await Dexie.waitFor(computeRealmSetHash(syncState));
+                            const ourRealmSetHash = await Dexie.waitFor(
+                            // Keep TX in non-IDB work
+                            computeRealmSetHash(syncState));
                             console.debug('ourRealmSetHash', ourRealmSetHash);
                             if (ourRealmSetHash !== msg.realmSetHash) {
                                 console.debug('not same realmSetHash', msg.realmSetHash);
-                                triggerSync(db, "pull");
+                                triggerSync(db, 'pull');
                                 // The message isn't based on the same realms.
                                 // Trigger a sync instead to resolve all things up.
                                 return;
@@ -3932,12 +3954,14 @@ function MessagesFromServerConsumer(db) {
                                 clientChanges = await listClientChanges(mutationTables, db);
                                 console.debug('msg queue: client changes', clientChanges);
                             }
-                            const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
-                            //
-                            // apply server changes
-                            //
-                            console.debug('applying filtered server changes', filteredChanges);
-                            await applyServerChanges(filteredChanges, db);
+                            if (msg.changes.length > 0) {
+                                const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
+                                //
+                                // apply server changes
+                                //
+                                console.debug('applying filtered server changes', filteredChanges);
+                                await applyServerChanges(filteredChanges, db);
+                            }
                             // Update latest revisions per table in case there are unsynced changes
                             // This can be a real case in future when we allow non-eagery sync.
                             // And it can actually be realistic now also, but very rare.
@@ -5018,18 +5042,19 @@ const SERVER_PING_TIMEOUT = 20000;
 const CLIENT_PING_INTERVAL = 30000;
 const FAIL_RETRY_WAIT_TIME = 60000;
 class WSObservable extends Observable$1 {
-    constructor(databaseUrl, rev, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
-        super((subscriber) => new WSConnection(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
+    constructor(databaseUrl, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
+        super((subscriber) => new WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
     }
 }
 let counter = 0;
 class WSConnection extends Subscription$1 {
-    constructor(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
+    constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
         super(() => this.teardown());
         this.id = ++counter;
         console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
         this.databaseUrl = databaseUrl;
         this.rev = rev;
+        this.realmSetHash = realmSetHash;
         this.clientIdentity = clientIdentity;
         this.token = token;
         this.tokenExpiration = tokenExpiration;
@@ -5134,7 +5159,9 @@ class WSConnection extends Subscription$1 {
         const searchParams = new URLSearchParams();
         if (this.subscriber.closed)
             return;
+        searchParams.set('v', "2");
         searchParams.set('rev', this.rev);
+        searchParams.set('realmsHash', this.realmSetHash);
         searchParams.set('clientId', this.clientIdentity);
         if (this.token) {
             searchParams.set('token', this.token);
@@ -5228,12 +5255,12 @@ function connectWebSocket(db) {
     function createObservable() {
         return db.cloud.persistedSyncState.pipe(filter(syncState => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
         take(1), // Don't continue waking up whenever syncState change
-        switchMap(() => db.cloud.currentUser), switchMap((userLogin) => userIsReallyActive.pipe(map((isActive) => (isActive ? userLogin : null)))), switchMap((userLogin) => 
+        switchMap((syncState) => db.cloud.currentUser.pipe(map(userLogin => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(async ([userLogin, syncState]) => [userLogin, await computeRealmSetHash(syncState)]), switchMap(([userLogin, realmSetHash]) => 
         // Let server end query changes from last entry of same client-ID and forward.
         // If no new entries, server won't bother the client. If new entries, server sends only those
         // and the baseRev of the last from same client-ID.
         userLogin
-            ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
+            ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
             : from$1([])), catchError((error) => {
             if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
                 console.debug('WebSocket observable: Token expired. Refreshing token...');
@@ -5353,22 +5380,26 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
     //let periodicSyncHandler: ((event: Event) => void) | null = null;
     let cancelToken = { cancelled: false };
     function syncAndRetry(purpose, retryNum = 1) {
-        syncIfPossible(db, cloudOptions, cloudSchema, {
-            cancelToken,
-            retryImmediatelyOnFetchError: true,
-            purpose
-        }).catch((e) => {
-            console.error('error in syncIfPossible()', e);
-            if (cancelToken.cancelled) {
-                stop();
-            }
-            else if (retryNum < 3) {
-                // Mimic service worker sync event: retry 3 times
-                // * first retry after 5 minutes
-                // * second retry 15 minutes later
-                setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
-            }
-        });
+        // Use setTimeout() to get onto a clean stack and
+        // break free from possible active transaction:
+        setTimeout(() => {
+            syncIfPossible(db, cloudOptions, cloudSchema, {
+                cancelToken,
+                retryImmediatelyOnFetchError: true,
+                purpose,
+            }).catch((e) => {
+                console.error('error in syncIfPossible()', e);
+                if (cancelToken.cancelled) {
+                    stop();
+                }
+                else if (retryNum < 3) {
+                    // Mimic service worker sync event: retry 3 times
+                    // * first retry after 5 minutes
+                    // * second retry 15 minutes later
+                    setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                }
+            });
+        }, 0);
     }
     const start = () => {
         // Sync eagerly whenever a change has happened (+ initially when there's no syncState yet)
@@ -5376,7 +5407,7 @@ function LocalSyncWorker(db, cloudOptions, cloudSchema) {
         console.debug('Starting LocalSyncWorker', db.localSyncEvent['id']);
         localSyncEventSubscription = db.localSyncEvent.subscribe(({ purpose }) => {
             try {
-                syncAndRetry(purpose || "pull");
+                syncAndRetry(purpose || 'pull');
             }
             catch (err) {
                 console.error('What-the....', err);
@@ -5954,6 +5985,7 @@ function syncDB(dbName, purpose) {
                 // Avoid race conditions.
                 managedDBs.delete(db.name);
             }
+            console.debug(`Dexie Cloud SW: Closing Dexie instance for ${dbName}`);
             db.dx.close();
             return false;
         }
@@ -6000,7 +6032,7 @@ if (!DISABLE_SERVICEWORKER_STRATEGY) {
             // Mimic background sync behavior - retry in X minutes on failure.
             // But lesser timeout and more number of times.
             const syncAndRetry = (num = 1) => {
-                return syncDB(dbName, event.data.purpuse || "pull").catch(async (e) => {
+                return syncDB(dbName, event.data.purpose || "pull").catch(async (e) => {
                     if (num === 3)
                         throw e;
                     await sleep(60000); // 1 minute