/*
 * Dexie.js - a minimalistic wrapper for IndexedDB
 * ===============================================
 *
 * By David Fahlander, david.fahlander@gmail.com
 *
 * Version 4.4.2, Tue Mar 31 2026
 *
 * https://dexie.org
 *
 * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
 */
 
const _global = typeof globalThis !== 'undefined'
    ? globalThis
    : typeof self !== 'undefined'
        ? self
        : typeof window !== 'undefined'
            ? window
            : global;

const keys = Object.keys;
const isArray = Array.isArray;
if (typeof Promise !== 'undefined' && !_global.Promise) {
    _global.Promise = Promise;
}
function extend(obj, extension) {
    if (typeof extension !== 'object')
        return obj;
    keys(extension).forEach(function (key) {
        obj[key] = extension[key];
    });
    return obj;
}
const getProto = Object.getPrototypeOf;
const _hasOwn = {}.hasOwnProperty;
function hasOwn(obj, prop) {
    return _hasOwn.call(obj, prop);
}
function props(proto, extension) {
    if (typeof extension === 'function')
        extension = extension(getProto(proto));
    (typeof Reflect === 'undefined' ? keys : Reflect.ownKeys)(extension).forEach((key) => {
        setProp(proto, key, extension[key]);
    });
}
const defineProperty = Object.defineProperty;
function setProp(obj, prop, functionOrGetSet, options) {
    defineProperty(obj, prop, extend(functionOrGetSet &&
        hasOwn(functionOrGetSet, 'get') &&
        typeof functionOrGetSet.get === 'function'
        ? {
            get: functionOrGetSet.get,
            set: functionOrGetSet.set,
            configurable: true,
        }
        : { value: functionOrGetSet, configurable: true, writable: true }, options));
}
function derive(Child) {
    return {
        from: function (Parent) {
            Child.prototype = Object.create(Parent.prototype);
            setProp(Child.prototype, 'constructor', Child);
            return {
                extend: props.bind(null, Child.prototype),
            };
        },
    };
}
const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
function getPropertyDescriptor(obj, prop) {
    const pd = getOwnPropertyDescriptor(obj, prop);
    let proto;
    return pd || ((proto = getProto(obj)) && getPropertyDescriptor(proto, prop));
}
const _slice = [].slice;
function slice(args, start, end) {
    return _slice.call(args, start, end);
}
function override(origFunc, overridedFactory) {
    return overridedFactory(origFunc);
}
function assert(b) {
    if (!b)
        throw new Error('Assertion Failed');
}
function asap$1(fn) {
    if (_global.setImmediate)
        setImmediate(fn);
    else
        setTimeout(fn, 0);
}
function arrayToObject(array, extractor) {
    return array.reduce((result, item, i) => {
        var nameAndValue = extractor(item, i);
        if (nameAndValue)
            result[nameAndValue[0]] = nameAndValue[1];
        return result;
    }, {});
}
function getByKeyPath(obj, keyPath) {
    if (typeof keyPath === 'string' && hasOwn(obj, keyPath))
        return obj[keyPath];
    if (!keyPath)
        return obj;
    if (typeof keyPath !== 'string') {
        var rv = [];
        for (var i = 0, l = keyPath.length; i < l; ++i) {
            var val = getByKeyPath(obj, keyPath[i]);
            rv.push(val);
        }
        return rv;
    }
    var period = keyPath.indexOf('.');
    if (period !== -1) {
        var innerObj = obj[keyPath.substr(0, period)];
        return innerObj == null
            ? undefined
            : getByKeyPath(innerObj, keyPath.substr(period + 1));
    }
    return undefined;
}
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]);
        }
    }
    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 (isArray(obj) && !isNaN(parseInt(currentKeyPath)))
                        obj.splice(currentKeyPath, 1);
                    else
                        delete obj[currentKeyPath];
                }
                else
                    obj[currentKeyPath] = value;
            else {
                var innerObj = obj[currentKeyPath];
                if (!innerObj || !hasOwn(obj, currentKeyPath))
                    innerObj = obj[currentKeyPath] = {};
                setByKeyPath(innerObj, remainingKeyPath, value);
            }
        }
        else {
            if (value === undefined) {
                if (isArray(obj) && !isNaN(parseInt(keyPath)))
                    obj.splice(keyPath, 1);
                else
                    delete obj[keyPath];
            }
            else
                obj[keyPath] = value;
        }
    }
}
function delByKeyPath(obj, keyPath) {
    if (typeof keyPath === 'string')
        setByKeyPath(obj, keyPath, undefined);
    else if ('length' in keyPath)
        [].map.call(keyPath, function (kp) {
            setByKeyPath(obj, kp, undefined);
        });
}
function shallowClone(obj) {
    var rv = {};
    for (var m in obj) {
        if (hasOwn(obj, m))
            rv[m] = obj[m];
    }
    return rv;
}
const concat = [].concat;
function flatten(a) {
    return concat.apply([], a);
}
const intrinsicTypeNames = 'BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey'
    .split(',')
    .concat(flatten([8, 16, 32, 64].map((num) => ['Int', 'Uint', 'Float'].map((t) => t + num + 'Array'))))
    .filter((t) => _global[t]);
const intrinsicTypes = new Set(intrinsicTypeNames.map((t) => _global[t]));
function cloneSimpleObjectTree(o) {
    const rv = {};
    for (const k in o)
        if (hasOwn(o, k)) {
            const v = o[k];
            rv[k] =
                !v || typeof v !== 'object' || intrinsicTypes.has(v.constructor)
                    ? v
                    : cloneSimpleObjectTree(v);
        }
    return rv;
}
let circularRefs = null;
function deepClone(any) {
    circularRefs = new WeakMap();
    const rv = innerDeepClone(any);
    circularRefs = null;
    return rv;
}
function innerDeepClone(x) {
    if (!x || typeof x !== 'object')
        return x;
    let rv = circularRefs.get(x);
    if (rv)
        return rv;
    if (isArray(x)) {
        rv = [];
        circularRefs.set(x, rv);
        for (var i = 0, l = x.length; i < l; ++i) {
            rv.push(innerDeepClone(x[i]));
        }
    }
    else if (intrinsicTypes.has(x.constructor)) {
        rv = x;
    }
    else {
        const proto = getProto(x);
        rv = proto === Object.prototype ? {} : Object.create(proto);
        circularRefs.set(x, rv);
        for (var prop in x) {
            if (hasOwn(x, prop)) {
                rv[prop] = innerDeepClone(x[prop]);
            }
        }
    }
    return rv;
}
const { toString } = {};
function toStringTag(o) {
    return toString.call(o).slice(8, -1);
}
const iteratorSymbol = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
const getIteratorOf = typeof iteratorSymbol === 'symbol'
    ? function (x) {
        var i;
        return x != null && (i = x[iteratorSymbol]) && i.apply(x);
    }
    : function () {
        return null;
    };
function delArrayItem(a, x) {
    const i = a.indexOf(x);
    if (i >= 0)
        a.splice(i, 1);
    return i >= 0;
}
const NO_CHAR_ARRAY = {};
function getArrayOf(arrayLike) {
    var i, a, x, it;
    if (arguments.length === 1) {
        if (isArray(arrayLike))
            return arrayLike.slice();
        if (this === NO_CHAR_ARRAY && typeof arrayLike === 'string')
            return [arrayLike];
        if ((it = getIteratorOf(arrayLike))) {
            a = [];
            while (((x = it.next()), !x.done))
                a.push(x.value);
            return a;
        }
        if (arrayLike == null)
            return [arrayLike];
        i = arrayLike.length;
        if (typeof i === 'number') {
            a = new Array(i);
            while (i--)
                a[i] = arrayLike[i];
            return a;
        }
        return [arrayLike];
    }
    i = arguments.length;
    a = new Array(i);
    while (i--)
        a[i] = arguments[i];
    return a;
}
const isAsyncFunction = typeof Symbol !== 'undefined'
    ? (fn) => fn[Symbol.toStringTag] === 'AsyncFunction'
    : () => false;

var dexieErrorNames = [
    'Modify',
    'Bulk',
    'OpenFailed',
    'VersionChange',
    'Schema',
    'Upgrade',
    'InvalidTable',
    'MissingAPI',
    'NoSuchDatabase',
    'InvalidArgument',
    'SubTransaction',
    'Unsupported',
    'Internal',
    'DatabaseClosed',
    'PrematureCommit',
    'ForeignAwait',
];
var idbDomErrorNames = [
    'Unknown',
    'Constraint',
    'Data',
    'TransactionInactive',
    'ReadOnly',
    'Version',
    'NotFound',
    'InvalidState',
    'InvalidAccess',
    'Abort',
    'Timeout',
    'QuotaExceeded',
    'Syntax',
    'DataClone',
];
var errorList = dexieErrorNames.concat(idbDomErrorNames);
var defaultTexts = {
    VersionChanged: 'Database version changed by other database connection',
    DatabaseClosed: 'Database has been closed',
    Abort: 'Transaction aborted',
    TransactionInactive: 'Transaction has already completed or failed',
    MissingAPI: 'IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb',
};
function DexieError(name, msg) {
    this.name = name;
    this.message = msg;
}
derive(DexieError)
    .from(Error)
    .extend({
    toString: function () {
        return this.name + ': ' + this.message;
    },
});
function getMultiErrorMessage(msg, failures) {
    return (msg +
        '. Errors: ' +
        Object.keys(failures)
            .map((key) => failures[key].toString())
            .filter((v, i, s) => s.indexOf(v) === i)
            .join('\n'));
}
function ModifyError(msg, failures, successCount, failedKeys) {
    this.failures = failures;
    this.failedKeys = failedKeys;
    this.successCount = successCount;
    this.message = getMultiErrorMessage(msg, failures);
}
derive(ModifyError).from(DexieError);
function BulkError(msg, failures) {
    this.name = 'BulkError';
    this.failures = Object.keys(failures).map((pos) => failures[pos]);
    this.failuresByPos = failures;
    this.message = getMultiErrorMessage(msg, this.failures);
}
derive(BulkError).from(DexieError);
var errnames = errorList.reduce((obj, name) => ((obj[name] = name + 'Error'), obj), {});
const BaseException = DexieError;
var exceptions = errorList.reduce((obj, name) => {
    var fullName = name + 'Error';
    function DexieError(msgOrInner, inner) {
        this.name = fullName;
        if (!msgOrInner) {
            this.message = defaultTexts[name] || fullName;
            this.inner = null;
        }
        else if (typeof msgOrInner === 'string') {
            this.message = `${msgOrInner}${!inner ? '' : '\n ' + inner}`;
            this.inner = inner || null;
        }
        else if (typeof msgOrInner === 'object') {
            this.message = `${msgOrInner.name} ${msgOrInner.message}`;
            this.inner = msgOrInner;
        }
    }
    derive(DexieError).from(BaseException);
    obj[name] = DexieError;
    return obj;
}, {});
exceptions.Syntax = SyntaxError;
exceptions.Type = TypeError;
exceptions.Range = RangeError;
var exceptionMap = idbDomErrorNames.reduce((obj, name) => {
    obj[name + 'Error'] = exceptions[name];
    return obj;
}, {});
function mapError(domError, message) {
    if (!domError ||
        domError instanceof DexieError ||
        domError instanceof TypeError ||
        domError instanceof SyntaxError ||
        !domError.name ||
        !exceptionMap[domError.name])
        return domError;
    var rv = new exceptionMap[domError.name](message || domError.message, domError);
    if ('stack' in domError) {
        setProp(rv, 'stack', {
            get: function () {
                return this.inner.stack;
            },
        });
    }
    return rv;
}
var fullNameExceptions = errorList.reduce((obj, name) => {
    if (['Syntax', 'Type', 'Range'].indexOf(name) === -1)
        obj[name + 'Error'] = exceptions[name];
    return obj;
}, {});
fullNameExceptions.ModifyError = ModifyError;
fullNameExceptions.DexieError = DexieError;
fullNameExceptions.BulkError = BulkError;

function nop() { }
function mirror(val) {
    return val;
}
function pureFunctionChain(f1, f2) {
    if (f1 == null || f1 === mirror)
        return f2;
    return function (val) {
        return f2(f1(val));
    };
}
function callBoth(on1, on2) {
    return function () {
        on1.apply(this, arguments);
        on2.apply(this, arguments);
    };
}
function hookCreatingChain(f1, f2) {
    if (f1 === nop)
        return f2;
    return function () {
        var res = f1.apply(this, arguments);
        if (res !== undefined)
            arguments[0] = res;
        var onsuccess = this.onsuccess,
        onerror = this.onerror;
        this.onsuccess = null;
        this.onerror = null;
        var res2 = f2.apply(this, arguments);
        if (onsuccess)
            this.onsuccess = this.onsuccess
                ? callBoth(onsuccess, this.onsuccess)
                : onsuccess;
        if (onerror)
            this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
        return res2 !== undefined ? res2 : res;
    };
}
function hookDeletingChain(f1, f2) {
    if (f1 === nop)
        return f2;
    return function () {
        f1.apply(this, arguments);
        var onsuccess = this.onsuccess,
        onerror = this.onerror;
        this.onsuccess = this.onerror = null;
        f2.apply(this, arguments);
        if (onsuccess)
            this.onsuccess = this.onsuccess
                ? callBoth(onsuccess, this.onsuccess)
                : onsuccess;
        if (onerror)
            this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
    };
}
function hookUpdatingChain(f1, f2) {
    if (f1 === nop)
        return f2;
    return function (modifications) {
        var res = f1.apply(this, arguments);
        extend(modifications, res);
        var onsuccess = this.onsuccess,
        onerror = this.onerror;
        this.onsuccess = null;
        this.onerror = null;
        var res2 = f2.apply(this, arguments);
        if (onsuccess)
            this.onsuccess = this.onsuccess
                ? callBoth(onsuccess, this.onsuccess)
                : onsuccess;
        if (onerror)
            this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
        return res === undefined
            ? res2 === undefined
                ? undefined
                : res2
            : extend(res, res2);
    };
}
function reverseStoppableEventChain(f1, f2) {
    if (f1 === nop)
        return f2;
    return function () {
        if (f2.apply(this, arguments) === false)
            return false;
        return f1.apply(this, arguments);
    };
}
function promisableChain(f1, f2) {
    if (f1 === nop)
        return f2;
    return function () {
        var res = f1.apply(this, arguments);
        if (res && typeof res.then === 'function') {
            var thiz = this, i = arguments.length, args = new Array(i);
            while (i--)
                args[i] = arguments[i];
            return res.then(function () {
                return f2.apply(thiz, args);
            });
        }
        return f2.apply(this, arguments);
    };
}

var debug = typeof location !== 'undefined' &&
    /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
function setDebug(value, filter) {
    debug = value;
}

var INTERNAL = {};
const ZONE_ECHO_LIMIT = 100, [resolvedNativePromise, nativePromiseProto, resolvedGlobalPromise] = typeof Promise === 'undefined'
    ? []
    : (() => {
        let globalP = Promise.resolve();
        if (typeof crypto === 'undefined' || !crypto.subtle)
            return [globalP, getProto(globalP), globalP];
        const nativeP = crypto.subtle.digest('SHA-512', new Uint8Array([0]));
        return [nativeP, getProto(nativeP), globalP];
    })(), nativePromiseThen = nativePromiseProto && nativePromiseProto.then;
const NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
const patchGlobalPromise = !!resolvedGlobalPromise;
function schedulePhysicalTick() {
    queueMicrotask(physicalTick);
}
var asap = function (callback, args) {
    microtickQueue.push([callback, args]);
    if (needsNewPhysicalTick) {
        schedulePhysicalTick();
        needsNewPhysicalTick = false;
    }
};
var isOutsideMicroTick = true,
needsNewPhysicalTick = true,
unhandledErrors = [],
rejectingErrors = [],
rejectionMapper = mirror;
var globalPSD = {
    id: 'global',
    global: true,
    ref: 0,
    unhandleds: [],
    onunhandled: nop,
    pgp: false,
    env: {},
    finalize: nop,
};
var PSD = globalPSD;
var microtickQueue = [];
var numScheduledCalls = 0;
var tickFinalizers = [];
function DexiePromise(fn) {
    if (typeof this !== 'object')
        throw new TypeError('Promises must be constructed via new');
    this._listeners = [];
    this._lib = false;
    var psd = (this._PSD = PSD);
    if (typeof fn !== 'function') {
        if (fn !== INTERNAL)
            throw new TypeError('Not a function');
        this._state = arguments[1];
        this._value = arguments[2];
        if (this._state === false)
            handleRejection(this, this._value);
        return;
    }
    this._state = null;
    this._value = null;
    ++psd.ref;
    executePromiseTask(this, fn);
}
const thenProp = {
    get: function () {
        var psd = PSD, microTaskId = totalEchoes;
        function then(onFulfilled, onRejected) {
            var possibleAwait = !psd.global && (psd !== PSD || microTaskId !== totalEchoes);
            const cleanup = possibleAwait && !decrementExpectedAwaits();
            var rv = new DexiePromise((resolve, reject) => {
                propagateToListener(this, new Listener(nativeAwaitCompatibleWrap(onFulfilled, psd, possibleAwait, cleanup), nativeAwaitCompatibleWrap(onRejected, psd, possibleAwait, cleanup), resolve, reject, psd));
            });
            if (this._consoleTask)
                rv._consoleTask = this._consoleTask;
            return rv;
        }
        then.prototype = INTERNAL;
        return then;
    },
    set: function (value) {
        setProp(this, 'then', value && value.prototype === INTERNAL
            ? thenProp
            : {
                get: function () {
                    return value;
                },
                set: thenProp.set,
            });
    },
};
props(DexiePromise.prototype, {
    then: thenProp,
    _then: function (onFulfilled, onRejected) {
        propagateToListener(this, new Listener(null, null, onFulfilled, onRejected, PSD));
    },
    catch: function (onRejected) {
        if (arguments.length === 1)
            return this.then(null, onRejected);
        var type = arguments[0], handler = arguments[1];
        return typeof type === 'function'
            ? this.then(null, (err) =>
            err instanceof type ? handler(err) : PromiseReject(err))
            : this.then(null, (err) =>
            err && err.name === type ? handler(err) : PromiseReject(err));
    },
    finally: function (onFinally) {
        return this.then((value) => {
            return DexiePromise.resolve(onFinally()).then(() => value);
        }, (err) => {
            return DexiePromise.resolve(onFinally()).then(() => PromiseReject(err));
        });
    },
    timeout: function (ms, msg) {
        return ms < Infinity
            ? new DexiePromise((resolve, reject) => {
                var handle = setTimeout(() => reject(new exceptions.Timeout(msg)), ms);
                this.then(resolve, reject).finally(clearTimeout.bind(null, handle));
            })
            : this;
    },
});
if (typeof Symbol !== 'undefined' && Symbol.toStringTag)
    setProp(DexiePromise.prototype, Symbol.toStringTag, 'Dexie.Promise');
globalPSD.env = snapShot();
function Listener(onFulfilled, onRejected, resolve, reject, zone) {
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
    this.resolve = resolve;
    this.reject = reject;
    this.psd = zone;
}
props(DexiePromise, {
    all: function () {
        var values = getArrayOf
            .apply(null, arguments)
            .map(onPossibleParallellAsync);
        return new DexiePromise(function (resolve, reject) {
            if (values.length === 0)
                resolve([]);
            var remaining = values.length;
            values.forEach((a, i) => DexiePromise.resolve(a).then((x) => {
                values[i] = x;
                if (!--remaining)
                    resolve(values);
            }, reject));
        });
    },
    resolve: (value) => {
        if (value instanceof DexiePromise)
            return value;
        if (value && typeof value.then === 'function')
            return new DexiePromise((resolve, reject) => {
                value.then(resolve, reject);
            });
        var rv = new DexiePromise(INTERNAL, true, value);
        return rv;
    },
    reject: PromiseReject,
    race: function () {
        var values = getArrayOf
            .apply(null, arguments)
            .map(onPossibleParallellAsync);
        return new DexiePromise((resolve, reject) => {
            values.map((value) => DexiePromise.resolve(value).then(resolve, reject));
        });
    },
    PSD: {
        get: () => PSD,
        set: (value) => (PSD = value),
    },
    totalEchoes: { get: () => totalEchoes },
    newPSD: newScope,
    usePSD: usePSD,
    scheduler: {
        get: () => asap,
        set: (value) => {
            asap = value;
        },
    },
    rejectionMapper: {
        get: () => rejectionMapper,
        set: (value) => {
            rejectionMapper = value;
        },
    },
    follow: (fn, zoneProps) => {
        return new DexiePromise((resolve, reject) => {
            return newScope((resolve, reject) => {
                var psd = PSD;
                psd.unhandleds = [];
                psd.onunhandled = reject;
                psd.finalize = callBoth(function () {
                    run_at_end_of_this_or_next_physical_tick(() => {
                        this.unhandleds.length === 0
                            ? resolve()
                            : reject(this.unhandleds[0]);
                    });
                }, psd.finalize);
                fn();
            }, zoneProps, resolve, reject);
        });
    },
});
if (NativePromise) {
    if (NativePromise.allSettled)
        setProp(DexiePromise, 'allSettled', function () {
            const possiblePromises = getArrayOf
                .apply(null, arguments)
                .map(onPossibleParallellAsync);
            return new DexiePromise((resolve) => {
                if (possiblePromises.length === 0)
                    resolve([]);
                let remaining = possiblePromises.length;
                const results = new Array(remaining);
                possiblePromises.forEach((p, i) => DexiePromise.resolve(p)
                    .then((value) => (results[i] = { status: 'fulfilled', value }), (reason) => (results[i] = { status: 'rejected', reason }))
                    .then(() => --remaining || resolve(results)));
            });
        });
    if (NativePromise.any && typeof AggregateError !== 'undefined')
        setProp(DexiePromise, 'any', function () {
            const possiblePromises = getArrayOf
                .apply(null, arguments)
                .map(onPossibleParallellAsync);
            return new DexiePromise((resolve, reject) => {
                if (possiblePromises.length === 0)
                    reject(new AggregateError([]));
                let remaining = possiblePromises.length;
                const failures = new Array(remaining);
                possiblePromises.forEach((p, i) => DexiePromise.resolve(p).then((value) => resolve(value), (failure) => {
                    failures[i] = failure;
                    if (!--remaining)
                        reject(new AggregateError(failures));
                }));
            });
        });
    if (NativePromise.withResolvers)
        DexiePromise.withResolvers = NativePromise.withResolvers;
}
function executePromiseTask(promise, fn) {
    try {
        fn((value) => {
            if (promise._state !== null)
                return;
            if (value === promise)
                throw new TypeError('A promise cannot be resolved with itself.');
            var shouldExecuteTick = promise._lib && beginMicroTickScope();
            if (value && typeof value.then === 'function') {
                executePromiseTask(promise, (resolve, reject) => {
                    value instanceof DexiePromise
                        ? value._then(resolve, reject)
                        : value.then(resolve, reject);
                });
            }
            else {
                promise._state = true;
                promise._value = value;
                propagateAllListeners(promise);
            }
            if (shouldExecuteTick)
                endMicroTickScope();
        }, handleRejection.bind(null, promise));
    }
    catch (ex) {
        handleRejection(promise, ex);
    }
}
function handleRejection(promise, reason) {
    rejectingErrors.push(reason);
    if (promise._state !== null)
        return;
    var shouldExecuteTick = promise._lib && beginMicroTickScope();
    reason = rejectionMapper(reason);
    promise._state = false;
    promise._value = reason;
    addPossiblyUnhandledError(promise);
    propagateAllListeners(promise);
    if (shouldExecuteTick)
        endMicroTickScope();
}
function propagateAllListeners(promise) {
    var listeners = promise._listeners;
    promise._listeners = [];
    for (var i = 0, len = listeners.length; i < len; ++i) {
        propagateToListener(promise, listeners[i]);
    }
    var psd = promise._PSD;
    --psd.ref || psd.finalize();
    if (numScheduledCalls === 0) {
        ++numScheduledCalls;
        asap(() => {
            if (--numScheduledCalls === 0)
                finalizePhysicalTick();
        }, []);
    }
}
function propagateToListener(promise, listener) {
    if (promise._state === null) {
        promise._listeners.push(listener);
        return;
    }
    var cb = promise._state ? listener.onFulfilled : listener.onRejected;
    if (cb === null) {
        return (promise._state ? listener.resolve : listener.reject)(promise._value);
    }
    ++listener.psd.ref;
    ++numScheduledCalls;
    asap(callListener, [cb, promise, listener]);
}
function callListener(cb, promise, listener) {
    try {
        var ret, value = promise._value;
        if (!promise._state && rejectingErrors.length)
            rejectingErrors = [];
        ret =
            debug && promise._consoleTask
                ? promise._consoleTask.run(() => cb(value))
                : cb(value);
        if (!promise._state && rejectingErrors.indexOf(value) === -1) {
            markErrorAsHandled(promise);
        }
        listener.resolve(ret);
    }
    catch (e) {
        listener.reject(e);
    }
    finally {
        if (--numScheduledCalls === 0)
            finalizePhysicalTick();
        --listener.psd.ref || listener.psd.finalize();
    }
}
function physicalTick() {
    usePSD(globalPSD, () => {
        beginMicroTickScope() && endMicroTickScope();
    });
}
function beginMicroTickScope() {
    var wasRootExec = isOutsideMicroTick;
    isOutsideMicroTick = false;
    needsNewPhysicalTick = false;
    return wasRootExec;
}
function endMicroTickScope() {
    var callbacks, i, l;
    do {
        while (microtickQueue.length > 0) {
            callbacks = microtickQueue;
            microtickQueue = [];
            l = callbacks.length;
            for (i = 0; i < l; ++i) {
                var item = callbacks[i];
                item[0].apply(null, item[1]);
            }
        }
    } while (microtickQueue.length > 0);
    isOutsideMicroTick = true;
    needsNewPhysicalTick = true;
}
function finalizePhysicalTick() {
    var unhandledErrs = unhandledErrors;
    unhandledErrors = [];
    unhandledErrs.forEach((p) => {
        p._PSD.onunhandled.call(null, p._value, p);
    });
    var finalizers = tickFinalizers.slice(0);
    var i = finalizers.length;
    while (i)
        finalizers[--i]();
}
function run_at_end_of_this_or_next_physical_tick(fn) {
    function finalizer() {
        fn();
        tickFinalizers.splice(tickFinalizers.indexOf(finalizer), 1);
    }
    tickFinalizers.push(finalizer);
    ++numScheduledCalls;
    asap(() => {
        if (--numScheduledCalls === 0)
            finalizePhysicalTick();
    }, []);
}
function addPossiblyUnhandledError(promise) {
    if (!unhandledErrors.some((p) => p._value === promise._value))
        unhandledErrors.push(promise);
}
function markErrorAsHandled(promise) {
    var i = unhandledErrors.length;
    while (i)
        if (unhandledErrors[--i]._value === promise._value) {
            unhandledErrors.splice(i, 1);
            return;
        }
}
function PromiseReject(reason) {
    return new DexiePromise(INTERNAL, false, reason);
}
function wrap(fn, errorCatcher) {
    var psd = PSD;
    return function () {
        var wasRootExec = beginMicroTickScope(), outerScope = PSD;
        try {
            switchToZone(psd, true);
            return fn.apply(this, arguments);
        }
        catch (e) {
            errorCatcher && errorCatcher(e);
        }
        finally {
            switchToZone(outerScope, false);
            if (wasRootExec)
                endMicroTickScope();
        }
    };
}
const task = { awaits: 0, echoes: 0, id: 0 };
var taskCounter = 0;
var zoneStack = [];
var zoneEchoes = 0;
var totalEchoes = 0;
var zone_id_counter = 0;
function newScope(fn, props, a1, a2) {
    var parent = PSD, psd = Object.create(parent);
    psd.parent = parent;
    psd.ref = 0;
    psd.global = false;
    psd.id = ++zone_id_counter;
    globalPSD.env;
    psd.env = patchGlobalPromise
        ? {
            Promise: DexiePromise,
            PromiseProp: {
                value: DexiePromise,
                configurable: true,
                writable: true,
            },
            all: DexiePromise.all,
            race: DexiePromise.race,
            allSettled: DexiePromise.allSettled,
            any: DexiePromise.any,
            resolve: DexiePromise.resolve,
            reject: DexiePromise.reject,
        }
        : {};
    if (props)
        extend(psd, props);
    ++parent.ref;
    psd.finalize = function () {
        --this.parent.ref || this.parent.finalize();
    };
    var rv = usePSD(psd, fn, a1, a2);
    if (psd.ref === 0)
        psd.finalize();
    return rv;
}
function incrementExpectedAwaits() {
    if (!task.id)
        task.id = ++taskCounter;
    ++task.awaits;
    task.echoes += ZONE_ECHO_LIMIT;
    return task.id;
}
function decrementExpectedAwaits() {
    if (!task.awaits)
        return false;
    if (--task.awaits === 0)
        task.id = 0;
    task.echoes = task.awaits * ZONE_ECHO_LIMIT;
    return true;
}
if (('' + nativePromiseThen).indexOf('[native code]') === -1) {
    incrementExpectedAwaits = decrementExpectedAwaits = nop;
}
function onPossibleParallellAsync(possiblePromise) {
    if (task.echoes &&
        possiblePromise &&
        possiblePromise.constructor === NativePromise) {
        incrementExpectedAwaits();
        return possiblePromise.then((x) => {
            decrementExpectedAwaits();
            return x;
        }, (e) => {
            decrementExpectedAwaits();
            return rejection(e);
        });
    }
    return possiblePromise;
}
function zoneEnterEcho(targetZone) {
    ++totalEchoes;
    if (!task.echoes || --task.echoes === 0) {
        task.echoes = task.awaits = task.id = 0;
    }
    zoneStack.push(PSD);
    switchToZone(targetZone, true);
}
function zoneLeaveEcho() {
    var zone = zoneStack[zoneStack.length - 1];
    zoneStack.pop();
    switchToZone(zone, false);
}
function switchToZone(targetZone, bEnteringZone) {
    var currentZone = PSD;
    if (bEnteringZone
        ? task.echoes && (!zoneEchoes++ || targetZone !== PSD)
        : zoneEchoes && (!--zoneEchoes || targetZone !== PSD)) {
        queueMicrotask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
    }
    if (targetZone === PSD)
        return;
    PSD = targetZone;
    if (currentZone === globalPSD)
        globalPSD.env = snapShot();
    if (patchGlobalPromise) {
        var GlobalPromise = globalPSD.env.Promise;
        var targetEnv = targetZone.env;
        if (currentZone.global || targetZone.global) {
            Object.defineProperty(_global, 'Promise', targetEnv.PromiseProp);
            GlobalPromise.all = targetEnv.all;
            GlobalPromise.race = targetEnv.race;
            GlobalPromise.resolve = targetEnv.resolve;
            GlobalPromise.reject = targetEnv.reject;
            if (targetEnv.allSettled)
                GlobalPromise.allSettled = targetEnv.allSettled;
            if (targetEnv.any)
                GlobalPromise.any = targetEnv.any;
        }
    }
}
function snapShot() {
    var GlobalPromise = _global.Promise;
    return patchGlobalPromise
        ? {
            Promise: GlobalPromise,
            PromiseProp: Object.getOwnPropertyDescriptor(_global, 'Promise'),
            all: GlobalPromise.all,
            race: GlobalPromise.race,
            allSettled: GlobalPromise.allSettled,
            any: GlobalPromise.any,
            resolve: GlobalPromise.resolve,
            reject: GlobalPromise.reject,
        }
        : {};
}
function usePSD(psd, fn, a1, a2, a3) {
    var outerScope = PSD;
    try {
        switchToZone(psd, true);
        return fn(a1, a2, a3);
    }
    finally {
        switchToZone(outerScope, false);
    }
}
function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) {
    return typeof fn !== 'function'
        ? fn
        : function () {
            var outerZone = PSD;
            if (possibleAwait)
                incrementExpectedAwaits();
            switchToZone(zone, true);
            try {
                return fn.apply(this, arguments);
            }
            finally {
                switchToZone(outerZone, false);
                if (cleanup)
                    queueMicrotask(decrementExpectedAwaits);
            }
        };
}
function execInGlobalContext(cb) {
    if (Promise === NativePromise && task.echoes === 0) {
        if (zoneEchoes === 0) {
            cb();
        }
        else {
            enqueueNativeMicroTask(cb);
        }
    }
    else {
        setTimeout(cb, 0);
    }
}
var rejection = DexiePromise.reject;

function tempTransaction(db, mode, storeNames, fn) {
    if (!db.idbdb || (!db._state.openComplete && !PSD.letThrough && !db._vip)) {
        if (db._state.openComplete) {
            return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));
        }
        if (!db._state.isBeingOpened) {
            if (!db._state.autoOpen)
                return rejection(new exceptions.DatabaseClosed());
            db.open().catch(nop);
        }
        return db._state.dbReadyPromise.then(() => tempTransaction(db, mode, storeNames, fn));
    }
    else {
        var trans = db._createTransaction(mode, storeNames, db._dbSchema);
        try {
            trans.create();
            db._state.PR1398_maxLoop = 3;
        }
        catch (ex) {
            if (ex.name === errnames.InvalidState &&
                db.isOpen() &&
                --db._state.PR1398_maxLoop > 0) {
                console.warn('Dexie: Need to reopen db');
                db.close({ disableAutoOpen: false });
                return db.open().then(() => tempTransaction(db, mode, storeNames, fn));
            }
            return rejection(ex);
        }
        return trans
            ._promise(mode, (resolve, reject) => {
            return newScope(() => {
                PSD.trans = trans;
                return fn(resolve, reject, trans);
            });
        })
            .then((result) => {
            if (mode === 'readwrite')
                try {
                    trans.idbtrans.commit();
                }
                catch { }
            return mode === 'readonly'
                ? result
                : trans._completion.then(() => result);
        });
    }
}

const DEXIE_VERSION = '4.4.2';
const maxString = String.fromCharCode(65535);
const minKey = -Infinity;
const INVALID_KEY_ARGUMENT = 'Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.';
const STRING_EXPECTED = 'String expected.';
const DEFAULT_MAX_CONNECTIONS = 1000;
const DBNAMES_DB = '__dbnames';
const READONLY = 'readonly';
const READWRITE = 'readwrite';

function combine(filter1, filter2) {
    return filter1
        ? filter2
            ? function () {
                return (filter1.apply(this, arguments) && filter2.apply(this, arguments));
            }
            : filter1
        : filter2;
}

const AnyRange = {
    type: 3 ,
    lower: -Infinity,
    lowerOpen: false,
    upper: [[]],
    upperOpen: false,
};

function workaroundForUndefinedPrimKey(keyPath) {
    return typeof keyPath === 'string' && !/\./.test(keyPath)
        ? (obj) => {
            if (obj[keyPath] === undefined && keyPath in obj) {
                obj = deepClone(obj);
                delete obj[keyPath];
            }
            return obj;
        }
        : (obj) => obj;
}

function Entity() {
    throw exceptions.Type(`Entity instances must never be new:ed. Instances are generated by the framework bypassing the constructor.`);
}

function cmp(a, b) {
    try {
        const ta = type(a);
        const tb = type(b);
        if (ta !== tb) {
            if (ta === 'Array')
                return 1;
            if (tb === 'Array')
                return -1;
            if (ta === 'binary')
                return 1;
            if (tb === 'binary')
                return -1;
            if (ta === 'string')
                return 1;
            if (tb === 'string')
                return -1;
            if (ta === 'Date')
                return 1;
            if (tb !== 'Date')
                return NaN;
            return -1;
        }
        switch (ta) {
            case 'number':
            case 'Date':
            case 'string':
                return a > b ? 1 : a < b ? -1 : 0;
            case 'binary': {
                return compareUint8Arrays(getUint8Array(a), getUint8Array(b));
            }
            case 'Array':
                return compareArrays(a, b);
        }
    }
    catch { }
    return NaN;
}
function compareArrays(a, b) {
    const al = a.length;
    const bl = b.length;
    const l = al < bl ? al : bl;
    for (let i = 0; i < l; ++i) {
        const res = cmp(a[i], b[i]);
        if (res !== 0)
            return res;
    }
    return al === bl ? 0 : al < bl ? -1 : 1;
}
function compareUint8Arrays(a, b) {
    const al = a.length;
    const bl = b.length;
    const l = al < bl ? al : bl;
    for (let i = 0; i < l; ++i) {
        if (a[i] !== b[i])
            return a[i] < b[i] ? -1 : 1;
    }
    return al === bl ? 0 : al < bl ? -1 : 1;
}
function type(x) {
    const t = typeof x;
    if (t !== 'object')
        return t;
    if (ArrayBuffer.isView(x))
        return 'binary';
    const tsTag = toStringTag(x);
    return tsTag === 'ArrayBuffer' ? 'binary' : tsTag;
}
function getUint8Array(a) {
    if (a instanceof Uint8Array)
        return a;
    if (ArrayBuffer.isView(a))
        return new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
    return new Uint8Array(a);
}

function builtInDeletionTrigger(table, keys, res) {
    const { yProps } = table.schema;
    if (!yProps)
        return res;
    if (keys && res.numFailures > 0)
        keys = keys.filter((_, i) => !res.failures[i]);
    return Promise.all(yProps.map(({ updatesTable }) => keys
        ? table.db.table(updatesTable).where('k').anyOf(keys).delete()
        : table.db.table(updatesTable).clear())).then(() => res);
}

class PropModification {
    execute(value) {
        const spec = this['@@propmod'];
        if (spec.add !== undefined) {
            const term = spec.add;
            if (isArray(term)) {
                return [...(isArray(value) ? value : []), ...term].sort();
            }
            if (typeof term === 'number')
                return (Number(value) || 0) + term;
            if (typeof term === 'bigint') {
                try {
                    return BigInt(value) + term;
                }
                catch {
                    return BigInt(0) + term;
                }
            }
            throw new TypeError(`Invalid term ${term}`);
        }
        if (spec.remove !== undefined) {
            const subtrahend = spec.remove;
            if (isArray(subtrahend)) {
                return isArray(value)
                    ? value.filter((item) => !subtrahend.includes(item)).sort()
                    : [];
            }
            if (typeof subtrahend === 'number')
                return Number(value) - subtrahend;
            if (typeof subtrahend === 'bigint') {
                try {
                    return BigInt(value) - subtrahend;
                }
                catch {
                    return BigInt(0) - subtrahend;
                }
            }
            throw new TypeError(`Invalid subtrahend ${subtrahend}`);
        }
        const prefixToReplace = spec.replacePrefix?.[0];
        if (prefixToReplace &&
            typeof value === 'string' &&
            value.startsWith(prefixToReplace)) {
            return spec.replacePrefix[1] + value.substring(prefixToReplace.length);
        }
        return value;
    }
    constructor(spec) {
        this['@@propmod'] = spec;
    }
}

function applyUpdateSpec(obj, changes) {
    const keyPaths = keys(changes);
    const numKeys = keyPaths.length;
    let anythingModified = false;
    for (let i = 0; i < numKeys; ++i) {
        const keyPath = keyPaths[i];
        const value = changes[keyPath];
        const origValue = getByKeyPath(obj, keyPath);
        if (value instanceof PropModification) {
            setByKeyPath(obj, keyPath, value.execute(origValue));
            anythingModified = true;
        }
        else if (origValue !== value) {
            setByKeyPath(obj, keyPath, value);
            anythingModified = true;
        }
    }
    return anythingModified;
}

class Table {
    _trans(mode, fn, writeLocked) {
        const trans = this._tx || PSD.trans;
        const tableName = this.name;
        const task = debug &&
            typeof console !== 'undefined' &&
            console.createTask &&
            console.createTask(`Dexie: ${mode === 'readonly' ? 'read' : 'write'} ${this.name}`);
        function checkTableInTransaction(resolve, reject, trans) {
            if (!trans.schema[tableName])
                throw new exceptions.NotFound('Table ' + tableName + ' not part of transaction');
            return fn(trans.idbtrans, trans);
        }
        const wasRootExec = beginMicroTickScope();
        try {
            let p = trans && trans.db._novip === this.db._novip
                ? trans === PSD.trans
                    ? trans._promise(mode, checkTableInTransaction, writeLocked)
                    : newScope(() => trans._promise(mode, checkTableInTransaction, writeLocked), { trans: trans, transless: PSD.transless || PSD })
                : tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
            if (task) {
                p._consoleTask = task;
                p = p.catch((err) => {
                    console.trace(err);
                    return rejection(err);
                });
            }
            return p;
        }
        finally {
            if (wasRootExec)
                endMicroTickScope();
        }
    }
    get(keyOrCrit, cb) {
        if (keyOrCrit && keyOrCrit.constructor === Object)
            return this.where(keyOrCrit).first(cb);
        if (keyOrCrit == null)
            return rejection(new exceptions.Type(`Invalid argument to Table.get()`));
        return this._trans('readonly', (trans) => {
            return this.core
                .get({ trans, key: keyOrCrit })
                .then((res) => this.hook.reading.fire(res));
        }).then(cb);
    }
    where(indexOrCrit) {
        if (typeof indexOrCrit === 'string')
            return new this.db.WhereClause(this, indexOrCrit);
        if (isArray(indexOrCrit))
            return new this.db.WhereClause(this, `[${indexOrCrit.join('+')}]`);
        const keyPaths = keys(indexOrCrit);
        if (keyPaths.length === 1)
            return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]);
        const compoundIndex = this.schema.indexes
            .concat(this.schema.primKey)
            .filter((ix) => {
            if (ix.compound &&
                keyPaths.every((keyPath) => ix.keyPath.indexOf(keyPath) >= 0)) {
                for (let i = 0; i < keyPaths.length; ++i) {
                    if (keyPaths.indexOf(ix.keyPath[i]) === -1)
                        return false;
                }
                return true;
            }
            return false;
        })
            .sort((a, b) => a.keyPath.length - b.keyPath.length)[0];
        if (compoundIndex && this.db._maxKey !== maxString) {
            const keyPathsInValidOrder = compoundIndex.keyPath.slice(0, keyPaths.length);
            return this.where(keyPathsInValidOrder).equals(keyPathsInValidOrder.map((kp) => indexOrCrit[kp]));
        }
        if (!compoundIndex && debug)
            console.warn(`The query ${JSON.stringify(indexOrCrit)} on ${this.name} would benefit from a ` +
                `compound index [${keyPaths.join('+')}]`);
        const { idxByName } = this.schema;
        function equals(a, b) {
            return cmp(a, b) === 0;
        }
        const [idx, filterFunction] = keyPaths.reduce(([prevIndex, prevFilterFn], keyPath) => {
            const index = idxByName[keyPath];
            const value = indexOrCrit[keyPath];
            return [
                prevIndex || index,
                prevIndex || !index
                    ? combine(prevFilterFn, index && index.multi
                        ? (x) => {
                            const prop = getByKeyPath(x, keyPath);
                            return (isArray(prop) &&
                                prop.some((item) => equals(value, item)));
                        }
                        : (x) => equals(value, getByKeyPath(x, keyPath)))
                    : prevFilterFn,
            ];
        }, [null, null]);
        return idx
            ? this.where(idx.name)
                .equals(indexOrCrit[idx.keyPath])
                .filter(filterFunction)
            : compoundIndex
                ? this.filter(filterFunction)
                : this.where(keyPaths).equals('');
    }
    filter(filterFunction) {
        return this.toCollection().and(filterFunction);
    }
    count(thenShortcut) {
        return this.toCollection().count(thenShortcut);
    }
    offset(offset) {
        return this.toCollection().offset(offset);
    }
    limit(numRows) {
        return this.toCollection().limit(numRows);
    }
    each(callback) {
        return this.toCollection().each(callback);
    }
    toArray(thenShortcut) {
        return this.toCollection().toArray(thenShortcut);
    }
    toCollection() {
        return new this.db.Collection(new this.db.WhereClause(this));
    }
    orderBy(index) {
        return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? `[${index.join('+')}]` : index));
    }
    reverse() {
        return this.toCollection().reverse();
    }
    mapToClass(constructor) {
        const { db, name: tableName } = this;
        this.schema.mappedClass = constructor;
        if (constructor.prototype instanceof Entity) {
            constructor = class extends constructor {
                get db() {
                    return db;
                }
                table() {
                    return tableName;
                }
            };
        }
        const inheritedProps = new Set();
        for (let proto = constructor.prototype; proto; proto = getProto(proto)) {
            Object.getOwnPropertyNames(proto).forEach((propName) => inheritedProps.add(propName));
        }
        const readHook = (obj) => {
            if (!obj)
                return obj;
            const res = Object.create(constructor.prototype);
            for (let m in obj)
                if (!inheritedProps.has(m))
                    try {
                        res[m] = obj[m];
                    }
                    catch (_) { }
            return res;
        };
        if (this.schema.readHook) {
            this.hook.reading.unsubscribe(this.schema.readHook);
        }
        this.schema.readHook = readHook;
        this.hook('reading', readHook);
        return constructor;
    }
    defineClass() {
        function Class(content) {
            extend(this, content);
        }
        return this.mapToClass(Class);
    }
    add(obj, key) {
        const { auto, keyPath } = this.schema.primKey;
        let objToAdd = obj;
        if (keyPath && auto) {
            objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
        }
        return this._trans('readwrite', (trans) => {
            return this.core.mutate({
                trans,
                type: 'add',
                keys: key != null ? [key] : null,
                values: [objToAdd],
            });
        })
            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
            .then((lastResult) => {
            if (keyPath) {
                try {
                    setByKeyPath(obj, keyPath, lastResult);
                }
                catch (_) { }
            }
            return lastResult;
        });
    }
    upsert(key, modifications) {
        const { keyPath } = this.schema.primKey;
        return this._trans('readwrite', (trans) => {
            return this.core.get({ trans, key }).then((existing) => {
                const obj = existing ?? {};
                applyUpdateSpec(obj, modifications);
                if (keyPath)
                    setByKeyPath(obj, keyPath, key);
                return this.core
                    .mutate({
                    trans,
                    type: 'put',
                    values: [obj],
                    keys: [key],
                    upsert: true,
                    updates: { keys: [key], changeSpecs: [modifications] },
                })
                    .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : !!existing);
            });
        });
    }
    update(keyOrObject, modifications) {
        if (typeof keyOrObject === 'object' && !isArray(keyOrObject)) {
            const key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
            if (key === undefined)
                return rejection(new exceptions.InvalidArgument('Given object does not contain its primary key'));
            return this.where(':id').equals(key).modify(modifications);
        }
        else {
            return this.where(':id').equals(keyOrObject).modify(modifications);
        }
    }
    put(obj, key) {
        const { auto, keyPath } = this.schema.primKey;
        let objToAdd = obj;
        if (keyPath && auto) {
            objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
        }
        return this._trans('readwrite', (trans) => this.core.mutate({
            trans,
            type: 'put',
            values: [objToAdd],
            keys: key != null ? [key] : null,
        }))
            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult)
            .then((lastResult) => {
            if (keyPath) {
                try {
                    setByKeyPath(obj, keyPath, lastResult);
                }
                catch (_) { }
            }
            return lastResult;
        });
    }
    delete(key) {
        return this._trans('readwrite', (trans) => this.core
            .mutate({ trans, type: 'delete', keys: [key] })
            .then((res) => builtInDeletionTrigger(this, [key], res))
            .then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined));
    }
    clear() {
        return this._trans('readwrite', (trans) => this.core
            .mutate({ trans, type: 'deleteRange', range: AnyRange })
            .then((res) => builtInDeletionTrigger(this, null, res))).then((res) => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined);
    }
    bulkGet(keys) {
        return this._trans('readonly', (trans) => {
            return this.core
                .getMany({
                keys,
                trans,
            })
                .then((result) => result.map((res) => this.hook.reading.fire(res)));
        });
    }
    bulkAdd(objects, keysOrOptions, options) {
        const keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
        options =
            options || (keys ? undefined : keysOrOptions);
        const wantResults = options ? options.allKeys : undefined;
        return this._trans('readwrite', (trans) => {
            const { auto, keyPath } = this.schema.primKey;
            if (keyPath && keys)
                throw new exceptions.InvalidArgument('bulkAdd(): keys argument invalid on tables with inbound keys');
            if (keys && keys.length !== objects.length)
                throw new exceptions.InvalidArgument('Arguments objects and keys must have the same length');
            const numObjects = objects.length;
            let objectsToAdd = keyPath && auto
                ? objects.map(workaroundForUndefinedPrimKey(keyPath))
                : objects;
            return this.core
                .mutate({
                trans,
                type: 'add',
                keys: keys,
                values: objectsToAdd,
                wantResults,
            })
                .then(({ numFailures, results, lastResult, failures }) => {
                const result = wantResults ? results : lastResult;
                if (numFailures === 0)
                    return result;
                throw new BulkError(`${this.name}.bulkAdd(): ${numFailures} of ${numObjects} operations failed`, failures);
            });
        });
    }
    bulkPut(objects, keysOrOptions, options) {
        const keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
        options =
            options || (keys ? undefined : keysOrOptions);
        const wantResults = options ? options.allKeys : undefined;
        return this._trans('readwrite', (trans) => {
            const { auto, keyPath } = this.schema.primKey;
            if (keyPath && keys)
                throw new exceptions.InvalidArgument('bulkPut(): keys argument invalid on tables with inbound keys');
            if (keys && keys.length !== objects.length)
                throw new exceptions.InvalidArgument('Arguments objects and keys must have the same length');
            const numObjects = objects.length;
            let objectsToPut = keyPath && auto
                ? objects.map(workaroundForUndefinedPrimKey(keyPath))
                : objects;
            return this.core
                .mutate({
                trans,
                type: 'put',
                keys: keys,
                values: objectsToPut,
                wantResults,
            })
                .then(({ numFailures, results, lastResult, failures }) => {
                const result = wantResults ? results : lastResult;
                if (numFailures === 0)
                    return result;
                throw new BulkError(`${this.name}.bulkPut(): ${numFailures} of ${numObjects} operations failed`, failures);
            });
        });
    }
    bulkUpdate(keysAndChanges) {
        const coreTable = this.core;
        const keys = keysAndChanges.map((entry) => entry.key);
        const changeSpecs = keysAndChanges.map((entry) => entry.changes);
        const offsetMap = [];
        return this._trans('readwrite', (trans) => {
            return coreTable.getMany({ trans, keys, cache: 'clone' }).then((objs) => {
                const resultKeys = [];
                const resultObjs = [];
                keysAndChanges.forEach(({ key, changes }, idx) => {
                    const obj = objs[idx];
                    if (obj) {
                        for (const keyPath of Object.keys(changes)) {
                            const value = changes[keyPath];
                            if (keyPath === this.schema.primKey.keyPath) {
                                if (cmp(value, key) !== 0) {
                                    throw new exceptions.Constraint(`Cannot update primary key in bulkUpdate()`);
                                }
                            }
                            else {
                                setByKeyPath(obj, keyPath, value);
                            }
                        }
                        offsetMap.push(idx);
                        resultKeys.push(key);
                        resultObjs.push(obj);
                    }
                });
                const numEntries = resultKeys.length;
                return coreTable
                    .mutate({
                    trans,
                    type: 'put',
                    keys: resultKeys,
                    values: resultObjs,
                    updates: {
                        keys,
                        changeSpecs,
                    },
                })
                    .then(({ numFailures, failures }) => {
                    if (numFailures === 0)
                        return numEntries;
                    for (const offset of Object.keys(failures)) {
                        const mappedOffset = offsetMap[Number(offset)];
                        if (mappedOffset != null) {
                            const failure = failures[offset];
                            delete failures[offset];
                            failures[mappedOffset] = failure;
                        }
                    }
                    throw new BulkError(`${this.name}.bulkUpdate(): ${numFailures} of ${numEntries} operations failed`, failures);
                });
            });
        });
    }
    bulkDelete(keys) {
        const numKeys = keys.length;
        return this._trans('readwrite', (trans) => {
            return this.core
                .mutate({ trans, type: 'delete', keys: keys })
                .then((res) => builtInDeletionTrigger(this, keys, res));
        }).then(({ numFailures, lastResult, failures }) => {
            if (numFailures === 0)
                return lastResult;
            throw new BulkError(`${this.name}.bulkDelete(): ${numFailures} of ${numKeys} operations failed`, failures);
        });
    }
}

function Events(ctx) {
    var evs = {};
    var rv = function (eventName, subscriber) {
        if (subscriber) {
            var i = arguments.length, args = new Array(i - 1);
            while (--i)
                args[i - 1] = arguments[i];
            evs[eventName].subscribe.apply(null, args);
            return ctx;
        }
        else if (typeof eventName === 'string') {
            return evs[eventName];
        }
    };
    rv.addEventType = add;
    for (var i = 1, l = arguments.length; i < l; ++i) {
        add(arguments[i]);
    }
    return rv;
    function add(eventName, chainFunction, defaultFunction) {
        if (typeof eventName === 'object')
            return addConfiguredEvents(eventName);
        if (!chainFunction)
            chainFunction = reverseStoppableEventChain;
        if (!defaultFunction)
            defaultFunction = nop;
        var context = {
            subscribers: [],
            fire: defaultFunction,
            subscribe: function (cb) {
                if (context.subscribers.indexOf(cb) === -1) {
                    context.subscribers.push(cb);
                    context.fire = chainFunction(context.fire, cb);
                }
            },
            unsubscribe: function (cb) {
                context.subscribers = context.subscribers.filter(function (fn) {
                    return fn !== cb;
                });
                context.fire = context.subscribers.reduce(chainFunction, defaultFunction);
            },
        };
        evs[eventName] = rv[eventName] = context;
        return context;
    }
    function addConfiguredEvents(cfg) {
        keys(cfg).forEach(function (eventName) {
            var args = cfg[eventName];
            if (isArray(args)) {
                add(eventName, cfg[eventName][0], cfg[eventName][1]);
            }
            else if (args === 'asap') {
                var context = add(eventName, mirror, function fire() {
                    var i = arguments.length, args = new Array(i);
                    while (i--)
                        args[i] = arguments[i];
                    context.subscribers.forEach(function (fn) {
                        asap$1(function fireEvent() {
                            fn.apply(null, args);
                        });
                    });
                });
            }
            else
                throw new exceptions.InvalidArgument('Invalid event config');
        });
    }
}

function makeClassConstructor(prototype, constructor) {
    derive(constructor).from({ prototype });
    return constructor;
}

function createTableConstructor(db) {
    return makeClassConstructor(Table.prototype, function Table(name, tableSchema, trans) {
        this.db = db;
        this._tx = trans;
        this.name = name;
        this.schema = tableSchema;
        this.hook = db._allTables[name]
            ? db._allTables[name].hook
            : Events(null, {
                creating: [hookCreatingChain, nop],
                reading: [pureFunctionChain, mirror],
                updating: [hookUpdatingChain, nop],
                deleting: [hookDeletingChain, nop],
            });
    });
}

function isPlainKeyRange(ctx, ignoreLimitFilter) {
    return (!(ctx.filter || ctx.algorithm || ctx.or) &&
        (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter));
}
function addFilter(ctx, fn) {
    ctx.filter = combine(ctx.filter, fn);
}
function addReplayFilter(ctx, factory, isLimitFilter) {
    var curr = ctx.replayFilter;
    ctx.replayFilter = curr ? () => combine(curr(), factory()) : factory;
    ctx.justLimit = isLimitFilter && !curr;
}
function addMatchFilter(ctx, fn) {
    ctx.isMatch = combine(ctx.isMatch, fn);
}
function getIndexOrStore(ctx, coreSchema) {
    if (ctx.isPrimKey)
        return coreSchema.primaryKey;
    const index = coreSchema.getIndexByKeyPath(ctx.index);
    if (!index)
        throw new exceptions.Schema('KeyPath ' +
            ctx.index +
            ' on object store ' +
            coreSchema.name +
            ' is not indexed');
    return index;
}
function openCursor(ctx, coreTable, trans) {
    const index = getIndexOrStore(ctx, coreTable.schema);
    return coreTable.openCursor({
        trans,
        values: !ctx.keysOnly,
        reverse: ctx.dir === 'prev',
        unique: !!ctx.unique,
        query: {
            index,
            range: ctx.range,
        },
    });
}
function iter(ctx, fn, coreTrans, coreTable) {
    const filter = ctx.replayFilter
        ? combine(ctx.filter, ctx.replayFilter())
        : ctx.filter;
    if (!ctx.or) {
        return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper);
    }
    else {
        const set = {};
        const union = (item, cursor, advance) => {
            if (!filter ||
                filter(cursor, advance, (result) => cursor.stop(result), (err) => cursor.fail(err))) {
                var primaryKey = cursor.primaryKey;
                var key = '' + primaryKey;
                if (key === '[object ArrayBuffer]')
                    key = '' + new Uint8Array(primaryKey);
                if (!hasOwn(set, key)) {
                    set[key] = true;
                    fn(item, cursor, advance);
                }
            }
        };
        return Promise.all([
            ctx.or._iterate(union, coreTrans),
            iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper),
        ]);
    }
}
function iterate(cursorPromise, filter, fn, valueMapper) {
    var mappedFn = valueMapper ? (x, c, a) => fn(valueMapper(x), c, a) : fn;
    var wrappedFn = wrap(mappedFn);
    return cursorPromise.then((cursor) => {
        if (cursor) {
            return cursor.start(() => {
                var c = () => cursor.continue();
                if (!filter ||
                    filter(cursor, (advancer) => (c = advancer), (val) => {
                        cursor.stop(val);
                        c = nop;
                    }, (e) => {
                        cursor.fail(e);
                        c = nop;
                    }))
                    wrappedFn(cursor.value, cursor, (advancer) => (c = advancer));
                c();
            });
        }
    });
}

class Collection {
    _read(fn, cb) {
        var ctx = this._ctx;
        return ctx.error
            ? ctx.table._trans(null, rejection.bind(null, ctx.error))
            : ctx.table._trans('readonly', fn).then(cb);
    }
    _write(fn) {
        var ctx = this._ctx;
        return ctx.error
            ? ctx.table._trans(null, rejection.bind(null, ctx.error))
            : ctx.table._trans('readwrite', fn, 'locked');
    }
    _addAlgorithm(fn) {
        var ctx = this._ctx;
        ctx.algorithm = combine(ctx.algorithm, fn);
    }
    _iterate(fn, coreTrans) {
        return iter(this._ctx, fn, coreTrans, this._ctx.table.core);
    }
    clone(props) {
        var rv = Object.create(this.constructor.prototype), ctx = Object.create(this._ctx);
        if (props)
            extend(ctx, props);
        rv._ctx = ctx;
        return rv;
    }
    raw() {
        this._ctx.valueMapper = null;
        return this;
    }
    each(fn) {
        var ctx = this._ctx;
        return this._read((trans) => iter(ctx, fn, trans, ctx.table.core));
    }
    count(cb) {
        return this._read((trans) => {
            const ctx = this._ctx;
            const coreTable = ctx.table.core;
            if (isPlainKeyRange(ctx, true)) {
                return coreTable
                    .count({
                    trans,
                    query: {
                        index: getIndexOrStore(ctx, coreTable.schema),
                        range: ctx.range,
                    },
                })
                    .then((count) => Math.min(count, ctx.limit));
            }
            else {
                var count = 0;
                return iter(ctx, () => {
                    ++count;
                    return false;
                }, trans, coreTable).then(() => count);
            }
        }).then(cb);
    }
    sortBy(keyPath, cb) {
        const parts = keyPath.split('.').reverse(), lastPart = parts[0], lastIndex = parts.length - 1;
        function getval(obj, i) {
            if (i)
                return getval(obj[parts[i]], i - 1);
            return obj[lastPart];
        }
        var order = this._ctx.dir === 'next' ? 1 : -1;
        function sorter(a, b) {
            var aVal = getval(a, lastIndex), bVal = getval(b, lastIndex);
            return cmp(aVal, bVal) * order;
        }
        return this.toArray(function (a) {
            return a.sort(sorter);
        }).then(cb);
    }
    toArray(cb) {
        return this._read((trans) => {
            var ctx = this._ctx;
            if (isPlainKeyRange(ctx, true) && ctx.limit > 0) {
                const { valueMapper } = ctx;
                const index = getIndexOrStore(ctx, ctx.table.core.schema);
                return ctx.table.core
                    .query({
                    trans,
                    limit: ctx.limit,
                    values: true,
                    direction: ctx.dir === 'prev' ? 'prev' : undefined,
                    query: {
                        index,
                        range: ctx.range,
                    },
                })
                    .then(({ result }) => valueMapper ? result.map(valueMapper) : result);
            }
            else {
                const a = [];
                return iter(ctx, (item) => a.push(item), trans, ctx.table.core).then(() => a);
            }
        }, cb);
    }
    offset(offset) {
        var ctx = this._ctx;
        if (offset <= 0)
            return this;
        ctx.offset += offset;
        if (isPlainKeyRange(ctx)) {
            addReplayFilter(ctx, () => {
                var offsetLeft = offset;
                return (cursor, advance) => {
                    if (offsetLeft === 0)
                        return true;
                    if (offsetLeft === 1) {
                        --offsetLeft;
                        return false;
                    }
                    advance(() => {
                        cursor.advance(offsetLeft);
                        offsetLeft = 0;
                    });
                    return false;
                };
            });
        }
        else {
            addReplayFilter(ctx, () => {
                var offsetLeft = offset;
                return () => --offsetLeft < 0;
            });
        }
        return this;
    }
    limit(numRows) {
        this._ctx.limit = Math.min(this._ctx.limit, numRows);
        addReplayFilter(this._ctx, () => {
            var rowsLeft = numRows;
            return function (cursor, advance, resolve) {
                if (--rowsLeft <= 0)
                    advance(resolve);
                return rowsLeft >= 0;
            };
        }, true);
        return this;
    }
    until(filterFunction, bIncludeStopEntry) {
        addFilter(this._ctx, function (cursor, advance, resolve) {
            if (filterFunction(cursor.value)) {
                advance(resolve);
                return bIncludeStopEntry;
            }
            else {
                return true;
            }
        });
        return this;
    }
    first(cb) {
        return this.limit(1)
            .toArray(function (a) {
            return a[0];
        })
            .then(cb);
    }
    last(cb) {
        return this.reverse().first(cb);
    }
    filter(filterFunction) {
        addFilter(this._ctx, function (cursor) {
            return filterFunction(cursor.value);
        });
        addMatchFilter(this._ctx, filterFunction);
        return this;
    }
    and(filter) {
        return this.filter(filter);
    }
    or(indexName) {
        return new this.db.WhereClause(this._ctx.table, indexName, this);
    }
    reverse() {
        this._ctx.dir = this._ctx.dir === 'prev' ? 'next' : 'prev';
        if (this._ondirectionchange)
            this._ondirectionchange(this._ctx.dir);
        return this;
    }
    desc() {
        return this.reverse();
    }
    eachKey(cb) {
        var ctx = this._ctx;
        ctx.keysOnly = !ctx.isMatch;
        return this.each(function (val, cursor) {
            cb(cursor.key, cursor);
        });
    }
    eachUniqueKey(cb) {
        this._ctx.unique = 'unique';
        return this.eachKey(cb);
    }
    eachPrimaryKey(cb) {
        var ctx = this._ctx;
        ctx.keysOnly = !ctx.isMatch;
        return this.each(function (val, cursor) {
            cb(cursor.primaryKey, cursor);
        });
    }
    keys(cb) {
        var ctx = this._ctx;
        ctx.keysOnly = !ctx.isMatch;
        var a = [];
        return this.each(function (item, cursor) {
            a.push(cursor.key);
        })
            .then(function () {
            return a;
        })
            .then(cb);
    }
    primaryKeys(cb) {
        var ctx = this._ctx;
        if (isPlainKeyRange(ctx, true) && ctx.limit > 0) {
            return this._read((trans) => {
                var index = getIndexOrStore(ctx, ctx.table.core.schema);
                return ctx.table.core.query({
                    trans,
                    values: false,
                    limit: ctx.limit,
                    direction: ctx.dir === 'prev' ? 'prev' : undefined,
                    query: {
                        index,
                        range: ctx.range,
                    },
                });
            })
                .then(({ result }) => result)
                .then(cb);
        }
        ctx.keysOnly = !ctx.isMatch;
        var a = [];
        return this.each(function (item, cursor) {
            a.push(cursor.primaryKey);
        })
            .then(function () {
            return a;
        })
            .then(cb);
    }
    uniqueKeys(cb) {
        this._ctx.unique = 'unique';
        return this.keys(cb);
    }
    firstKey(cb) {
        return this.limit(1)
            .keys(function (a) {
            return a[0];
        })
            .then(cb);
    }
    lastKey(cb) {
        return this.reverse().firstKey(cb);
    }
    distinct() {
        var ctx = this._ctx, idx = ctx.index && ctx.table.schema.idxByName[ctx.index];
        if (!idx || !idx.multi)
            return this;
        var set = {};
        addFilter(this._ctx, function (cursor) {
            var strKey = cursor.primaryKey.toString();
            var found = hasOwn(set, strKey);
            set[strKey] = true;
            return !found;
        });
        return this;
    }
    modify(changes) {
        var ctx = this._ctx;
        return this._write((trans) => {
            var modifyer;
            if (typeof changes === 'function') {
                modifyer = changes;
            }
            else {
                modifyer = (item) => applyUpdateSpec(item, changes);
            }
            const coreTable = ctx.table.core;
            const { outbound, extractKey } = coreTable.schema.primaryKey;
            let limit = 200;
            const modifyChunkSize = this.db._options.modifyChunkSize;
            if (modifyChunkSize) {
                if (typeof modifyChunkSize == 'object') {
                    limit =
                        modifyChunkSize[coreTable.name] || modifyChunkSize['*'] || 200;
                }
                else {
                    limit = modifyChunkSize;
                }
            }
            const totalFailures = [];
            let successCount = 0;
            const failedKeys = [];
            const applyMutateResult = (expectedCount, res) => {
                const { failures, numFailures } = res;
                successCount += expectedCount - numFailures;
                for (let pos of keys(failures)) {
                    totalFailures.push(failures[pos]);
                }
            };
            const isUnconditionalDelete = changes === deleteCallback;
            return this.clone()
                .primaryKeys()
                .then((keys) => {
                const criteria = isPlainKeyRange(ctx) &&
                    ctx.limit === Infinity &&
                    (typeof changes !== 'function' || isUnconditionalDelete) && {
                    index: ctx.index,
                    range: ctx.range,
                };
                const nextChunk = (offset) => {
                    const count = Math.min(limit, keys.length - offset);
                    const keysInChunk = keys.slice(offset, offset + count);
                    return (isUnconditionalDelete
                        ? Promise.resolve([])
                        : coreTable.getMany({
                            trans,
                            keys: keysInChunk,
                            cache: 'immutable',
                        })).then((values) => {
                        const addValues = [];
                        const putValues = [];
                        const putKeys = outbound ? [] : null;
                        const deleteKeys = isUnconditionalDelete ? keysInChunk : [];
                        if (!isUnconditionalDelete)
                            for (let i = 0; i < count; ++i) {
                                const origValue = values[i];
                                const ctx = {
                                    value: deepClone(origValue),
                                    primKey: keys[offset + i],
                                };
                                if (modifyer.call(ctx, ctx.value, ctx) !== false) {
                                    if (ctx.value == null) {
                                        deleteKeys.push(keys[offset + i]);
                                    }
                                    else if (!outbound &&
                                        cmp(extractKey(origValue), extractKey(ctx.value)) !== 0) {
                                        deleteKeys.push(keys[offset + i]);
                                        addValues.push(ctx.value);
                                    }
                                    else {
                                        putValues.push(ctx.value);
                                        if (outbound)
                                            putKeys.push(keys[offset + i]);
                                    }
                                }
                            }
                        return Promise.resolve(addValues.length > 0 &&
                            coreTable
                                .mutate({ trans, type: 'add', values: addValues })
                                .then((res) => {
                                for (let pos in res.failures) {
                                    deleteKeys.splice(parseInt(pos), 1);
                                }
                                applyMutateResult(addValues.length, res);
                            }))
                            .then(() => (putValues.length > 0 ||
                            (criteria && typeof changes === 'object')) &&
                            coreTable
                                .mutate({
                                trans,
                                type: 'put',
                                keys: putKeys,
                                values: putValues,
                                criteria,
                                changeSpec: typeof changes !== 'function' && changes,
                                isAdditionalChunk: offset > 0,
                            })
                                .then((res) => applyMutateResult(putValues.length, res)))
                            .then(() => (deleteKeys.length > 0 ||
                            (criteria && isUnconditionalDelete)) &&
                            coreTable
                                .mutate({
                                trans,
                                type: 'delete',
                                keys: deleteKeys,
                                criteria,
                                isAdditionalChunk: offset > 0,
                            })
                                .then((res) => builtInDeletionTrigger(ctx.table, deleteKeys, res))
                                .then((res) => applyMutateResult(deleteKeys.length, res)))
                            .then(() => {
                            return (keys.length > offset + count && nextChunk(offset + limit));
                        });
                    });
                };
                return nextChunk(0).then(() => {
                    if (totalFailures.length > 0)
                        throw new ModifyError('Error modifying one or more objects', totalFailures, successCount, failedKeys);
                    return keys.length;
                });
            });
        });
    }
    delete() {
        var ctx = this._ctx, range = ctx.range;
        if (isPlainKeyRange(ctx) &&
            !ctx.table.schema.yProps &&
            (ctx.isPrimKey || range.type === 3 ))
         {
            return this._write((trans) => {
                const { primaryKey } = ctx.table.core.schema;
                const coreRange = range;
                return ctx.table.core
                    .count({ trans, query: { index: primaryKey, range: coreRange } })
                    .then((count) => {
                    return ctx.table.core
                        .mutate({ trans, type: 'deleteRange', range: coreRange })
                        .then(({ failures, numFailures }) => {
                        if (numFailures)
                            throw new ModifyError('Could not delete some values', Object.keys(failures).map((pos) => failures[pos]), count - numFailures);
                        return count - numFailures;
                    });
                });
            });
        }
        return this.modify(deleteCallback);
    }
}
const deleteCallback = (value, ctx) => (ctx.value = null);

function createCollectionConstructor(db) {
    return makeClassConstructor(Collection.prototype, function Collection(whereClause, keyRangeGenerator) {
        this.db = db;
        let keyRange = AnyRange, error = null;
        if (keyRangeGenerator)
            try {
                keyRange = keyRangeGenerator();
            }
            catch (ex) {
                error = ex;
            }
        const whereCtx = whereClause._ctx;
        const table = whereCtx.table;
        const readingHook = table.hook.reading.fire;
        this._ctx = {
            table: table,
            index: whereCtx.index,
            isPrimKey: !whereCtx.index ||
                (table.schema.primKey.keyPath &&
                    whereCtx.index === table.schema.primKey.name),
            range: keyRange,
            keysOnly: false,
            dir: 'next',
            unique: '',
            algorithm: null,
            filter: null,
            replayFilter: null,
            justLimit: true,
            isMatch: null,
            offset: 0,
            limit: Infinity,
            error: error,
            or: whereCtx.or,
            valueMapper: readingHook !== mirror ? readingHook : null,
        };
    });
}

function simpleCompare(a, b) {
    return a < b ? -1 : a === b ? 0 : 1;
}
function simpleCompareReverse(a, b) {
    return a > b ? -1 : a === b ? 0 : 1;
}

function fail(collectionOrWhereClause, err, T) {
    var collection = collectionOrWhereClause instanceof WhereClause
        ? new collectionOrWhereClause.Collection(collectionOrWhereClause)
        : collectionOrWhereClause;
    collection._ctx.error = T ? new T(err) : new TypeError(err);
    return collection;
}
function emptyCollection(whereClause) {
    return new whereClause.Collection(whereClause, () => rangeEqual('')).limit(0);
}
function upperFactory(dir) {
    return dir === 'next'
        ? (s) => s.toUpperCase()
        : (s) => s.toLowerCase();
}
function lowerFactory(dir) {
    return dir === 'next'
        ? (s) => s.toLowerCase()
        : (s) => s.toUpperCase();
}
function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir) {
    var length = Math.min(key.length, lowerNeedle.length);
    var llp = -1;
    for (var i = 0; i < length; ++i) {
        var lwrKeyChar = lowerKey[i];
        if (lwrKeyChar !== lowerNeedle[i]) {
            if (cmp(key[i], upperNeedle[i]) < 0)
                return key.substr(0, i) + upperNeedle[i] + upperNeedle.substr(i + 1);
            if (cmp(key[i], lowerNeedle[i]) < 0)
                return key.substr(0, i) + lowerNeedle[i] + upperNeedle.substr(i + 1);
            if (llp >= 0)
                return key.substr(0, llp) + lowerKey[llp] + upperNeedle.substr(llp + 1);
            return null;
        }
        if (cmp(key[i], lwrKeyChar) < 0)
            llp = i;
    }
    if (length < lowerNeedle.length && dir === 'next')
        return key + upperNeedle.substr(key.length);
    if (length < key.length && dir === 'prev')
        return key.substr(0, upperNeedle.length);
    return llp < 0
        ? null
        : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
}
function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
    var upper, lower, compare, upperNeedles, lowerNeedles, direction, nextKeySuffix, needlesLen = needles.length;
    if (!needles.every((s) => typeof s === 'string')) {
        return fail(whereClause, STRING_EXPECTED);
    }
    function initDirection(dir) {
        upper = upperFactory(dir);
        lower = lowerFactory(dir);
        compare = dir === 'next' ? simpleCompare : simpleCompareReverse;
        var needleBounds = needles
            .map(function (needle) {
            return { lower: lower(needle), upper: upper(needle) };
        })
            .sort(function (a, b) {
            return compare(a.lower, b.lower);
        });
        upperNeedles = needleBounds.map(function (nb) {
            return nb.upper;
        });
        lowerNeedles = needleBounds.map(function (nb) {
            return nb.lower;
        });
        direction = dir;
        nextKeySuffix = dir === 'next' ? '' : suffix;
    }
    initDirection('next');
    var c = new whereClause.Collection(whereClause, () => createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix));
    c._ondirectionchange = function (direction) {
        initDirection(direction);
    };
    var firstPossibleNeedle = 0;
    c._addAlgorithm(function (cursor, advance, resolve) {
        var key = cursor.key;
        if (typeof key !== 'string')
            return false;
        var lowerKey = lower(key);
        if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) {
            return true;
        }
        else {
            var lowestPossibleCasing = null;
            for (var i = firstPossibleNeedle; i < needlesLen; ++i) {
                var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction);
                if (casing === null && lowestPossibleCasing === null)
                    firstPossibleNeedle = i + 1;
                else if (lowestPossibleCasing === null ||
                    compare(lowestPossibleCasing, casing) > 0) {
                    lowestPossibleCasing = casing;
                }
            }
            if (lowestPossibleCasing !== null) {
                advance(function () {
                    cursor.continue(lowestPossibleCasing + nextKeySuffix);
                });
            }
            else {
                advance(resolve);
            }
            return false;
        }
    });
    return c;
}
function createRange(lower, upper, lowerOpen, upperOpen) {
    return {
        type: 2 ,
        lower,
        upper,
        lowerOpen,
        upperOpen,
    };
}
function rangeEqual(value) {
    return {
        type: 1 ,
        lower: value,
        upper: value,
    };
}

class WhereClause {
    get Collection() {
        return this._ctx.table.db.Collection;
    }
    between(lower, upper, includeLower, includeUpper) {
        includeLower = includeLower !== false;
        includeUpper = includeUpper === true;
        try {
            if (this._cmp(lower, upper) > 0 ||
                (this._cmp(lower, upper) === 0 &&
                    (includeLower || includeUpper) &&
                    !(includeLower && includeUpper)))
                return emptyCollection(this);
            return new this.Collection(this, () => createRange(lower, upper, !includeLower, !includeUpper));
        }
        catch (e) {
            return fail(this, INVALID_KEY_ARGUMENT);
        }
    }
    equals(value) {
        if (value == null)
            return fail(this, INVALID_KEY_ARGUMENT);
        return new this.Collection(this, () => rangeEqual(value));
    }
    above(value) {
        if (value == null)
            return fail(this, INVALID_KEY_ARGUMENT);
        return new this.Collection(this, () => createRange(value, undefined, true));
    }
    aboveOrEqual(value) {
        if (value == null)
            return fail(this, INVALID_KEY_ARGUMENT);
        return new this.Collection(this, () => createRange(value, undefined, false));
    }
    below(value) {
        if (value == null)
            return fail(this, INVALID_KEY_ARGUMENT);
        return new this.Collection(this, () => createRange(undefined, value, false, true));
    }
    belowOrEqual(value) {
        if (value == null)
            return fail(this, INVALID_KEY_ARGUMENT);
        return new this.Collection(this, () => createRange(undefined, value));
    }
    startsWith(str) {
        if (typeof str !== 'string')
            return fail(this, STRING_EXPECTED);
        return this.between(str, str + maxString, true, true);
    }
    startsWithIgnoreCase(str) {
        if (str === '')
            return this.startsWith(str);
        return addIgnoreCaseAlgorithm(this, (x, a) => x.indexOf(a[0]) === 0, [str], maxString);
    }
    equalsIgnoreCase(str) {
        return addIgnoreCaseAlgorithm(this, (x, a) => x === a[0], [str], '');
    }
    anyOfIgnoreCase() {
        var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
        if (set.length === 0)
            return emptyCollection(this);
        return addIgnoreCaseAlgorithm(this, (x, a) => a.indexOf(x) !== -1, set, '');
    }
    startsWithAnyOfIgnoreCase() {
        var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
        if (set.length === 0)
            return emptyCollection(this);
        return addIgnoreCaseAlgorithm(this, (x, a) => a.some((n) => x.indexOf(n) === 0), set, maxString);
    }
    anyOf() {
        const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
        let compare = this._cmp;
        try {
            set.sort(compare);
        }
        catch (e) {
            return fail(this, INVALID_KEY_ARGUMENT);
        }
        if (set.length === 0)
            return emptyCollection(this);
        const c = new this.Collection(this, () => createRange(set[0], set[set.length - 1]));
        c._ondirectionchange = (direction) => {
            compare = direction === 'next' ? this._ascending : this._descending;
            set.sort(compare);
        };
        let i = 0;
        c._addAlgorithm((cursor, advance, resolve) => {
            const key = cursor.key;
            while (compare(key, set[i]) > 0) {
                ++i;
                if (i === set.length) {
                    advance(resolve);
                    return false;
                }
            }
            if (compare(key, set[i]) === 0) {
                return true;
            }
            else {
                advance(() => {
                    cursor.continue(set[i]);
                });
                return false;
            }
        });
        return c;
    }
    notEqual(value) {
        return this.inAnyRange([
            [minKey, value],
            [value, this.db._maxKey],
        ], { includeLowers: false, includeUppers: false });
    }
    noneOf() {
        const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
        if (set.length === 0)
            return new this.Collection(this);
        try {
            set.sort(this._ascending);
        }
        catch (e) {
            return fail(this, INVALID_KEY_ARGUMENT);
        }
        const ranges = set.reduce((res, val) => res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]], null);
        ranges.push([set[set.length - 1], this.db._maxKey]);
        return this.inAnyRange(ranges, {
            includeLowers: false,
            includeUppers: false,
        });
    }
    inAnyRange(ranges, options) {
        const cmp = this._cmp, ascending = this._ascending, descending = this._descending, min = this._min, max = this._max;
        if (ranges.length === 0)
            return emptyCollection(this);
        if (!ranges.every((range) => range[0] !== undefined &&
            range[1] !== undefined &&
            ascending(range[0], range[1]) <= 0)) {
            return fail(this, 'First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower', exceptions.InvalidArgument);
        }
        const includeLowers = !options || options.includeLowers !== false;
        const includeUppers = options && options.includeUppers === true;
        function addRange(ranges, newRange) {
            let i = 0, l = ranges.length;
            for (; i < l; ++i) {
                const range = ranges[i];
                if (cmp(newRange[0], range[1]) < 0 && cmp(newRange[1], range[0]) > 0) {
                    range[0] = min(range[0], newRange[0]);
                    range[1] = max(range[1], newRange[1]);
                    break;
                }
            }
            if (i === l)
                ranges.push(newRange);
            return ranges;
        }
        let sortDirection = ascending;
        function rangeSorter(a, b) {
            return sortDirection(a[0], b[0]);
        }
        let set;
        try {
            set = ranges.reduce(addRange, []);
            set.sort(rangeSorter);
        }
        catch (ex) {
            return fail(this, INVALID_KEY_ARGUMENT);
        }
        let rangePos = 0;
        const keyIsBeyondCurrentEntry = includeUppers
            ? (key) => ascending(key, set[rangePos][1]) > 0
            : (key) => ascending(key, set[rangePos][1]) >= 0;
        const keyIsBeforeCurrentEntry = includeLowers
            ? (key) => descending(key, set[rangePos][0]) > 0
            : (key) => descending(key, set[rangePos][0]) >= 0;
        function keyWithinCurrentRange(key) {
            return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key);
        }
        let checkKey = keyIsBeyondCurrentEntry;
        const c = new this.Collection(this, () => createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers));
        c._ondirectionchange = (direction) => {
            if (direction === 'next') {
                checkKey = keyIsBeyondCurrentEntry;
                sortDirection = ascending;
            }
            else {
                checkKey = keyIsBeforeCurrentEntry;
                sortDirection = descending;
            }
            set.sort(rangeSorter);
        };
        c._addAlgorithm((cursor, advance, resolve) => {
            var key = cursor.key;
            while (checkKey(key)) {
                ++rangePos;
                if (rangePos === set.length) {
                    advance(resolve);
                    return false;
                }
            }
            if (keyWithinCurrentRange(key)) {
                return true;
            }
            else if (this._cmp(key, set[rangePos][1]) === 0 ||
                this._cmp(key, set[rangePos][0]) === 0) {
                return false;
            }
            else {
                advance(() => {
                    if (sortDirection === ascending)
                        cursor.continue(set[rangePos][0]);
                    else
                        cursor.continue(set[rangePos][1]);
                });
                return false;
            }
        });
        return c;
    }
    startsWithAnyOf() {
        const set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
        if (!set.every((s) => typeof s === 'string')) {
            return fail(this, 'startsWithAnyOf() only works with strings');
        }
        if (set.length === 0)
            return emptyCollection(this);
        return this.inAnyRange(set.map((str) => [str, str + maxString]));
    }
}

function createWhereClauseConstructor(db) {
    return makeClassConstructor(WhereClause.prototype, function WhereClause(table, index, orCollection) {
        this.db = db;
        this._ctx = {
            table: table,
            index: index === ':id' ? null : index,
            or: orCollection,
        };
        this._cmp = this._ascending = cmp;
        this._descending = (a, b) => cmp(b, a);
        this._max = (a, b) => (cmp(a, b) > 0 ? a : b);
        this._min = (a, b) => (cmp(a, b) < 0 ? a : b);
        this._IDBKeyRange = db._deps.IDBKeyRange;
        if (!this._IDBKeyRange)
            throw new exceptions.MissingAPI();
    });
}

function eventRejectHandler(reject) {
    return wrap(function (event) {
        preventDefault(event);
        reject(event.target.error);
        return false;
    });
}
function preventDefault(event) {
    if (event.stopPropagation)
        event.stopPropagation();
    if (event.preventDefault)
        event.preventDefault();
}

const DEXIE_STORAGE_MUTATED_EVENT_NAME = 'storagemutated';
const STORAGE_MUTATED_DOM_EVENT_NAME = 'x-storagemutated-1';
const globalEvents = Events(null, DEXIE_STORAGE_MUTATED_EVENT_NAME);

class Transaction {
    _lock() {
        assert(!PSD.global);
        ++this._reculock;
        if (this._reculock === 1 && !PSD.global)
            PSD.lockOwnerFor = this;
        return this;
    }
    _unlock() {
        assert(!PSD.global);
        if (--this._reculock === 0) {
            if (!PSD.global)
                PSD.lockOwnerFor = null;
            while (this._blockedFuncs.length > 0 && !this._locked()) {
                var fnAndPSD = this._blockedFuncs.shift();
                try {
                    usePSD(fnAndPSD[1], fnAndPSD[0]);
                }
                catch (e) { }
            }
        }
        return this;
    }
    _locked() {
        return this._reculock && PSD.lockOwnerFor !== this;
    }
    create(idbtrans) {
        if (!this.mode)
            return this;
        const idbdb = this.db.idbdb;
        const dbOpenError = this.db._state.dbOpenError;
        assert(!this.idbtrans);
        if (!idbtrans && !idbdb) {
            switch (dbOpenError && dbOpenError.name) {
                case 'DatabaseClosedError':
                    throw new exceptions.DatabaseClosed(dbOpenError);
                case 'MissingAPIError':
                    throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError);
                default:
                    throw new exceptions.OpenFailed(dbOpenError);
            }
        }
        if (!this.active)
            throw new exceptions.TransactionInactive();
        assert(this._completion._state === null);
        idbtrans = this.idbtrans =
            idbtrans ||
                (this.db.core
                    ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability })
                    : idbdb.transaction(this.storeNames, this.mode, {
                        durability: this.chromeTransactionDurability,
                    }));
        idbtrans.onerror = wrap((ev) => {
            preventDefault(ev);
            this._reject(idbtrans.error);
        });
        idbtrans.onabort = wrap((ev) => {
            preventDefault(ev);
            this.active && this._reject(new exceptions.Abort(idbtrans.error));
            this.active = false;
            this.on('abort').fire(ev);
        });
        idbtrans.oncomplete = wrap(() => {
            this.active = false;
            this._resolve();
            if ('mutatedParts' in idbtrans) {
                globalEvents.storagemutated.fire(idbtrans['mutatedParts']);
            }
        });
        return this;
    }
    _promise(mode, fn, bWriteLock) {
        if (mode === 'readwrite' && this.mode !== 'readwrite')
            return rejection(new exceptions.ReadOnly('Transaction is readonly'));
        if (!this.active)
            return rejection(new exceptions.TransactionInactive());
        if (this._locked()) {
            return new DexiePromise((resolve, reject) => {
                this._blockedFuncs.push([
                    () => {
                        this._promise(mode, fn, bWriteLock).then(resolve, reject);
                    },
                    PSD,
                ]);
            });
        }
        else if (bWriteLock) {
            return newScope(() => {
                var p = new DexiePromise((resolve, reject) => {
                    this._lock();
                    const rv = fn(resolve, reject, this);
                    if (rv && rv.then)
                        rv.then(resolve, reject);
                });
                p.finally(() => this._unlock());
                p._lib = true;
                return p;
            });
        }
        else {
            var p = new DexiePromise((resolve, reject) => {
                var rv = fn(resolve, reject, this);
                if (rv && rv.then)
                    rv.then(resolve, reject);
            });
            p._lib = true;
            return p;
        }
    }
    _root() {
        return this.parent ? this.parent._root() : this;
    }
    waitFor(promiseLike) {
        var root = this._root();
        const promise = DexiePromise.resolve(promiseLike);
        if (root._waitingFor) {
            root._waitingFor = root._waitingFor.then(() => promise);
        }
        else {
            root._waitingFor = promise;
            root._waitingQueue = [];
            var store = root.idbtrans.objectStore(root.storeNames[0]);
            (function spin() {
                ++root._spinCount;
                while (root._waitingQueue.length)
                    root._waitingQueue.shift()();
                if (root._waitingFor)
                    store.get(-Infinity).onsuccess = spin;
            })();
        }
        var currentWaitPromise = root._waitingFor;
        return new DexiePromise((resolve, reject) => {
            promise
                .then((res) => root._waitingQueue.push(wrap(resolve.bind(null, res))), (err) => root._waitingQueue.push(wrap(reject.bind(null, err))))
                .finally(() => {
                if (root._waitingFor === currentWaitPromise) {
                    root._waitingFor = null;
                }
            });
        });
    }
    abort() {
        if (this.active) {
            this.active = false;
            if (this.idbtrans)
                this.idbtrans.abort();
            this._reject(new exceptions.Abort());
        }
    }
    table(tableName) {
        const memoizedTables = this._memoizedTables || (this._memoizedTables = {});
        if (hasOwn(memoizedTables, tableName))
            return memoizedTables[tableName];
        const tableSchema = this.schema[tableName];
        if (!tableSchema) {
            throw new exceptions.NotFound('Table ' + tableName + ' not part of transaction');
        }
        const transactionBoundTable = new this.db.Table(tableName, tableSchema, this);
        transactionBoundTable.core = this.db.core.table(tableName);
        memoizedTables[tableName] = transactionBoundTable;
        return transactionBoundTable;
    }
}

function createTransactionConstructor(db) {
    return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
        if (mode !== 'readonly')
            storeNames.forEach((storeName) => {
                const yProps = dbschema[storeName]?.yProps;
                if (yProps)
                    storeNames = storeNames.concat(yProps.map((p) => p.updatesTable));
            });
        this.db = db;
        this.mode = mode;
        this.storeNames = storeNames;
        this.schema = dbschema;
        this.chromeTransactionDurability = chromeTransactionDurability;
        this.idbtrans = null;
        this.on = Events(this, 'complete', 'error', 'abort');
        this.parent = parent || null;
        this.active = true;
        this._reculock = 0;
        this._blockedFuncs = [];
        this._resolve = null;
        this._reject = null;
        this._waitingFor = null;
        this._waitingQueue = null;
        this._spinCount = 0;
        this._completion = new DexiePromise((resolve, reject) => {
            this._resolve = resolve;
            this._reject = reject;
        });
        this._completion.then(() => {
            this.active = false;
            this.on.complete.fire();
        }, (e) => {
            var wasActive = this.active;
            this.active = false;
            this.on.error.fire(e);
            this.parent
                ? this.parent._reject(e)
                : wasActive && this.idbtrans && this.idbtrans.abort();
            return rejection(e);
        });
    });
}

function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey, type) {
    return {
        name,
        keyPath,
        unique,
        multi,
        auto,
        compound,
        src: (unique && !isPrimKey ? '&' : '') +
            (multi ? '*' : '') +
            (auto ? '++' : '') +
            nameFromKeyPath(keyPath),
        type,
    };
}
function nameFromKeyPath(keyPath) {
    return typeof keyPath === 'string'
        ? keyPath
        : keyPath
            ? '[' + [].join.call(keyPath, '+') + ']'
            : '';
}

function createTableSchema(name, primKey, indexes) {
    return {
        name,
        primKey,
        indexes,
        mappedClass: null,
        idxByName: arrayToObject(indexes, (index) => [index.name, index]),
    };
}

function safariMultiStoreFix(storeNames) {
    return storeNames.length === 1 ? storeNames[0] : storeNames;
}
let getMaxKey = (IdbKeyRange) => {
    try {
        IdbKeyRange.only([[]]);
        getMaxKey = () => [[]];
        return [[]];
    }
    catch (e) {
        getMaxKey = () => maxString;
        return maxString;
    }
};

function getKeyExtractor(keyPath) {
    if (keyPath == null) {
        return () => undefined;
    }
    else if (typeof keyPath === 'string') {
        return getSinglePathKeyExtractor(keyPath);
    }
    else {
        return (obj) => getByKeyPath(obj, keyPath);
    }
}
function getSinglePathKeyExtractor(keyPath) {
    const split = keyPath.split('.');
    if (split.length === 1) {
        return (obj) => obj[keyPath];
    }
    else {
        return (obj) => getByKeyPath(obj, keyPath);
    }
}

function arrayify(arrayLike) {
    return [].slice.call(arrayLike);
}
let _id_counter = 0;
function getKeyPathAlias(keyPath) {
    return keyPath == null
        ? ':id'
        : typeof keyPath === 'string'
            ? keyPath
            : `[${keyPath.join('+')}]`;
}
function createDBCore(db, IdbKeyRange, tmpTrans) {
    function extractSchema(db, trans) {
        const tables = arrayify(db.objectStoreNames);
        const tempStore = tables.length > 0 ? trans.objectStore(tables[0]) : {};
        return {
            schema: {
                name: db.name,
                tables: tables
                    .map((table) => trans.objectStore(table))
                    .map((store) => {
                    const { keyPath, autoIncrement } = store;
                    const compound = isArray(keyPath);
                    const outbound = keyPath == null;
                    const indexByKeyPath = {};
                    const result = {
                        name: store.name,
                        primaryKey: {
                            name: null,
                            isPrimaryKey: true,
                            outbound,
                            compound,
                            keyPath,
                            autoIncrement,
                            unique: true,
                            extractKey: getKeyExtractor(keyPath),
                        },
                        indexes: arrayify(store.indexNames)
                            .map((indexName) => store.index(indexName))
                            .map((index) => {
                            const { name, unique, multiEntry, keyPath } = index;
                            const compound = isArray(keyPath);
                            const result = {
                                name,
                                compound,
                                keyPath,
                                unique,
                                multiEntry,
                                extractKey: getKeyExtractor(keyPath),
                            };
                            indexByKeyPath[getKeyPathAlias(keyPath)] = result;
                            return result;
                        }),
                        getIndexByKeyPath: (keyPath) => indexByKeyPath[getKeyPathAlias(keyPath)],
                    };
                    indexByKeyPath[':id'] = result.primaryKey;
                    if (keyPath != null) {
                        indexByKeyPath[getKeyPathAlias(keyPath)] = result.primaryKey;
                    }
                    return result;
                }),
            },
            hasGetAll: tables.length > 0 &&
                'getAll' in tempStore &&
                !(typeof navigator !== 'undefined' &&
                    /Safari/.test(navigator.userAgent) &&
                    !/(Chrome\/|Edge\/)/.test(navigator.userAgent) &&
                    [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604),
            hasIdb3Features: 'getAllRecords' in tempStore,
        };
    }
    function makeIDBKeyRange(range) {
        if (range.type === 3 )
            return null;
        if (range.type === 4 )
            throw new Error('Cannot convert never type to IDBKeyRange');
        const { lower, upper, lowerOpen, upperOpen } = range;
        const idbRange = lower === undefined
            ? upper === undefined
                ? null
                : IdbKeyRange.upperBound(upper, !!upperOpen)
            : upper === undefined
                ? IdbKeyRange.lowerBound(lower, !!lowerOpen)
                : IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen);
        return idbRange;
    }
    function createDbCoreTable(tableSchema) {
        const tableName = tableSchema.name;
        function mutate({ trans, type, keys, values, range }) {
            return new Promise((resolve, reject) => {
                resolve = wrap(resolve);
                const store = trans.objectStore(tableName);
                const outbound = store.keyPath == null;
                const isAddOrPut = type === 'put' || type === 'add';
                if (!isAddOrPut && type !== 'delete' && type !== 'deleteRange')
                    throw new Error('Invalid operation type: ' + type);
                const { length } = keys || values || { length: 1 };
                if (keys && values && keys.length !== values.length) {
                    throw new Error('Given keys array must have same length as given values array.');
                }
                if (length === 0)
                    return resolve({
                        numFailures: 0,
                        failures: {},
                        results: [],
                        lastResult: undefined,
                    });
                let req;
                const reqs = [];
                const failures = [];
                let numFailures = 0;
                const errorHandler = (event) => {
                    ++numFailures;
                    preventDefault(event);
                };
                if (type === 'deleteRange') {
                    if (range.type === 4 )
                        return resolve({
                            numFailures,
                            failures,
                            results: [],
                            lastResult: undefined,
                        });
                    if (range.type === 3 )
                        reqs.push((req = store.clear()));
                    else
                        reqs.push((req = store.delete(makeIDBKeyRange(range))));
                }
                else {
                    const [args1, args2] = isAddOrPut
                        ? outbound
                            ? [values, keys]
                            : [values, null]
                        : [keys, null];
                    if (isAddOrPut) {
                        for (let i = 0; i < length; ++i) {
                            reqs.push((req = (args2 && args2[i] !== undefined
                                ? store[type](args1[i], args2[i])
                                : store[type](args1[i]))));
                            req.onerror = errorHandler;
                        }
                    }
                    else {
                        for (let i = 0; i < length; ++i) {
                            reqs.push((req = store[type](args1[i])));
                            req.onerror = errorHandler;
                        }
                    }
                }
                const done = (event) => {
                    const lastResult = event.target.result;
                    reqs.forEach((req, i) => req.error != null && (failures[i] = req.error));
                    resolve({
                        numFailures,
                        failures,
                        results: type === 'delete' ? keys : reqs.map((req) => req.result),
                        lastResult,
                    });
                };
                req.onerror = (event) => {
                    errorHandler(event);
                    done(event);
                };
                req.onsuccess = done;
            });
        }
        function openCursor({ trans, values, query, reverse, unique, }) {
            return new Promise((resolve, reject) => {
                resolve = wrap(resolve);
                const { index, range } = query;
                const store = trans.objectStore(tableName);
                const source = index.isPrimaryKey ? store : store.index(index.name);
                const direction = reverse
                    ? unique
                        ? 'prevunique'
                        : 'prev'
                    : unique
                        ? 'nextunique'
                        : 'next';
                const req = values || !('openKeyCursor' in source)
                    ? source.openCursor(makeIDBKeyRange(range), direction)
                    : source.openKeyCursor(makeIDBKeyRange(range), direction);
                req.onerror = eventRejectHandler(reject);
                req.onsuccess = wrap((ev) => {
                    const cursor = req.result;
                    if (!cursor) {
                        resolve(null);
                        return;
                    }
                    cursor.___id = ++_id_counter;
                    cursor.done = false;
                    const _cursorContinue = cursor.continue.bind(cursor);
                    let _cursorContinuePrimaryKey = cursor.continuePrimaryKey;
                    if (_cursorContinuePrimaryKey)
                        _cursorContinuePrimaryKey = _cursorContinuePrimaryKey.bind(cursor);
                    const _cursorAdvance = cursor.advance.bind(cursor);
                    const doThrowCursorIsNotStarted = () => {
                        throw new Error('Cursor not started');
                    };
                    const doThrowCursorIsStopped = () => {
                        throw new Error('Cursor not stopped');
                    };
                    cursor.trans = trans;
                    cursor.stop =
                        cursor.continue =
                            cursor.continuePrimaryKey =
                                cursor.advance =
                                    doThrowCursorIsNotStarted;
                    cursor.fail = wrap(reject);
                    cursor.next = function () {
                        let gotOne = 1;
                        return this.start(() => gotOne-- ? this.continue() : this.stop()).then(() => this);
                    };
                    cursor.start = (callback) => {
                        const iterationPromise = new Promise((resolveIteration, rejectIteration) => {
                            resolveIteration = wrap(resolveIteration);
                            req.onerror = eventRejectHandler(rejectIteration);
                            cursor.fail = rejectIteration;
                            cursor.stop = (value) => {
                                cursor.stop =
                                    cursor.continue =
                                        cursor.continuePrimaryKey =
                                            cursor.advance =
                                                doThrowCursorIsStopped;
                                resolveIteration(value);
                            };
                        });
                        const guardedCallback = () => {
                            if (req.result) {
                                try {
                                    callback();
                                }
                                catch (err) {
                                    cursor.fail(err);
                                }
                            }
                            else {
                                cursor.done = true;
                                cursor.start = () => {
                                    throw new Error('Cursor behind last entry');
                                };
                                cursor.stop();
                            }
                        };
                        req.onsuccess = wrap((ev) => {
                            req.onsuccess = guardedCallback;
                            guardedCallback();
                        });
                        cursor.continue = _cursorContinue;
                        cursor.continuePrimaryKey = _cursorContinuePrimaryKey;
                        cursor.advance = _cursorAdvance;
                        guardedCallback();
                        return iterationPromise;
                    };
                    resolve(cursor);
                }, reject);
            });
        }
        function query(hasGetAll, hasIdb3Features) {
            return (request) => {
                return new Promise((resolve, reject) => {
                    resolve = wrap(resolve);
                    const { trans, values, limit, query } = request;
                    const direction = request.direction ?? 'next';
                    const nonInfinitLimit = limit === Infinity ? undefined : limit;
                    const { index, range } = query;
                    const store = trans.objectStore(tableName);
                    const source = index.isPrimaryKey ? store : store.index(index.name);
                    const idbKeyRange = makeIDBKeyRange(range);
                    if (limit === 0)
                        return resolve({ result: [] });
                    if (hasIdb3Features) {
                        const options = {
                            query: idbKeyRange,
                            count: nonInfinitLimit,
                            direction,
                        };
                        const req = values
                            ? source.getAll(options)
                            : source.getAllKeys(options);
                        req.onsuccess = (event) => resolve({ result: event.target.result });
                        req.onerror = eventRejectHandler(reject);
                    }
                    else if (hasGetAll && direction === 'next') {
                        const req = values
                            ? source.getAll(idbKeyRange, nonInfinitLimit)
                            : source.getAllKeys(idbKeyRange, nonInfinitLimit);
                        req.onsuccess = (event) => resolve({ result: event.target.result });
                        req.onerror = eventRejectHandler(reject);
                    }
                    else {
                        let count = 0;
                        const req = values || !('openKeyCursor' in source)
                            ? source.openCursor(idbKeyRange, direction)
                            : source.openKeyCursor(idbKeyRange, direction);
                        const result = [];
                        req.onsuccess = () => {
                            const cursor = req.result;
                            if (!cursor)
                                return resolve({ result });
                            result.push(values ? cursor.value : cursor.primaryKey);
                            if (++count === limit)
                                return resolve({ result });
                            cursor.continue();
                        };
                        req.onerror = eventRejectHandler(reject);
                    }
                });
            };
        }
        return {
            name: tableName,
            schema: tableSchema,
            mutate,
            getMany({ trans, keys }) {
                return new Promise((resolve, reject) => {
                    resolve = wrap(resolve);
                    const store = trans.objectStore(tableName);
                    const length = keys.length;
                    const result = new Array(length);
                    let keyCount = 0;
                    let callbackCount = 0;
                    let req;
                    const successHandler = (event) => {
                        const req = event.target;
                        if ((result[req._pos] = req.result) != null)
                            ;
                        if (++callbackCount === keyCount)
                            resolve(result);
                    };
                    const errorHandler = eventRejectHandler(reject);
                    for (let i = 0; i < length; ++i) {
                        const key = keys[i];
                        if (key != null) {
                            req = store.get(keys[i]);
                            req._pos = i;
                            req.onsuccess = successHandler;
                            req.onerror = errorHandler;
                            ++keyCount;
                        }
                    }
                    if (keyCount === 0)
                        resolve(result);
                });
            },
            get({ trans, key }) {
                return new Promise((resolve, reject) => {
                    resolve = wrap(resolve);
                    const store = trans.objectStore(tableName);
                    const req = store.get(key);
                    req.onsuccess = (event) => resolve(event.target.result);
                    req.onerror = eventRejectHandler(reject);
                });
            },
            query: query(hasGetAll, hasIdb3Features),
            openCursor,
            count({ query, trans }) {
                const { index, range } = query;
                return new Promise((resolve, reject) => {
                    const store = trans.objectStore(tableName);
                    const source = index.isPrimaryKey ? store : store.index(index.name);
                    const idbKeyRange = makeIDBKeyRange(range);
                    const req = idbKeyRange ? source.count(idbKeyRange) : source.count();
                    req.onsuccess = wrap((ev) => resolve(ev.target.result));
                    req.onerror = eventRejectHandler(reject);
                });
            },
        };
    }
    const { schema, hasGetAll, hasIdb3Features } = extractSchema(db, tmpTrans);
    const tables = schema.tables.map((tableSchema) => createDbCoreTable(tableSchema));
    const tableMap = {};
    tables.forEach((table) => (tableMap[table.name] = table));
    return {
        stack: 'dbcore',
        transaction: db.transaction.bind(db),
        table(name) {
            const result = tableMap[name];
            if (!result)
                throw new Error(`Table '${name}' not found`);
            return tableMap[name];
        },
        MIN_KEY: -Infinity,
        MAX_KEY: getMaxKey(IdbKeyRange),
        schema,
    };
}

function createMiddlewareStack(stackImpl, middlewares) {
    return middlewares.reduce((down, { create }) => ({ ...down, ...create(down) }), stackImpl);
}
function createMiddlewareStacks(middlewares, idbdb, { IDBKeyRange, indexedDB }, tmpTrans) {
    const dbcore = createMiddlewareStack(createDBCore(idbdb, IDBKeyRange, tmpTrans), middlewares.dbcore);
    return {
        dbcore,
    };
}
function generateMiddlewareStacks(db, tmpTrans) {
    const idbdb = tmpTrans.db;
    const stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans);
    db.core = stacks.dbcore;
    db.tables.forEach((table) => {
        const tableName = table.name;
        if (db.core.schema.tables.some((tbl) => tbl.name === tableName)) {
            table.core = db.core.table(tableName);
            if (db[tableName] instanceof db.Table) {
                db[tableName].core = table.core;
            }
        }
    });
}

function setApiOnPlace(db, objs, tableNames, dbschema) {
    tableNames.forEach((tableName) => {
        const schema = dbschema[tableName];
        objs.forEach((obj) => {
            const propDesc = getPropertyDescriptor(obj, tableName);
            if (!propDesc || ('value' in propDesc && propDesc.value === undefined)) {
                if (obj === db.Transaction.prototype || obj instanceof db.Transaction) {
                    setProp(obj, tableName, {
                        get() {
                            return this.table(tableName);
                        },
                        set(value) {
                            defineProperty(this, tableName, {
                                value,
                                writable: true,
                                configurable: true,
                                enumerable: true,
                            });
                        },
                    });
                }
                else {
                    obj[tableName] = new db.Table(tableName, schema);
                }
            }
        });
    });
}
function removeTablesApi(db, objs) {
    objs.forEach((obj) => {
        for (let key in obj) {
            if (obj[key] instanceof db.Table)
                delete obj[key];
        }
    });
}
function lowerVersionFirst(a, b) {
    return a._cfg.version - b._cfg.version;
}
function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
    const globalSchema = db._dbSchema;
    if (idbUpgradeTrans.objectStoreNames.contains('$meta') &&
        !globalSchema.$meta) {
        globalSchema.$meta = createTableSchema('$meta', parseIndexSyntax('')[0], []);
        db._storeNames.push('$meta');
    }
    const trans = db._createTransaction('readwrite', db._storeNames, globalSchema);
    trans.create(idbUpgradeTrans);
    trans._completion.catch(reject);
    const rejectTransaction = trans._reject.bind(trans);
    const transless = PSD.transless || PSD;
    newScope(() => {
        PSD.trans = trans;
        PSD.transless = transless;
        if (oldVersion === 0) {
            keys(globalSchema).forEach((tableName) => {
                createTable(idbUpgradeTrans, tableName, globalSchema[tableName].primKey, globalSchema[tableName].indexes);
            });
            generateMiddlewareStacks(db, idbUpgradeTrans);
            DexiePromise.follow(() => db.on.populate.fire(trans)).catch(rejectTransaction);
        }
        else {
            generateMiddlewareStacks(db, idbUpgradeTrans);
            return getExistingVersion(db, trans, oldVersion)
                .then((oldVersion) => updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans))
                .catch(rejectTransaction);
        }
    });
}
function patchCurrentVersion(db, idbUpgradeTrans) {
    createMissingTables(db._dbSchema, idbUpgradeTrans);
    if (idbUpgradeTrans.db.version % 10 === 0 &&
        !idbUpgradeTrans.objectStoreNames.contains('$meta')) {
        idbUpgradeTrans.db
            .createObjectStore('$meta')
            .add(Math.ceil(idbUpgradeTrans.db.version / 10 - 1), 'version');
    }
    const globalSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
    adjustToExistingIndexNames(db, db._dbSchema, idbUpgradeTrans);
    const diff = getSchemaDiff(globalSchema, db._dbSchema);
    for (const tableChange of diff.change) {
        if (tableChange.change.length || tableChange.recreate) {
            console.warn(`Unable to patch indexes of table ${tableChange.name} because it has changes on the type of index or primary key.`);
            return;
        }
        const store = idbUpgradeTrans.objectStore(tableChange.name);
        tableChange.add.forEach((idx) => {
            if (debug)
                console.debug(`Dexie upgrade patch: Creating missing index ${tableChange.name}.${idx.src}`);
            addIndex(store, idx);
        });
    }
}
function getExistingVersion(db, trans, oldVersion) {
    if (trans.storeNames.includes('$meta')) {
        return trans
            .table('$meta')
            .get('version')
            .then((metaVersion) => {
            return metaVersion != null ? metaVersion : oldVersion;
        });
    }
    else {
        return DexiePromise.resolve(oldVersion);
    }
}
function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
    const queue = [];
    const versions = db._versions;
    let globalSchema = (db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans));
    const versToRun = versions.filter((v) => v._cfg.version >= oldVersion);
    if (versToRun.length === 0) {
        return DexiePromise.resolve();
    }
    versToRun.forEach((version) => {
        queue.push(() => {
            const oldSchema = globalSchema;
            const newSchema = version._cfg.dbschema;
            adjustToExistingIndexNames(db, oldSchema, idbUpgradeTrans);
            adjustToExistingIndexNames(db, newSchema, idbUpgradeTrans);
            globalSchema = db._dbSchema = newSchema;
            const diff = getSchemaDiff(oldSchema, newSchema);
            diff.add.forEach((tuple) => {
                createTable(idbUpgradeTrans, tuple[0], tuple[1].primKey, tuple[1].indexes);
            });
            diff.change.forEach((change) => {
                if (change.recreate) {
                    throw new exceptions.Upgrade('Not yet support for changing primary key');
                }
                else {
                    const store = idbUpgradeTrans.objectStore(change.name);
                    change.add.forEach((idx) => addIndex(store, idx));
                    change.change.forEach((idx) => {
                        store.deleteIndex(idx.name);
                        addIndex(store, idx);
                    });
                    change.del.forEach((idxName) => store.deleteIndex(idxName));
                }
            });
            const contentUpgrade = version._cfg.contentUpgrade;
            if (contentUpgrade && version._cfg.version > oldVersion) {
                generateMiddlewareStacks(db, idbUpgradeTrans);
                trans._memoizedTables = {};
                let upgradeSchema = shallowClone(newSchema);
                diff.del.forEach((table) => {
                    upgradeSchema[table] = oldSchema[table];
                });
                removeTablesApi(db, [db.Transaction.prototype]);
                setApiOnPlace(db, [db.Transaction.prototype], keys(upgradeSchema), upgradeSchema);
                trans.schema = upgradeSchema;
                const contentUpgradeIsAsync = isAsyncFunction(contentUpgrade);
                if (contentUpgradeIsAsync) {
                    incrementExpectedAwaits();
                }
                let returnValue;
                const promiseFollowed = DexiePromise.follow(() => {
                    returnValue = contentUpgrade(trans);
                    if (returnValue) {
                        if (contentUpgradeIsAsync) {
                            var decrementor = decrementExpectedAwaits.bind(null, null);
                            returnValue.then(decrementor, decrementor);
                        }
                    }
                });
                return returnValue && typeof returnValue.then === 'function'
                    ? DexiePromise.resolve(returnValue)
                    : promiseFollowed.then(() => returnValue);
            }
        });
        queue.push((idbtrans) => {
            const newSchema = version._cfg.dbschema;
            deleteRemovedTables(newSchema, idbtrans);
            removeTablesApi(db, [db.Transaction.prototype]);
            setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema);
            trans.schema = db._dbSchema;
        });
        queue.push((idbtrans) => {
            if (db.idbdb.objectStoreNames.contains('$meta')) {
                if (Math.ceil(db.idbdb.version / 10) === version._cfg.version) {
                    db.idbdb.deleteObjectStore('$meta');
                    delete db._dbSchema.$meta;
                    db._storeNames = db._storeNames.filter((name) => name !== '$meta');
                }
                else {
                    idbtrans.objectStore('$meta').put(version._cfg.version, 'version');
                }
            }
        });
    });
    function runQueue() {
        return queue.length
            ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue)
            : DexiePromise.resolve();
    }
    return runQueue().then(() => {
        createMissingTables(globalSchema, idbUpgradeTrans);
    });
}
function getSchemaDiff(oldSchema, newSchema) {
    const diff = {
        del: [],
        add: [],
        change: [],
    };
    let table;
    for (table in oldSchema) {
        if (!newSchema[table])
            diff.del.push(table);
    }
    for (table in newSchema) {
        const oldDef = oldSchema[table], newDef = newSchema[table];
        if (!oldDef) {
            diff.add.push([table, newDef]);
        }
        else {
            const change = {
                name: table,
                def: newDef,
                recreate: false,
                del: [],
                add: [],
                change: [],
            };
            if (
            '' + (oldDef.primKey.keyPath || '') !==
                '' + (newDef.primKey.keyPath || '') ||
                oldDef.primKey.auto !== newDef.primKey.auto) {
                change.recreate = true;
                diff.change.push(change);
            }
            else {
                const oldIndexes = oldDef.idxByName;
                const newIndexes = newDef.idxByName;
                let idxName;
                for (idxName in oldIndexes) {
                    if (!newIndexes[idxName])
                        change.del.push(idxName);
                }
                for (idxName in newIndexes) {
                    const oldIdx = oldIndexes[idxName], newIdx = newIndexes[idxName];
                    if (!oldIdx)
                        change.add.push(newIdx);
                    else if (oldIdx.src !== newIdx.src)
                        change.change.push(newIdx);
                }
                if (change.del.length > 0 ||
                    change.add.length > 0 ||
                    change.change.length > 0) {
                    diff.change.push(change);
                }
            }
        }
    }
    return diff;
}
function createTable(idbtrans, tableName, primKey, indexes) {
    const store = idbtrans.db.createObjectStore(tableName, primKey.keyPath
        ? { keyPath: primKey.keyPath, autoIncrement: primKey.auto }
        : { autoIncrement: primKey.auto });
    indexes.forEach((idx) => addIndex(store, idx));
    return store;
}
function createMissingTables(newSchema, idbtrans) {
    keys(newSchema).forEach((tableName) => {
        if (!idbtrans.db.objectStoreNames.contains(tableName)) {
            if (debug)
                console.debug('Dexie: Creating missing table', tableName);
            createTable(idbtrans, tableName, newSchema[tableName].primKey, newSchema[tableName].indexes);
        }
    });
}
function deleteRemovedTables(newSchema, idbtrans) {
    [].slice
        .call(idbtrans.db.objectStoreNames)
        .forEach((storeName) => newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName));
}
function addIndex(store, idx) {
    store.createIndex(idx.name, idx.keyPath, {
        unique: idx.unique,
        multiEntry: idx.multi,
    });
}
function buildGlobalSchema(db, idbdb, tmpTrans) {
    const globalSchema = {};
    const dbStoreNames = slice(idbdb.objectStoreNames, 0);
    dbStoreNames.forEach((storeName) => {
        const store = tmpTrans.objectStore(storeName);
        let keyPath = store.keyPath;
        const primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || '', true, false, !!store.autoIncrement, keyPath && typeof keyPath !== 'string', true);
        const indexes = [];
        for (let j = 0; j < store.indexNames.length; ++j) {
            const idbindex = store.index(store.indexNames[j]);
            keyPath = idbindex.keyPath;
            var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== 'string', false);
            indexes.push(index);
        }
        globalSchema[storeName] = createTableSchema(storeName, primKey, indexes);
    });
    return globalSchema;
}
function readGlobalSchema(db, idbdb, tmpTrans) {
    db.verno = idbdb.version / 10;
    const globalSchema = (db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans));
    db._storeNames = slice(idbdb.objectStoreNames, 0);
    setApiOnPlace(db, [db._allTables], keys(globalSchema), globalSchema);
}
function verifyInstalledSchema(db, tmpTrans) {
    const installedSchema = buildGlobalSchema(db, db.idbdb, tmpTrans);
    const diff = getSchemaDiff(installedSchema, db._dbSchema);
    return !(diff.add.length ||
        diff.change.some((ch) => ch.add.length || ch.change.length));
}
function adjustToExistingIndexNames(db, schema, idbtrans) {
    const storeNames = idbtrans.db.objectStoreNames;
    for (let i = 0; i < storeNames.length; ++i) {
        const storeName = storeNames[i];
        const store = idbtrans.objectStore(storeName);
        db._hasGetAll = 'getAll' in store;
        for (let j = 0; j < store.indexNames.length; ++j) {
            const indexName = store.indexNames[j];
            const keyPath = store.index(indexName).keyPath;
            const dexieName = typeof keyPath === 'string'
                ? keyPath
                : '[' + slice(keyPath).join('+') + ']';
            if (schema[storeName]) {
                const indexSpec = schema[storeName].idxByName[dexieName];
                if (indexSpec) {
                    indexSpec.name = indexName;
                    delete schema[storeName].idxByName[dexieName];
                    schema[storeName].idxByName[indexName] = indexSpec;
                }
            }
        }
    }
    if (typeof navigator !== 'undefined' &&
        /Safari/.test(navigator.userAgent) &&
        !/(Chrome\/|Edge\/)/.test(navigator.userAgent) &&
        _global.WorkerGlobalScope &&
        _global instanceof _global.WorkerGlobalScope &&
        [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) {
        db._hasGetAll = false;
    }
}
function parseIndexSyntax(primKeyAndIndexes) {
    return primKeyAndIndexes.split(',').map((index, indexNum) => {
        const typeSplit = index.split(':');
        const type = typeSplit[1]?.trim();
        index = typeSplit[0].trim();
        const name = index.replace(/([&*]|\+\+)/g, '');
        const keyPath = /^\[/.test(name)
            ? name.match(/^\[(.*)\]$/)[1].split('+')
            : name;
        return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0, type);
    });
}

class Version {
    _createTableSchema(name, primKey, indexes) {
        return createTableSchema(name, primKey, indexes);
    }
    _parseIndexSyntax(primKeyAndIndexes) {
        return parseIndexSyntax(primKeyAndIndexes);
    }
    _parseStoresSpec(stores, outSchema) {
        keys(stores).forEach((tableName) => {
            if (stores[tableName] !== null) {
                let indexes = this._parseIndexSyntax(stores[tableName]);
                const primKey = indexes.shift();
                if (!primKey) {
                    throw new exceptions.Schema('Invalid schema for table ' + tableName + ': ' + stores[tableName]);
                }
                primKey.unique = true;
                if (primKey.multi)
                    throw new exceptions.Schema('Primary key cannot be multiEntry*');
                indexes.forEach((idx) => {
                    if (idx.auto)
                        throw new exceptions.Schema('Only primary key can be marked as autoIncrement (++)');
                    if (!idx.keyPath)
                        throw new exceptions.Schema('Index must have a name and cannot be an empty string');
                });
                const tblSchema = this._createTableSchema(tableName, primKey, indexes);
                outSchema[tableName] = tblSchema;
            }
        });
    }
    stores(stores) {
        const db = this.db;
        this._cfg.storesSource = this._cfg.storesSource
            ? extend(this._cfg.storesSource, stores)
            : stores;
        const versions = db._versions;
        const storesSpec = {};
        let dbschema = {};
        versions.forEach((version) => {
            extend(storesSpec, version._cfg.storesSource);
            dbschema = version._cfg.dbschema = {};
            version._parseStoresSpec(storesSpec, dbschema);
        });
        db._dbSchema = dbschema;
        removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]);
        setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema);
        db._storeNames = keys(dbschema);
        return this;
    }
    upgrade(upgradeFunction) {
        this._cfg.contentUpgrade = promisableChain(this._cfg.contentUpgrade || nop, upgradeFunction);
        return this;
    }
}

function createVersionConstructor(db) {
    return makeClassConstructor(Version.prototype, function Version(versionNumber) {
        this.db = db;
        this._cfg = {
            version: versionNumber,
            storesSource: null,
            dbschema: {},
            tables: {},
            contentUpgrade: null,
        };
    });
}

const connections = createConnectionsManager();
function createConnectionsManager() {
    if (typeof FinalizationRegistry !== 'undefined' &&
        typeof WeakRef !== 'undefined') {
        const _refs = new Set();
        const _registry = new FinalizationRegistry((ref) => {
            _refs.delete(ref);
        });
        const toArray = () => {
            return Array.from(_refs)
                .map((ref) => ref.deref())
                .filter((db) => db !== undefined);
        };
        const add = (db) => {
            const ref = new WeakRef(db._novip);
            _refs.add(ref);
            _registry.register(db._novip, ref, ref);
            if (_refs.size > db._options.maxConnections) {
                const oldestRef = _refs.values().next().value;
                _refs.delete(oldestRef);
                _registry.unregister(oldestRef);
            }
        };
        const remove = (db) => {
            if (!db)
                return;
            const iterator = _refs.values();
            let result = iterator.next();
            while (!result.done) {
                const ref = result.value;
                if (ref.deref() === db._novip) {
                    _refs.delete(ref);
                    _registry.unregister(ref);
                    return;
                }
                result = iterator.next();
            }
        };
        return { toArray, add, remove };
    }
    else {
        const connections = [];
        const toArray = () => connections;
        const add = (db) => {
            connections.push(db._novip);
        };
        const remove = (db) => {
            if (!db)
                return;
            const index = connections.indexOf(db._novip);
            if (index !== -1) {
                connections.splice(index, 1);
            }
        };
        return { toArray, add, remove };
    }
}

function getDbNamesTable(indexedDB, IDBKeyRange) {
    let dbNamesDB = indexedDB['_dbNamesDB'];
    if (!dbNamesDB) {
        dbNamesDB = indexedDB['_dbNamesDB'] = new Dexie$1(DBNAMES_DB, {
            addons: [],
            indexedDB,
            IDBKeyRange,
        });
        dbNamesDB.version(1).stores({ dbnames: 'name' });
    }
    return dbNamesDB.table('dbnames');
}
function hasDatabasesNative(indexedDB) {
    return indexedDB && typeof indexedDB.databases === 'function';
}
function getDatabaseNames({ indexedDB, IDBKeyRange, }) {
    return hasDatabasesNative(indexedDB)
        ? Promise.resolve(indexedDB.databases()).then((infos) => infos
            .map((info) => info.name)
            .filter((name) => name !== DBNAMES_DB))
        : getDbNamesTable(indexedDB, IDBKeyRange).toCollection().primaryKeys();
}
function _onDatabaseCreated({ indexedDB, IDBKeyRange }, name) {
    !hasDatabasesNative(indexedDB) &&
        name !== DBNAMES_DB &&
        getDbNamesTable(indexedDB, IDBKeyRange).put({ name }).catch(nop);
}
function _onDatabaseDeleted({ indexedDB, IDBKeyRange }, name) {
    !hasDatabasesNative(indexedDB) &&
        name !== DBNAMES_DB &&
        getDbNamesTable(indexedDB, IDBKeyRange).delete(name).catch(nop);
}

function vip(fn) {
    return newScope(function () {
        PSD.letThrough = true;
        return fn();
    });
}

function idbReady() {
    var isSafari = !navigator.userAgentData &&
        /Safari\//.test(navigator.userAgent) &&
        !/Chrom(e|ium)\//.test(navigator.userAgent);
    if (!isSafari || !indexedDB.databases)
        return Promise.resolve();
    var intervalId;
    return new Promise(function (resolve) {
        var tryIdb = function () { return indexedDB.databases().finally(resolve); };
        intervalId = setInterval(tryIdb, 100);
        tryIdb();
    }).finally(function () { return clearInterval(intervalId); });
}

function isEmptyRange(node) {
    return !('from' in node);
}
const RangeSet = function (fromOrTree, to) {
    if (this) {
        extend(this, arguments.length
            ? { d: 1, from: fromOrTree, to: arguments.length > 1 ? to : fromOrTree }
            : { d: 0 });
    }
    else {
        const rv = new RangeSet();
        if (fromOrTree && 'd' in fromOrTree) {
            extend(rv, fromOrTree);
        }
        return rv;
    }
};
props(RangeSet.prototype, {
    add(rangeSet) {
        mergeRanges(this, rangeSet);
        return this;
    },
    addKey(key) {
        addRange(this, key, key);
        return this;
    },
    addKeys(keys) {
        keys.forEach((key) => addRange(this, key, key));
        return this;
    },
    hasKey(key) {
        const node = getRangeSetIterator(this).next(key).value;
        return node && cmp(node.from, key) <= 0 && cmp(node.to, key) >= 0;
    },
    [iteratorSymbol]() {
        return getRangeSetIterator(this);
    },
});
function addRange(target, from, to) {
    const diff = cmp(from, to);
    if (isNaN(diff))
        return;
    if (diff > 0)
        throw RangeError();
    if (isEmptyRange(target))
        return extend(target, { from, to, d: 1 });
    const left = target.l;
    const right = target.r;
    if (cmp(to, target.from) < 0) {
        left
            ? addRange(left, from, to)
            : (target.l = { from, to, d: 1, l: null, r: null });
        return rebalance(target);
    }
    if (cmp(from, target.to) > 0) {
        right
            ? addRange(right, from, to)
            : (target.r = { from, to, d: 1, l: null, r: null });
        return rebalance(target);
    }
    if (cmp(from, target.from) < 0) {
        target.from = from;
        target.l = null;
        target.d = right ? right.d + 1 : 1;
    }
    if (cmp(to, target.to) > 0) {
        target.to = to;
        target.r = null;
        target.d = target.l ? target.l.d + 1 : 1;
    }
    const rightWasCutOff = !target.r;
    if (left && !target.l) {
        mergeRanges(target, left);
    }
    if (right && rightWasCutOff) {
        mergeRanges(target, right);
    }
}
function mergeRanges(target, newSet) {
    function _addRangeSet(target, { from, to, l, r, }) {
        addRange(target, from, to);
        if (l)
            _addRangeSet(target, l);
        if (r)
            _addRangeSet(target, r);
    }
    if (!isEmptyRange(newSet))
        _addRangeSet(target, newSet);
}
function rangesOverlap(rangeSet1, rangeSet2) {
    const i1 = getRangeSetIterator(rangeSet2);
    let nextResult1 = i1.next();
    if (nextResult1.done)
        return false;
    let a = nextResult1.value;
    const i2 = getRangeSetIterator(rangeSet1);
    let nextResult2 = i2.next(a.from);
    let b = nextResult2.value;
    while (!nextResult1.done && !nextResult2.done) {
        if (cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0)
            return true;
        cmp(a.from, b.from) < 0
            ? (a = (nextResult1 = i1.next(b.from)).value)
            : (b = (nextResult2 = i2.next(a.from)).value);
    }
    return false;
}
function getRangeSetIterator(node) {
    let state = isEmptyRange(node)
        ? null
        : { s: 0, n: node };
    return {
        next(key) {
            const keyProvided = arguments.length > 0;
            while (state) {
                switch (state.s) {
                    case 0:
                        state.s = 1;
                        if (keyProvided) {
                            while (state.n.l && cmp(key, state.n.from) < 0)
                                state = { up: state, n: state.n.l, s: 1 };
                        }
                        else {
                            while (state.n.l)
                                state = { up: state, n: state.n.l, s: 1 };
                        }
                    case 1:
                        state.s = 2;
                        if (!keyProvided || cmp(key, state.n.to) <= 0)
                            return { value: state.n, done: false };
                    case 2:
                        if (state.n.r) {
                            state.s = 3;
                            state = { up: state, n: state.n.r, s: 0 };
                            continue;
                        }
                    case 3:
                        state = state.up;
                }
            }
            return { done: true };
        },
    };
}
function rebalance(target) {
    const diff = (target.r?.d || 0) - (target.l?.d || 0);
    const r = diff > 1 ? 'r' : diff < -1 ? 'l' : '';
    if (r) {
        const l = r === 'r' ? 'l' : 'r';
        const rootClone = { ...target };
        const oldRootRight = target[r];
        target.from = oldRootRight.from;
        target.to = oldRootRight.to;
        target[r] = oldRootRight[r];
        rootClone[r] = oldRootRight[l];
        target[l] = rootClone;
        rootClone.d = computeDepth(rootClone);
    }
    target.d = computeDepth(target);
}
function computeDepth({ r, l }) {
    return (r ? (l ? Math.max(r.d, l.d) : r.d) : l ? l.d : 0) + 1;
}

function extendObservabilitySet(target, newSet) {
    keys(newSet).forEach((part) => {
        if (target[part])
            mergeRanges(target[part], newSet[part]);
        else
            target[part] = cloneSimpleObjectTree(newSet[part]);
    });
    return target;
}

function obsSetsOverlap(os1, os2) {
    return (os1.all ||
        os2.all ||
        Object.keys(os1).some((key) => os2[key] && rangesOverlap(os2[key], os1[key])));
}

const cache = {};

let unsignaledParts = {};
let isTaskEnqueued = false;
function signalSubscribersLazily(part, optimistic = false) {
    extendObservabilitySet(unsignaledParts, part);
    if (!isTaskEnqueued) {
        isTaskEnqueued = true;
        setTimeout(() => {
            isTaskEnqueued = false;
            const parts = unsignaledParts;
            unsignaledParts = {};
            signalSubscribersNow(parts, false);
        }, 0);
    }
}
function signalSubscribersNow(updatedParts, deleteAffectedCacheEntries = false) {
    const queriesToSignal = new Set();
    if (updatedParts.all) {
        for (const tblCache of Object.values(cache)) {
            collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
        }
    }
    else {
        for (const key in updatedParts) {
            const parts = /^idb\:\/\/(.*)\/(.*)\//.exec(key);
            if (parts) {
                const [, dbName, tableName] = parts;
                const tblCache = cache[`idb://${dbName}/${tableName}`];
                if (tblCache)
                    collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
            }
        }
    }
    queriesToSignal.forEach((requery) => requery());
}
function collectTableSubscribers(tblCache, updatedParts, outQueriesToSignal, deleteAffectedCacheEntries) {
    const updatedEntryLists = [];
    for (const [indexName, entries] of Object.entries(tblCache.queries.query)) {
        const filteredEntries = [];
        for (const entry of entries) {
            if (obsSetsOverlap(updatedParts, entry.obsSet)) {
                entry.subscribers.forEach((requery) => outQueriesToSignal.add(requery));
            }
            else if (deleteAffectedCacheEntries) {
                filteredEntries.push(entry);
            }
        }
        if (deleteAffectedCacheEntries)
            updatedEntryLists.push([indexName, filteredEntries]);
    }
    if (deleteAffectedCacheEntries) {
        for (const [indexName, filteredEntries] of updatedEntryLists) {
            tblCache.queries.query[indexName] = filteredEntries;
        }
    }
}

function dexieOpen(db) {
    const state = db._state;
    const { indexedDB } = db._deps;
    if (state.isBeingOpened || db.idbdb)
        return state.dbReadyPromise.then(() => state.dbOpenError ? rejection(state.dbOpenError) : db);
    state.isBeingOpened = true;
    state.dbOpenError = null;
    state.openComplete = false;
    const openCanceller = state.openCanceller;
    let nativeVerToOpen = Math.round(db.verno * 10);
    let schemaPatchMode = false;
    function throwIfCancelled() {
        if (state.openCanceller !== openCanceller)
            throw new exceptions.DatabaseClosed('db.open() was cancelled');
    }
    let resolveDbReady = state.dbReadyResolve,
    upgradeTransaction = null, wasCreated = false;
    const tryOpenDB = () => new DexiePromise((resolve, reject) => {
        throwIfCancelled();
        if (!indexedDB)
            throw new exceptions.MissingAPI();
        const dbName = db.name;
        const req = state.autoSchema || !nativeVerToOpen
            ? indexedDB.open(dbName)
            : indexedDB.open(dbName, nativeVerToOpen);
        if (!req)
            throw new exceptions.MissingAPI();
        req.onerror = eventRejectHandler(reject);
        req.onblocked = wrap(db._fireOnBlocked);
        req.onupgradeneeded = wrap((e) => {
            upgradeTransaction = req.transaction;
            if (state.autoSchema && !db._options.allowEmptyDB) {
                req.onerror = preventDefault;
                upgradeTransaction.abort();
                req.result.close();
                const delreq = indexedDB.deleteDatabase(dbName);
                delreq.onsuccess = delreq.onerror = wrap(() => {
                    reject(new exceptions.NoSuchDatabase(`Database ${dbName} doesnt exist`));
                });
            }
            else {
                upgradeTransaction.onerror = eventRejectHandler(reject);
                const oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
                wasCreated = oldVer < 1;
                db.idbdb = req.result;
                if (schemaPatchMode) {
                    patchCurrentVersion(db, upgradeTransaction);
                }
                runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
            }
        }, reject);
        req.onsuccess = wrap(() => {
            upgradeTransaction = null;
            const idbdb = (db.idbdb = req.result);
            const objectStoreNames = slice(idbdb.objectStoreNames);
            if (objectStoreNames.length > 0)
                try {
                    const tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), 'readonly');
                    if (state.autoSchema)
                        readGlobalSchema(db, idbdb, tmpTrans);
                    else {
                        adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
                        if (!verifyInstalledSchema(db, tmpTrans) && !schemaPatchMode) {
                            console.warn(`Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Dexie will add missing parts and increment native version number to workaround this.`);
                            idbdb.close();
                            nativeVerToOpen = idbdb.version + 1;
                            schemaPatchMode = true;
                            return resolve(tryOpenDB());
                        }
                    }
                    generateMiddlewareStacks(db, tmpTrans);
                }
                catch (e) {
                }
            connections.add(db);
            idbdb.onversionchange = wrap((ev) => {
                state.vcFired = true;
                db.on('versionchange').fire(ev);
            });
            idbdb.onclose = wrap(() => {
                db.close({ disableAutoOpen: false });
            });
            if (wasCreated)
                _onDatabaseCreated(db._deps, dbName);
            resolve();
        }, reject);
    }).catch((err) => {
        switch (err?.name) {
            case 'UnknownError':
                if (state.PR1398_maxLoop > 0) {
                    state.PR1398_maxLoop--;
                    console.warn('Dexie: Workaround for Chrome UnknownError on open()');
                    return tryOpenDB();
                }
                break;
            case 'VersionError':
                if (nativeVerToOpen > 0) {
                    nativeVerToOpen = 0;
                    return tryOpenDB();
                }
                break;
        }
        return DexiePromise.reject(err);
    });
    return DexiePromise.race([
        openCanceller,
        (typeof navigator === 'undefined'
            ? DexiePromise.resolve()
            : idbReady()).then(tryOpenDB),
    ])
        .then(() => {
        throwIfCancelled();
        state.onReadyBeingFired = [];
        return DexiePromise.resolve(vip(() => db.on.ready.fire(db.vip))).then(function fireRemainders() {
            if (state.onReadyBeingFired.length > 0) {
                let remainders = state.onReadyBeingFired.reduce(promisableChain, nop);
                state.onReadyBeingFired = [];
                return DexiePromise.resolve(vip(() => remainders(db.vip))).then(fireRemainders);
            }
        });
    })
        .finally(() => {
        if (state.openCanceller === openCanceller) {
            state.onReadyBeingFired = null;
            state.isBeingOpened = false;
        }
    })
        .catch((err) => {
        state.dbOpenError = err;
        try {
            upgradeTransaction && upgradeTransaction.abort();
        }
        catch { }
        if (openCanceller === state.openCanceller) {
            db._close();
        }
        return rejection(err);
    })
        .finally(() => {
        state.openComplete = true;
        resolveDbReady();
    })
        .then(() => {
        if (wasCreated) {
            const everything = {};
            db.tables.forEach((table) => {
                table.schema.indexes.forEach((idx) => {
                    if (idx.name)
                        everything[`idb://${db.name}/${table.name}/${idx.name}`] =
                            new RangeSet(-Infinity, [[[]]]);
                });
                everything[`idb://${db.name}/${table.name}/`] = everything[`idb://${db.name}/${table.name}/:dels`] = new RangeSet(-Infinity, [[[]]]);
            });
            globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME).fire(everything);
            signalSubscribersNow(everything, true);
        }
        return db;
    });
}

function awaitIterator(iterator) {
    var callNext = (result) => iterator.next(result), doThrow = (error) => iterator.throw(error), onSuccess = step(callNext), onError = step(doThrow);
    function step(getNext) {
        return (val) => {
            var next = getNext(val), value = next.value;
            return next.done
                ? value
                : !value || typeof value.then !== 'function'
                    ? isArray(value)
                        ? Promise.all(value).then(onSuccess, onError)
                        : onSuccess(value)
                    : value.then(onSuccess, onError);
        };
    }
    return step(callNext)();
}

function extractTransactionArgs(mode, _tableArgs_, scopeFunc) {
    var i = arguments.length;
    if (i < 2)
        throw new exceptions.InvalidArgument('Too few arguments');
    var args = new Array(i - 1);
    while (--i)
        args[i - 1] = arguments[i];
    scopeFunc = args.pop();
    var tables = flatten(args);
    return [mode, tables, scopeFunc];
}
function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFunc) {
    return DexiePromise.resolve().then(() => {
        const transless = PSD.transless || PSD;
        const trans = db._createTransaction(mode, storeNames, db._dbSchema, parentTransaction);
        trans.explicit = true;
        const zoneProps = {
            trans: trans,
            transless: transless,
        };
        if (parentTransaction) {
            trans.idbtrans = parentTransaction.idbtrans;
        }
        else {
            try {
                trans.create();
                trans.idbtrans._explicit = true;
                db._state.PR1398_maxLoop = 3;
            }
            catch (ex) {
                if (ex.name === errnames.InvalidState &&
                    db.isOpen() &&
                    --db._state.PR1398_maxLoop > 0) {
                    console.warn('Dexie: Need to reopen db');
                    db.close({ disableAutoOpen: false });
                    return db
                        .open()
                        .then(() => enterTransactionScope(db, mode, storeNames, null, scopeFunc));
                }
                return rejection(ex);
            }
        }
        const scopeFuncIsAsync = isAsyncFunction(scopeFunc);
        if (scopeFuncIsAsync) {
            incrementExpectedAwaits();
        }
        let returnValue;
        const promiseFollowed = DexiePromise.follow(() => {
            returnValue = scopeFunc.call(trans, trans);
            if (returnValue) {
                if (scopeFuncIsAsync) {
                    var decrementor = decrementExpectedAwaits.bind(null, null);
                    returnValue.then(decrementor, decrementor);
                }
                else if (typeof returnValue.next === 'function' &&
                    typeof returnValue.throw === 'function') {
                    returnValue = awaitIterator(returnValue);
                }
            }
        }, zoneProps);
        return (returnValue && typeof returnValue.then === 'function'
            ?
                DexiePromise.resolve(returnValue).then((x) => trans.active
                    ? x
                    : rejection(new exceptions.PrematureCommit('Transaction committed too early. See http://bit.ly/2kdckMn')))
            :
                promiseFollowed.then(() => returnValue))
            .then((x) => {
            if (parentTransaction)
                trans._resolve();
            return trans._completion.then(() => x);
        })
            .catch((e) => {
            trans._reject(e);
            return rejection(e);
        });
    });
}

function pad(a, value, count) {
    const result = isArray(a) ? a.slice() : [a];
    for (let i = 0; i < count; ++i)
        result.push(value);
    return result;
}
function createVirtualIndexMiddleware(down) {
    return {
        ...down,
        table(tableName) {
            const table = down.table(tableName);
            const { schema } = table;
            const indexLookup = {};
            const allVirtualIndexes = [];
            function addVirtualIndexes(keyPath, keyTail, lowLevelIndex) {
                const keyPathAlias = getKeyPathAlias(keyPath);
                const indexList = (indexLookup[keyPathAlias] =
                    indexLookup[keyPathAlias] || []);
                const keyLength = keyPath == null
                    ? 0
                    : typeof keyPath === 'string'
                        ? 1
                        : keyPath.length;
                const isVirtual = keyTail > 0;
                const virtualIndex = {
                    ...lowLevelIndex,
                    name: isVirtual
                        ? `${keyPathAlias}(virtual-from:${lowLevelIndex.name})`
                        : lowLevelIndex.name,
                    lowLevelIndex,
                    isVirtual,
                    keyTail,
                    keyLength,
                    extractKey: getKeyExtractor(keyPath),
                    unique: !isVirtual && lowLevelIndex.unique,
                };
                indexList.push(virtualIndex);
                if (!virtualIndex.isPrimaryKey) {
                    allVirtualIndexes.push(virtualIndex);
                }
                if (keyLength > 1) {
                    const virtualKeyPath = keyLength === 2
                        ? keyPath[0]
                        : keyPath.slice(0, keyLength - 1);
                    addVirtualIndexes(virtualKeyPath, keyTail + 1, lowLevelIndex);
                }
                indexList.sort((a, b) => a.keyTail - b.keyTail);
                return virtualIndex;
            }
            const primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey);
            indexLookup[':id'] = [primaryKey];
            for (const index of schema.indexes) {
                addVirtualIndexes(index.keyPath, 0, index);
            }
            function findBestIndex(keyPath) {
                const result = indexLookup[getKeyPathAlias(keyPath)];
                return result && result[0];
            }
            function translateRange(range, keyTail) {
                return {
                    type: range.type === 1
                        ? 2
                        : range.type,
                    lower: pad(range.lower, range.lowerOpen ? down.MAX_KEY : down.MIN_KEY, keyTail),
                    lowerOpen: true,
                    upper: pad(range.upper, range.upperOpen ? down.MIN_KEY : down.MAX_KEY, keyTail),
                    upperOpen: true,
                };
            }
            function translateRequest(req) {
                const index = req.query.index;
                return index.isVirtual
                    ? {
                        ...req,
                        query: {
                            index: index.lowLevelIndex,
                            range: translateRange(req.query.range, index.keyTail),
                        },
                    }
                    : req;
            }
            const result = {
                ...table,
                schema: {
                    ...schema,
                    primaryKey,
                    indexes: allVirtualIndexes,
                    getIndexByKeyPath: findBestIndex,
                },
                count(req) {
                    return table.count(translateRequest(req));
                },
                query(req) {
                    return table.query(translateRequest(req));
                },
                openCursor(req) {
                    const { keyTail, isVirtual, keyLength } = req.query
                        .index;
                    if (!isVirtual)
                        return table.openCursor(req);
                    function createVirtualCursor(cursor) {
                        function _continue(key) {
                            key != null
                                ? cursor.continue(pad(key, req.reverse ? down.MAX_KEY : down.MIN_KEY, keyTail))
                                : req.unique
                                    ? cursor.continue(cursor.key
                                        .slice(0, keyLength)
                                        .concat(req.reverse ? down.MIN_KEY : down.MAX_KEY, keyTail))
                                    : cursor.continue();
                        }
                        const virtualCursor = Object.create(cursor, {
                            continue: { value: _continue },
                            continuePrimaryKey: {
                                value(key, primaryKey) {
                                    cursor.continuePrimaryKey(pad(key, down.MAX_KEY, keyTail), primaryKey);
                                },
                            },
                            primaryKey: {
                                get() {
                                    return cursor.primaryKey;
                                },
                            },
                            key: {
                                get() {
                                    const key = cursor.key;
                                    return keyLength === 1
                                        ? key[0]
                                        : key.slice(0, keyLength);
                                },
                            },
                            value: {
                                get() {
                                    return cursor.value;
                                },
                            },
                        });
                        return virtualCursor;
                    }
                    return table
                        .openCursor(translateRequest(req))
                        .then((cursor) => cursor && createVirtualCursor(cursor));
                },
            };
            return result;
        },
    };
}
const virtualIndexMiddleware = {
    stack: 'dbcore',
    name: 'VirtualIndexMiddleware',
    level: 1,
    create: createVirtualIndexMiddleware,
};

function getObjectDiff(a, b, rv, prfx) {
    rv = rv || {};
    prfx = prfx || '';
    keys(a).forEach((prop) => {
        if (!hasOwn(b, prop)) {
            rv[prfx + prop] = undefined;
        }
        else {
            var ap = a[prop], bp = b[prop];
            if (typeof ap === 'object' && typeof bp === 'object' && ap && bp) {
                const apTypeName = toStringTag(ap);
                const bpTypeName = toStringTag(bp);
                if (apTypeName !== bpTypeName) {
                    rv[prfx + prop] = b[prop];
                }
                else if (apTypeName === 'Object') {
                    getObjectDiff(ap, bp, rv, prfx + prop + '.');
                }
                else if (ap !== bp) {
                    rv[prfx + prop] = b[prop];
                }
            }
            else if (ap !== bp)
                rv[prfx + prop] = b[prop];
        }
    });
    keys(b).forEach((prop) => {
        if (!hasOwn(a, prop)) {
            rv[prfx + prop] = b[prop];
        }
    });
    return rv;
}

function getEffectiveKeys(primaryKey, req) {
    if (req.type === 'delete')
        return req.keys;
    return req.keys || req.values.map(primaryKey.extractKey);
}

const hooksMiddleware = {
    stack: 'dbcore',
    name: 'HooksMiddleware',
    level: 2,
    create: (downCore) => ({
        ...downCore,
        table(tableName) {
            const downTable = downCore.table(tableName);
            const { primaryKey } = downTable.schema;
            const tableMiddleware = {
                ...downTable,
                mutate(req) {
                    const dxTrans = PSD.trans;
                    const { deleting, creating, updating } = dxTrans.table(tableName).hook;
                    switch (req.type) {
                        case 'add':
                            if (creating.fire === nop)
                                break;
                            return dxTrans._promise('readwrite', () => addPutOrDelete(req), true);
                        case 'put':
                            if (creating.fire === nop && updating.fire === nop)
                                break;
                            return dxTrans._promise('readwrite', () => addPutOrDelete(req), true);
                        case 'delete':
                            if (deleting.fire === nop)
                                break;
                            return dxTrans._promise('readwrite', () => addPutOrDelete(req), true);
                        case 'deleteRange':
                            if (deleting.fire === nop)
                                break;
                            return dxTrans._promise('readwrite', () => deleteRange(req), true);
                    }
                    return downTable.mutate(req);
                    function addPutOrDelete(req) {
                        const dxTrans = PSD.trans;
                        const keys = req.keys || getEffectiveKeys(primaryKey, req);
                        if (!keys)
                            throw new Error('Keys missing');
                        req =
                            req.type === 'add' || req.type === 'put'
                                ? { ...req, keys }
                                : { ...req };
                        if (req.type !== 'delete')
                            req.values = [...req.values];
                        if (req.keys)
                            req.keys = [...req.keys];
                        return getExistingValues(downTable, req, keys).then((existingValues) => {
                            const contexts = keys.map((key, i) => {
                                const existingValue = existingValues[i];
                                const ctx = { onerror: null, onsuccess: null };
                                if (req.type === 'delete') {
                                    deleting.fire.call(ctx, key, existingValue, dxTrans);
                                }
                                else if (req.type === 'add' ||
                                    existingValue === undefined) {
                                    const generatedPrimaryKey = creating.fire.call(ctx, key, req.values[i], dxTrans);
                                    if (key == null && generatedPrimaryKey != null) {
                                        key = generatedPrimaryKey;
                                        req.keys[i] = key;
                                        if (!primaryKey.outbound) {
                                            setByKeyPath(req.values[i], primaryKey.keyPath, key);
                                        }
                                    }
                                }
                                else {
                                    const objectDiff = getObjectDiff(existingValue, req.values[i]);
                                    const additionalChanges = updating.fire.call(ctx, objectDiff, key, existingValue, dxTrans);
                                    if (additionalChanges) {
                                        const requestedValue = req.values[i];
                                        Object.keys(additionalChanges).forEach((keyPath) => {
                                            if (hasOwn(requestedValue, keyPath)) {
                                                requestedValue[keyPath] =
                                                    additionalChanges[keyPath];
                                            }
                                            else {
                                                setByKeyPath(requestedValue, keyPath, additionalChanges[keyPath]);
                                            }
                                        });
                                    }
                                }
                                return ctx;
                            });
                            return downTable
                                .mutate(req)
                                .then(({ failures, results, numFailures, lastResult }) => {
                                for (let i = 0; i < keys.length; ++i) {
                                    const primKey = results ? results[i] : keys[i];
                                    const ctx = contexts[i];
                                    if (primKey == null) {
                                        ctx.onerror && ctx.onerror(failures[i]);
                                    }
                                    else {
                                        ctx.onsuccess &&
                                            ctx.onsuccess(req.type === 'put' && existingValues[i]
                                                ? req.values[i]
                                                : primKey
                                            );
                                    }
                                }
                                return { failures, results, numFailures, lastResult };
                            })
                                .catch((error) => {
                                contexts.forEach((ctx) => ctx.onerror && ctx.onerror(error));
                                return Promise.reject(error);
                            });
                        });
                    }
                    function deleteRange(req) {
                        return deleteNextChunk(req.trans, req.range, 10000);
                    }
                    function deleteNextChunk(trans, range, limit) {
                        return downTable
                            .query({
                            trans,
                            values: false,
                            query: { index: primaryKey, range },
                            limit,
                        })
                            .then(({ result }) => {
                            return addPutOrDelete({
                                type: 'delete',
                                keys: result,
                                trans,
                            }).then((res) => {
                                if (res.numFailures > 0)
                                    return Promise.reject(res.failures[0]);
                                if (result.length < limit) {
                                    return {
                                        failures: [],
                                        numFailures: 0,
                                        lastResult: undefined,
                                    };
                                }
                                else {
                                    return deleteNextChunk(trans, {
                                        ...range,
                                        lower: result[result.length - 1],
                                        lowerOpen: true,
                                    }, limit);
                                }
                            });
                        });
                    }
                },
            };
            return tableMiddleware;
        },
    }),
};
function getExistingValues(table, req, effectiveKeys) {
    return req.type === 'add'
        ? Promise.resolve([])
        : table.getMany({
            trans: req.trans,
            keys: effectiveKeys,
            cache: 'immutable',
        });
}

function getFromTransactionCache(keys, cache, clone) {
    try {
        if (!cache)
            return null;
        if (cache.keys.length < keys.length)
            return null;
        const result = [];
        for (let i = 0, j = 0; i < cache.keys.length && j < keys.length; ++i) {
            if (cmp(cache.keys[i], keys[j]) !== 0)
                continue;
            result.push(clone ? deepClone(cache.values[i]) : cache.values[i]);
            ++j;
        }
        return result.length === keys.length ? result : null;
    }
    catch {
        return null;
    }
}
const cacheExistingValuesMiddleware = {
    stack: 'dbcore',
    level: -1,
    create: (core) => {
        return {
            table: (tableName) => {
                const table = core.table(tableName);
                return {
                    ...table,
                    getMany: (req) => {
                        if (!req.cache) {
                            return table.getMany(req);
                        }
                        const cachedResult = getFromTransactionCache(req.keys, req.trans['_cache'], req.cache === 'clone');
                        if (cachedResult) {
                            return DexiePromise.resolve(cachedResult);
                        }
                        return table.getMany(req).then((res) => {
                            req.trans['_cache'] = {
                                keys: req.keys,
                                values: req.cache === 'clone' ? deepClone(res) : res,
                            };
                            return res;
                        });
                    },
                    mutate: (req) => {
                        if (req.type !== 'add')
                            req.trans['_cache'] = null;
                        return table.mutate(req);
                    },
                };
            },
        };
    },
};

function isCachableContext(ctx, table) {
    return (ctx.trans.mode === 'readonly' &&
        !!ctx.subscr &&
        !ctx.trans.explicit &&
        ctx.trans.db._options.cache !== 'disabled' &&
        !table.schema.primaryKey.outbound);
}

function isCachableRequest(type, req) {
    switch (type) {
        case 'query':
            return req.values && !req.unique;
        case 'get':
            return false;
        case 'getMany':
            return false;
        case 'count':
            return false;
        case 'openCursor':
            return false;
    }
}

const observabilityMiddleware = {
    stack: 'dbcore',
    level: 0,
    name: 'Observability',
    create: (core) => {
        const dbName = core.schema.name;
        const FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY);
        return {
            ...core,
            transaction: (stores, mode, options) => {
                if (PSD.subscr && mode !== 'readonly') {
                    throw new exceptions.ReadOnly(`Readwrite transaction in liveQuery context. Querier source: ${PSD.querier}`);
                }
                return core.transaction(stores, mode, options);
            },
            table: (tableName) => {
                const table = core.table(tableName);
                const { schema } = table;
                const { primaryKey, indexes } = schema;
                const { extractKey, outbound } = primaryKey;
                const indexesWithAutoIncPK = primaryKey.autoIncrement &&
                    indexes.filter((index) => index.compound &&
                        index.keyPath.includes(primaryKey.keyPath));
                const tableClone = {
                    ...table,
                    mutate: (req) => {
                        const trans = req.trans;
                        const mutatedParts = req.mutatedParts || (req.mutatedParts = {});
                        const getRangeSet = (indexName) => {
                            const part = `idb://${dbName}/${tableName}/${indexName}`;
                            return (mutatedParts[part] ||
                                (mutatedParts[part] = new RangeSet()));
                        };
                        const pkRangeSet = getRangeSet('');
                        const delsRangeSet = getRangeSet(':dels');
                        const { type } = req;
                        let [keys, newObjs] = req.type === 'deleteRange'
                            ? [req.range]
                            : req.type === 'delete'
                                ? [req.keys]
                                : req.values.length < 50
                                    ? [
                                        getEffectiveKeys(primaryKey, req).filter((id) => id),
                                        req.values,
                                    ]
                                    : [];
                        const oldCache = req.trans['_cache'];
                        if (isArray(keys)) {
                            pkRangeSet.addKeys(keys);
                            const oldObjs = type === 'delete' || keys.length === newObjs.length
                                ? getFromTransactionCache(keys, oldCache)
                                : null;
                            if (!oldObjs) {
                                delsRangeSet.addKeys(keys);
                            }
                            if (oldObjs || newObjs) {
                                trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs);
                            }
                        }
                        else if (keys) {
                            const range = {
                                from: keys.lower ?? core.MIN_KEY,
                                to: keys.upper ?? core.MAX_KEY,
                            };
                            delsRangeSet.add(range);
                            pkRangeSet.add(range);
                        }
                        else {
                            pkRangeSet.add(FULL_RANGE);
                            delsRangeSet.add(FULL_RANGE);
                            schema.indexes.forEach((idx) => getRangeSet(idx.name).add(FULL_RANGE));
                        }
                        return table.mutate(req).then((res) => {
                            if (keys && (req.type === 'add' || req.type === 'put')) {
                                pkRangeSet.addKeys(res.results);
                                if (indexesWithAutoIncPK) {
                                    indexesWithAutoIncPK.forEach((idx) => {
                                        const idxVals = req.values.map((v) => idx.extractKey(v));
                                        const pkPos = idx.keyPath.findIndex((prop) => prop === primaryKey.keyPath);
                                        for (let i = 0, len = res.results.length; i < len; ++i) {
                                            idxVals[i][pkPos] = res.results[i];
                                        }
                                        getRangeSet(idx.name).addKeys(idxVals);
                                    });
                                }
                            }
                            trans.mutatedParts = extendObservabilitySet(trans.mutatedParts || {}, mutatedParts);
                            return res;
                        });
                    },
                };
                const getRange = ({ query: { index, range }, }) => [
                    index,
                    new RangeSet(range.lower ?? core.MIN_KEY, range.upper ?? core.MAX_KEY),
                ];
                const readSubscribers = {
                    get: (req) => [primaryKey, new RangeSet(req.key)],
                    getMany: (req) => [primaryKey, new RangeSet().addKeys(req.keys)],
                    count: getRange,
                    query: getRange,
                    openCursor: getRange,
                };
                keys(readSubscribers).forEach((method) => {
                    tableClone[method] = function (req) {
                        const { subscr } = PSD;
                        const isLiveQuery = !!subscr;
                        let cachable = isCachableContext(PSD, table) &&
                            isCachableRequest(method, req);
                        const obsSet = cachable
                            ? (req.obsSet = {})
                            : subscr;
                        if (isLiveQuery) {
                            const getRangeSet = (indexName) => {
                                const part = `idb://${dbName}/${tableName}/${indexName}`;
                                return (obsSet[part] ||
                                    (obsSet[part] = new RangeSet()));
                            };
                            const pkRangeSet = getRangeSet('');
                            const delsRangeSet = getRangeSet(':dels');
                            const [queriedIndex, queriedRanges] = readSubscribers[method](req);
                            if (method === 'query' &&
                                queriedIndex.isPrimaryKey &&
                                !req.values) {
                                delsRangeSet.add(queriedRanges);
                            }
                            else {
                                getRangeSet(queriedIndex.name || '').add(queriedRanges);
                            }
                            if (!queriedIndex.isPrimaryKey) {
                                if (method === 'count') {
                                    delsRangeSet.add(FULL_RANGE);
                                }
                                else {
                                    const keysPromise = method === 'query' &&
                                        outbound &&
                                        req.values &&
                                        table.query({
                                            ...req,
                                            values: false,
                                        });
                                    return table[method].apply(this, arguments).then((res) => {
                                        if (method === 'query') {
                                            if (outbound && req.values) {
                                                return keysPromise.then(({ result: resultingKeys, }) => {
                                                    pkRangeSet.addKeys(resultingKeys);
                                                    return res;
                                                });
                                            }
                                            const pKeys = req.values
                                                ? res.result.map(extractKey)
                                                : res.result;
                                            if (req.values) {
                                                pkRangeSet.addKeys(pKeys);
                                            }
                                            else {
                                                delsRangeSet.addKeys(pKeys);
                                            }
                                        }
                                        else if (method === 'openCursor') {
                                            const cursor = res;
                                            const wantValues = req
                                                .values;
                                            return (cursor &&
                                                Object.create(cursor, {
                                                    key: {
                                                        get() {
                                                            delsRangeSet.addKey(cursor.primaryKey);
                                                            return cursor.key;
                                                        },
                                                    },
                                                    primaryKey: {
                                                        get() {
                                                            const pkey = cursor.primaryKey;
                                                            delsRangeSet.addKey(pkey);
                                                            return pkey;
                                                        },
                                                    },
                                                    value: {
                                                        get() {
                                                            wantValues &&
                                                                pkRangeSet.addKey(cursor.primaryKey);
                                                            return cursor.value;
                                                        },
                                                    },
                                                }));
                                        }
                                        return res;
                                    });
                                }
                            }
                        }
                        return table[method].apply(this, arguments);
                    };
                });
                return tableClone;
            },
        };
    },
};
function trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs) {
    function addAffectedIndex(ix) {
        const rangeSet = getRangeSet(ix.name || '');
        function extractKey(obj) {
            return obj != null ? ix.extractKey(obj) : null;
        }
        const addKeyOrKeys = (key) => ix.multiEntry && isArray(key)
            ?
                key.forEach((key) => rangeSet.addKey(key))
            :
                rangeSet.addKey(key);
        (oldObjs || newObjs).forEach((_, i) => {
            const oldKey = oldObjs && extractKey(oldObjs[i]);
            const newKey = newObjs && extractKey(newObjs[i]);
            if (cmp(oldKey, newKey) !== 0) {
                if (oldKey != null)
                    addKeyOrKeys(oldKey);
                if (newKey != null)
                    addKeyOrKeys(newKey);
            }
        });
    }
    schema.indexes.forEach(addAffectedIndex);
}

function adjustOptimisticFromFailures(tblCache, req, res) {
    if (res.numFailures === 0)
        return req;
    if (req.type === 'deleteRange') {
        return null;
    }
    const numBulkOps = req.keys
        ? req.keys.length
        : 'values' in req && req.values
            ? req.values.length
            : 1;
    if (res.numFailures === numBulkOps) {
        return null;
    }
    const clone = { ...req };
    if (isArray(clone.keys)) {
        clone.keys = clone.keys.filter((_, i) => !(i in res.failures));
    }
    if ('values' in clone && isArray(clone.values)) {
        clone.values = clone.values.filter((_, i) => !(i in res.failures));
    }
    return clone;
}

function isAboveLower(key, range) {
    return range.lower === undefined
        ? true
        : range.lowerOpen
            ? cmp(key, range.lower) > 0
            : cmp(key, range.lower) >= 0;
}
function isBelowUpper(key, range) {
    return range.upper === undefined
        ? true
        : range.upperOpen
            ? cmp(key, range.upper) < 0
            : cmp(key, range.upper) <= 0;
}
function isWithinRange(key, range) {
    return isAboveLower(key, range) && isBelowUpper(key, range);
}

function applyOptimisticOps(result, req, ops, table, cacheEntry, immutable) {
    if (!ops || ops.length === 0)
        return result;
    const index = req.query.index;
    const { multiEntry } = index;
    const queryRange = req.query.range;
    const primaryKey = table.schema.primaryKey;
    const extractPrimKey = primaryKey.extractKey;
    const extractIndex = index.extractKey;
    const extractLowLevelIndex = (index.lowLevelIndex || index).extractKey;
    let finalResult = ops.reduce((result, op) => {
        let modifedResult = result;
        const includedValues = [];
        if (op.type === 'add' || op.type === 'put') {
            const includedPKs = new RangeSet();
            for (let i = op.values.length - 1; i >= 0; --i) {
                const value = op.values[i];
                const pk = extractPrimKey(value);
                if (includedPKs.hasKey(pk))
                    continue;
                const key = extractIndex(value);
                if (multiEntry && isArray(key)
                    ? key.some((k) => isWithinRange(k, queryRange))
                    : isWithinRange(key, queryRange)) {
                    includedPKs.addKey(pk);
                    includedValues.push(value);
                }
            }
        }
        switch (op.type) {
            case 'add': {
                const existingKeys = new RangeSet().addKeys(req.values ? result.map((v) => extractPrimKey(v)) : result);
                modifedResult = result.concat(req.values
                    ? includedValues.filter((v) => {
                        const key = extractPrimKey(v);
                        if (existingKeys.hasKey(key))
                            return false;
                        existingKeys.addKey(key);
                        return true;
                    })
                    : includedValues
                        .map((v) => extractPrimKey(v))
                        .filter((k) => {
                        if (existingKeys.hasKey(k))
                            return false;
                        existingKeys.addKey(k);
                        return true;
                    }));
                break;
            }
            case 'put': {
                const keySet = new RangeSet().addKeys(op.values.map((v) => extractPrimKey(v)));
                modifedResult = result
                    .filter(
                (item) => !keySet.hasKey(req.values ? extractPrimKey(item) : item))
                    .concat(
                req.values
                    ? includedValues
                    : includedValues.map((v) => extractPrimKey(v)));
                break;
            }
            case 'delete':
                const keysToDelete = new RangeSet().addKeys(op.keys);
                modifedResult = result.filter((item) => !keysToDelete.hasKey(req.values ? extractPrimKey(item) : item));
                break;
            case 'deleteRange':
                const range = op.range;
                modifedResult = result.filter((item) => !isWithinRange(extractPrimKey(item), range));
                break;
        }
        return modifedResult;
    }, result);
    if (finalResult === result)
        return result;
    const sorter = (a, b) => cmp(extractLowLevelIndex(a), extractLowLevelIndex(b)) ||
        cmp(extractPrimKey(a), extractPrimKey(b));
    finalResult.sort(req.direction === 'prev' || req.direction === 'prevunique'
        ? (a, b) => sorter(b, a)
        : sorter);
    if (req.limit && req.limit < Infinity) {
        if (finalResult.length > req.limit) {
            finalResult.length = req.limit;
        }
        else if (result.length === req.limit && finalResult.length < req.limit) {
            cacheEntry.dirty = true;
        }
    }
    return immutable ? Object.freeze(finalResult) : finalResult;
}

function areRangesEqual(r1, r2) {
    return (cmp(r1.lower, r2.lower) === 0 &&
        cmp(r1.upper, r2.upper) === 0 &&
        !!r1.lowerOpen === !!r2.lowerOpen &&
        !!r1.upperOpen === !!r2.upperOpen);
}

function compareLowers(lower1, lower2, lowerOpen1, lowerOpen2) {
    if (lower1 === undefined)
        return lower2 !== undefined ? -1 : 0;
    if (lower2 === undefined)
        return 1;
    const c = cmp(lower1, lower2);
    if (c === 0) {
        if (lowerOpen1 && lowerOpen2)
            return 0;
        if (lowerOpen1)
            return 1;
        if (lowerOpen2)
            return -1;
    }
    return c;
}
function compareUppers(upper1, upper2, upperOpen1, upperOpen2) {
    if (upper1 === undefined)
        return upper2 !== undefined ? 1 : 0;
    if (upper2 === undefined)
        return -1;
    const c = cmp(upper1, upper2);
    if (c === 0) {
        if (upperOpen1 && upperOpen2)
            return 0;
        if (upperOpen1)
            return -1;
        if (upperOpen2)
            return 1;
    }
    return c;
}
function isSuperRange(r1, r2) {
    return (compareLowers(r1.lower, r2.lower, r1.lowerOpen, r2.lowerOpen) <= 0 &&
        compareUppers(r1.upper, r2.upper, r1.upperOpen, r2.upperOpen) >= 0);
}

function findCompatibleQuery(dbName, tableName, type, req) {
    const tblCache = cache[`idb://${dbName}/${tableName}`];
    if (!tblCache)
        return [];
    const queries = tblCache.queries[type];
    if (!queries)
        return [null, false, tblCache, null];
    const indexName = req.query ? req.query.index.name : null;
    const entries = queries[indexName || ''];
    if (!entries)
        return [null, false, tblCache, null];
    switch (type) {
        case 'query':
            const reqDirection = req.direction ?? 'next';
            const equalEntry = entries.find((entry) => entry.req.limit === req.limit &&
                entry.req.values === req.values &&
                (entry.req.direction ?? 'next') ===
                    reqDirection &&
                areRangesEqual(entry.req.query.range, req.query.range));
            if (equalEntry)
                return [
                    equalEntry,
                    true,
                    tblCache,
                    entries,
                ];
            const superEntry = entries.find((entry) => {
                const limit = 'limit' in entry.req ? entry.req.limit : Infinity;
                return (limit >= req.limit &&
                    (entry.req.direction ?? 'next') ===
                        reqDirection &&
                    (req.values ? entry.req.values : true) &&
                    isSuperRange(entry.req.query.range, req.query.range));
            });
            return [superEntry, false, tblCache, entries];
        case 'count':
            const countQuery = entries.find((entry) => areRangesEqual(entry.req.query.range, req.query.range));
            return [countQuery, !!countQuery, tblCache, entries];
    }
}

function subscribeToCacheEntry(cacheEntry, container, requery, signal) {
    cacheEntry.subscribers.add(requery);
    signal.addEventListener('abort', () => {
        cacheEntry.subscribers.delete(requery);
        if (cacheEntry.subscribers.size === 0) {
            enqueForDeletion(cacheEntry, container);
        }
    });
}
function enqueForDeletion(cacheEntry, container) {
    setTimeout(() => {
        if (cacheEntry.subscribers.size === 0) {
            delArrayItem(container, cacheEntry);
        }
    }, 3000);
}

const cacheMiddleware = {
    stack: 'dbcore',
    level: 0,
    name: 'Cache',
    create: (core) => {
        const dbName = core.schema.name;
        const coreMW = {
            ...core,
            transaction: (stores, mode, options) => {
                const idbtrans = core.transaction(stores, mode, options);
                if (mode === 'readwrite') {
                    const ac = new AbortController();
                    const { signal } = ac;
                    const endTransaction = (wasCommitted) => () => {
                        ac.abort();
                        if (mode === 'readwrite') {
                            const affectedSubscribers = new Set();
                            for (const storeName of stores) {
                                const tblCache = cache[`idb://${dbName}/${storeName}`];
                                if (tblCache) {
                                    const table = core.table(storeName);
                                    const ops = tblCache.optimisticOps.filter((op) => op.trans === idbtrans);
                                    if (idbtrans._explicit &&
                                        wasCommitted &&
                                        idbtrans.mutatedParts) {
                                        for (const entries of Object.values(tblCache.queries.query)) {
                                            for (const entry of entries.slice()) {
                                                if (obsSetsOverlap(entry.obsSet, idbtrans.mutatedParts)) {
                                                    delArrayItem(entries, entry);
                                                    entry.subscribers.forEach((requery) => affectedSubscribers.add(requery));
                                                }
                                            }
                                        }
                                    }
                                    else if (ops.length > 0) {
                                        tblCache.optimisticOps = tblCache.optimisticOps.filter((op) => op.trans !== idbtrans);
                                        for (const entries of Object.values(tblCache.queries.query)) {
                                            for (const entry of entries.slice()) {
                                                if (entry.res != null &&
                                                    idbtrans.mutatedParts
) {
                                                    if (wasCommitted && !entry.dirty) {
                                                        const freezeResults = Object.isFrozen(entry.res);
                                                        const modRes = applyOptimisticOps(entry.res, entry.req, ops, table, entry, freezeResults);
                                                        if (entry.dirty) {
                                                            delArrayItem(entries, entry);
                                                            entry.subscribers.forEach((requery) => affectedSubscribers.add(requery));
                                                        }
                                                        else if (modRes !== entry.res) {
                                                            entry.res = modRes;
                                                            entry.promise = DexiePromise.resolve({
                                                                result: modRes,
                                                            });
                                                        }
                                                    }
                                                    else {
                                                        if (entry.dirty) {
                                                            delArrayItem(entries, entry);
                                                        }
                                                        entry.subscribers.forEach((requery) => affectedSubscribers.add(requery));
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            affectedSubscribers.forEach((requery) => requery());
                        }
                    };
                    idbtrans.addEventListener('abort', endTransaction(false), {
                        signal,
                    });
                    idbtrans.addEventListener('error', endTransaction(false), {
                        signal,
                    });
                    idbtrans.addEventListener('complete', endTransaction(true), {
                        signal,
                    });
                }
                return idbtrans;
            },
            table(tableName) {
                const downTable = core.table(tableName);
                const primKey = downTable.schema.primaryKey;
                const tableMW = {
                    ...downTable,
                    mutate(req) {
                        const trans = PSD.trans;
                        if (primKey.outbound ||
                            trans.db._options.cache === 'disabled' ||
                            trans.explicit ||
                            trans.idbtrans.mode !== 'readwrite'
                        ) {
                            return downTable.mutate(req);
                        }
                        const tblCache = cache[`idb://${dbName}/${tableName}`];
                        if (!tblCache)
                            return downTable.mutate(req);
                        const promise = downTable.mutate(req);
                        if ((req.type === 'add' || req.type === 'put') &&
                            (req.values.length >= 50 ||
                                getEffectiveKeys(primKey, req).some((key) => key == null))) {
                            promise.then((res) => {
                                const reqWithResolvedKeys = {
                                    ...req,
                                    values: req.values.map((value, i) => {
                                        if (res.failures[i])
                                            return value;
                                        const valueWithKey = primKey.keyPath?.includes('.')
                                            ? deepClone(value)
                                            : {
                                                ...value,
                                            };
                                        setByKeyPath(valueWithKey, primKey.keyPath, res.results[i]);
                                        return valueWithKey;
                                    }),
                                };
                                const adjustedReq = adjustOptimisticFromFailures(tblCache, reqWithResolvedKeys, res);
                                tblCache.optimisticOps.push(adjustedReq);
                                queueMicrotask(() => req.mutatedParts &&
                                    signalSubscribersLazily(req.mutatedParts));
                            });
                        }
                        else {
                            tblCache.optimisticOps.push(req);
                            req.mutatedParts && signalSubscribersLazily(req.mutatedParts);
                            promise.then((res) => {
                                if (res.numFailures > 0) {
                                    delArrayItem(tblCache.optimisticOps, req);
                                    const adjustedReq = adjustOptimisticFromFailures(tblCache, req, res);
                                    if (adjustedReq) {
                                        tblCache.optimisticOps.push(adjustedReq);
                                    }
                                    req.mutatedParts && signalSubscribersLazily(req.mutatedParts);
                                }
                            });
                            promise.catch(() => {
                                delArrayItem(tblCache.optimisticOps, req);
                                req.mutatedParts && signalSubscribersLazily(req.mutatedParts);
                            });
                        }
                        return promise;
                    },
                    query(req) {
                        if (!isCachableContext(PSD, downTable) ||
                            !isCachableRequest('query', req))
                            return downTable.query(req);
                        const freezeResults = PSD.trans?.db._options.cache ===
                            'immutable';
                        const { requery, signal } = PSD;
                        let [cacheEntry, exactMatch, tblCache, container] = findCompatibleQuery(dbName, tableName, 'query', req);
                        if (cacheEntry && exactMatch) {
                            cacheEntry.obsSet = req.obsSet;
                        }
                        else {
                            const promise = downTable
                                .query(req)
                                .then((res) => {
                                const result = res.result;
                                if (cacheEntry)
                                    cacheEntry.res = result;
                                if (freezeResults) {
                                    for (let i = 0, l = result.length; i < l; ++i) {
                                        Object.freeze(result[i]);
                                    }
                                    Object.freeze(result);
                                }
                                else {
                                    res.result = deepClone(result);
                                }
                                return res;
                            })
                                .catch((error) => {
                                if (container && cacheEntry)
                                    delArrayItem(container, cacheEntry);
                                return Promise.reject(error);
                            });
                            cacheEntry = {
                                obsSet: req.obsSet,
                                promise,
                                subscribers: new Set(),
                                type: 'query',
                                req,
                                dirty: false,
                            };
                            if (container) {
                                container.push(cacheEntry);
                            }
                            else {
                                container = [cacheEntry];
                                if (!tblCache) {
                                    tblCache = cache[`idb://${dbName}/${tableName}`] = {
                                        queries: {
                                            query: {},
                                            count: {},
                                        },
                                        objs: new Map(),
                                        optimisticOps: [],
                                        unsignaledParts: {},
                                    };
                                }
                                tblCache.queries.query[req.query.index.name || ''] = container;
                            }
                        }
                        subscribeToCacheEntry(cacheEntry, container, requery, signal);
                        return cacheEntry.promise.then((res) => {
                            return {
                                result: applyOptimisticOps(res.result, req, tblCache?.optimisticOps, downTable, cacheEntry, freezeResults),
                            };
                        });
                    },
                };
                return tableMW;
            },
        };
        return coreMW;
    },
};

function vipify(target, vipDb) {
    return new Proxy(target, {
        get(target, prop, receiver) {
            if (prop === 'db')
                return vipDb;
            return Reflect.get(target, prop, receiver);
        },
    });
}

let Dexie$1 = class Dexie {
    constructor(name, options) {
        this._middlewares = {};
        this.verno = 0;
        const deps = Dexie.dependencies;
        this._options = options = {
            addons: Dexie.addons,
            autoOpen: true,
            indexedDB: deps.indexedDB,
            IDBKeyRange: deps.IDBKeyRange,
            cache: 'cloned',
            maxConnections: DEFAULT_MAX_CONNECTIONS,
            ...options,
        };
        this._deps = {
            indexedDB: options.indexedDB,
            IDBKeyRange: options.IDBKeyRange,
        };
        const { addons } = options;
        this._dbSchema = {};
        this._versions = [];
        this._storeNames = [];
        this._allTables = {};
        this.idbdb = null;
        this._novip = this;
        const state = {
            dbOpenError: null,
            isBeingOpened: false,
            onReadyBeingFired: null,
            openComplete: false,
            dbReadyResolve: nop,
            dbReadyPromise: null,
            cancelOpen: nop,
            openCanceller: null,
            autoSchema: true,
            PR1398_maxLoop: 3,
            autoOpen: options.autoOpen,
        };
        state.dbReadyPromise = new DexiePromise((resolve) => {
            state.dbReadyResolve = resolve;
        });
        state.openCanceller = new DexiePromise((_, reject) => {
            state.cancelOpen = reject;
        });
        this._state = state;
        this.name = name;
        this.on = Events(this, 'populate', 'blocked', 'versionchange', 'close', {
            ready: [promisableChain, nop],
        });
        this.once = (event, callback) => {
            const fn = (...args) => {
                this.on(event).unsubscribe(fn);
                callback.apply(this, args);
            };
            return this.on(event, fn);
        };
        this.on.ready.subscribe = override(this.on.ready.subscribe, (subscribe) => {
            return (subscriber, bSticky) => {
                Dexie.vip(() => {
                    const state = this._state;
                    if (state.openComplete) {
                        if (!state.dbOpenError)
                            DexiePromise.resolve().then(subscriber);
                        if (bSticky)
                            subscribe(subscriber);
                    }
                    else if (state.onReadyBeingFired) {
                        state.onReadyBeingFired.push(subscriber);
                        if (bSticky)
                            subscribe(subscriber);
                    }
                    else {
                        subscribe(subscriber);
                        const db = this;
                        if (!bSticky)
                            subscribe(function unsubscribe() {
                                db.on.ready.unsubscribe(subscriber);
                                db.on.ready.unsubscribe(unsubscribe);
                            });
                    }
                });
            };
        });
        this.Collection = createCollectionConstructor(this);
        this.Table = createTableConstructor(this);
        this.Transaction = createTransactionConstructor(this);
        this.Version = createVersionConstructor(this);
        this.WhereClause = createWhereClauseConstructor(this);
        this.on('versionchange', (ev) => {
            if (ev.newVersion > 0)
                console.warn(`Another connection wants to upgrade database '${this.name}'. Closing db now to resume the upgrade.`);
            else
                console.warn(`Another connection wants to delete database '${this.name}'. Closing db now to resume the delete request.`);
            this.close({ disableAutoOpen: false });
        });
        this.on('blocked', (ev) => {
            if (!ev.newVersion || ev.newVersion < ev.oldVersion)
                console.warn(`Dexie.delete('${this.name}') was blocked`);
            else
                console.warn(`Upgrade '${this.name}' blocked by other connection holding version ${ev.oldVersion / 10}`);
        });
        this._maxKey = getMaxKey(options.IDBKeyRange);
        this._createTransaction = (mode, storeNames, dbschema, parentTransaction) => new this.Transaction(mode, storeNames, dbschema, this._options.chromeTransactionDurability, parentTransaction);
        this._fireOnBlocked = (ev) => {
            this.on('blocked').fire(ev);
            connections
                .toArray()
                .filter((c) => c.name === this.name && c !== this && !c._state.vcFired)
                .map((c) => c.on('versionchange').fire(ev));
        };
        this.use(cacheExistingValuesMiddleware);
        this.use(cacheMiddleware);
        this.use(observabilityMiddleware);
        this.use(virtualIndexMiddleware);
        this.use(hooksMiddleware);
        const vipDB = new Proxy(this, {
            get: (_, prop, receiver) => {
                if (prop === '_vip')
                    return true;
                if (prop === 'table')
                    return (tableName) => vipify(this.table(tableName), vipDB);
                const rv = Reflect.get(_, prop, receiver);
                if (rv instanceof Table)
                    return vipify(rv, vipDB);
                if (prop === 'tables')
                    return rv.map((t) => vipify(t, vipDB));
                if (prop === '_createTransaction')
                    return function () {
                        const tx = rv.apply(this, arguments);
                        return vipify(tx, vipDB);
                    };
                return rv;
            },
        });
        this.vip = vipDB;
        addons.forEach((addon) => addon(this));
    }
    version(versionNumber) {
        if (isNaN(versionNumber) || versionNumber < 0.1)
            throw new exceptions.Type(`Given version is not a positive number`);
        versionNumber = Math.round(versionNumber * 10) / 10;
        if (this.idbdb || this._state.isBeingOpened)
            throw new exceptions.Schema('Cannot add version when database is open');
        this.verno = Math.max(this.verno, versionNumber);
        const versions = this._versions;
        var versionInstance = versions.filter((v) => v._cfg.version === versionNumber)[0];
        if (versionInstance)
            return versionInstance;
        versionInstance = new this.Version(versionNumber);
        versions.push(versionInstance);
        versions.sort(lowerVersionFirst);
        versionInstance.stores({});
        this._state.autoSchema = false;
        return versionInstance;
    }
    _whenReady(fn) {
        return this.idbdb &&
            (this._state.openComplete || PSD.letThrough || this._vip)
            ? fn()
            : new DexiePromise((resolve, reject) => {
                if (this._state.openComplete) {
                    return reject(new exceptions.DatabaseClosed(this._state.dbOpenError));
                }
                if (!this._state.isBeingOpened) {
                    if (!this._state.autoOpen) {
                        reject(new exceptions.DatabaseClosed());
                        return;
                    }
                    this.open().catch(nop);
                }
                this._state.dbReadyPromise.then(resolve, reject);
            }).then(fn);
    }
    use({ stack, create, level, name }) {
        if (name)
            this.unuse({ stack, name });
        const middlewares = this._middlewares[stack] || (this._middlewares[stack] = []);
        middlewares.push({
            stack,
            create,
            level: level == null ? 10 : level,
            name,
        });
        middlewares.sort((a, b) => a.level - b.level);
        return this;
    }
    unuse({ stack, name, create, }) {
        if (stack && this._middlewares[stack]) {
            this._middlewares[stack] = this._middlewares[stack].filter((mw) => create
                ? mw.create !== create
                : name
                    ? mw.name !== name
                    : false);
        }
        return this;
    }
    open() {
        return usePSD(globalPSD,
        () => dexieOpen(this));
    }
    _close() {
        this.on.close.fire(new CustomEvent('close'));
        const state = this._state;
        connections.remove(this);
        if (this.idbdb) {
            try {
                this.idbdb.close();
            }
            catch (e) { }
            this.idbdb = null;
        }
        if (!state.isBeingOpened) {
            state.dbReadyPromise = new DexiePromise((resolve) => {
                state.dbReadyResolve = resolve;
            });
            state.openCanceller = new DexiePromise((_, reject) => {
                state.cancelOpen = reject;
            });
        }
    }
    close({ disableAutoOpen } = { disableAutoOpen: true }) {
        const state = this._state;
        if (disableAutoOpen) {
            if (state.isBeingOpened) {
                state.cancelOpen(new exceptions.DatabaseClosed());
            }
            this._close();
            state.autoOpen = false;
            state.dbOpenError = new exceptions.DatabaseClosed();
        }
        else {
            this._close();
            state.autoOpen = this._options.autoOpen || state.isBeingOpened;
            state.openComplete = false;
            state.dbOpenError = null;
        }
    }
    delete(closeOptions = { disableAutoOpen: true }) {
        const hasInvalidArguments = arguments.length > 0 && typeof arguments[0] !== 'object';
        const state = this._state;
        return new DexiePromise((resolve, reject) => {
            const doDelete = () => {
                this.close(closeOptions);
                var req = this._deps.indexedDB.deleteDatabase(this.name);
                req.onsuccess = wrap(() => {
                    _onDatabaseDeleted(this._deps, this.name);
                    resolve();
                });
                req.onerror = eventRejectHandler(reject);
                req.onblocked = this._fireOnBlocked;
            };
            if (hasInvalidArguments)
                throw new exceptions.InvalidArgument('Invalid closeOptions argument to db.delete()');
            if (state.isBeingOpened) {
                state.dbReadyPromise.then(doDelete);
            }
            else {
                doDelete();
            }
        });
    }
    backendDB() {
        return this.idbdb;
    }
    isOpen() {
        return this.idbdb !== null;
    }
    hasBeenClosed() {
        const dbOpenError = this._state.dbOpenError;
        return dbOpenError && dbOpenError.name === 'DatabaseClosed';
    }
    hasFailed() {
        return this._state.dbOpenError !== null;
    }
    dynamicallyOpened() {
        return this._state.autoSchema;
    }
    get tables() {
        return keys(this._allTables).map((name) => this._allTables[name]);
    }
    transaction() {
        const args = extractTransactionArgs.apply(this, arguments);
        return this._transaction.apply(this, args);
    }
    _transaction(mode, tables, scopeFunc) {
        let parentTransaction = PSD.trans;
        if (!parentTransaction ||
            parentTransaction.db !== this ||
            mode.indexOf('!') !== -1)
            parentTransaction = null;
        const onlyIfCompatible = mode.indexOf('?') !== -1;
        mode = mode.replace('!', '').replace('?', '');
        let idbMode, storeNames;
        try {
            storeNames = tables.map((table) => {
                var storeName = table instanceof this.Table ? table.name : table;
                if (typeof storeName !== 'string')
                    throw new TypeError('Invalid table argument to Dexie.transaction(). Only Table or String are allowed');
                return storeName;
            });
            if (mode == 'r' || mode === READONLY)
                idbMode = READONLY;
            else if (mode == 'rw' || mode == READWRITE)
                idbMode = READWRITE;
            else
                throw new exceptions.InvalidArgument('Invalid transaction mode: ' + mode);
            if (parentTransaction) {
                if (parentTransaction.mode === READONLY && idbMode === READWRITE) {
                    if (onlyIfCompatible) {
                        parentTransaction = null;
                    }
                    else
                        throw new exceptions.SubTransaction('Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY');
                }
                if (parentTransaction) {
                    storeNames.forEach((storeName) => {
                        if (parentTransaction &&
                            parentTransaction.storeNames.indexOf(storeName) === -1) {
                            if (onlyIfCompatible) {
                                parentTransaction = null;
                            }
                            else
                                throw new exceptions.SubTransaction('Table ' + storeName + ' not included in parent transaction.');
                        }
                    });
                }
                if (onlyIfCompatible &&
                    parentTransaction &&
                    !parentTransaction.active) {
                    parentTransaction = null;
                }
            }
        }
        catch (e) {
            return parentTransaction
                ? parentTransaction._promise(null, (_, reject) => {
                    reject(e);
                })
                : rejection(e);
        }
        const enterTransaction = enterTransactionScope.bind(null, this, idbMode, storeNames, parentTransaction, scopeFunc);
        return parentTransaction
            ? parentTransaction._promise(idbMode, enterTransaction, 'lock')
            : PSD.trans
                ?
                    usePSD(PSD.transless, () => this._whenReady(enterTransaction))
                : this._whenReady(enterTransaction);
    }
    table(tableName) {
        if (!hasOwn(this._allTables, tableName)) {
            throw new exceptions.InvalidTable(`Table ${tableName} does not exist`);
        }
        return this._allTables[tableName];
    }
};

const symbolObservable = typeof Symbol !== 'undefined' && 'observable' in Symbol
    ? Symbol.observable
    : '@@observable';
class Observable {
    constructor(subscribe) {
        this._subscribe = subscribe;
    }
    subscribe(x, error, complete) {
        return this._subscribe(!x || typeof x === 'function' ? { next: x, error, complete } : x);
    }
    [symbolObservable]() {
        return this;
    }
}

let domDeps;
try {
    domDeps = {
        indexedDB: _global.indexedDB ||
            _global.mozIndexedDB ||
            _global.webkitIndexedDB ||
            _global.msIndexedDB,
        IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange,
    };
}
catch (e) {
    domDeps = { indexedDB: null, IDBKeyRange: null };
}

function liveQuery(querier) {
    let hasValue = false;
    let currentValue;
    const observable = new Observable((observer) => {
        const scopeFuncIsAsync = isAsyncFunction(querier);
        function execute(ctx) {
            const wasRootExec = beginMicroTickScope();
            try {
                if (scopeFuncIsAsync) {
                    incrementExpectedAwaits();
                }
                let rv = newScope(querier, ctx);
                if (scopeFuncIsAsync) {
                    rv = rv.finally(decrementExpectedAwaits);
                }
                return rv;
            }
            finally {
                wasRootExec && endMicroTickScope();
            }
        }
        let closed = false;
        let abortController;
        let accumMuts = {};
        let currentObs = {};
        const subscription = {
            get closed() {
                return closed;
            },
            unsubscribe: () => {
                if (closed)
                    return;
                closed = true;
                if (abortController)
                    abortController.abort();
                if (startedListening)
                    globalEvents.storagemutated.unsubscribe(mutationListener);
            },
        };
        observer.start && observer.start(subscription);
        let startedListening = false;
        const doQuery = () => execInGlobalContext(_doQuery);
        function shouldNotify() {
            return obsSetsOverlap(currentObs, accumMuts);
        }
        const mutationListener = (parts) => {
            extendObservabilitySet(accumMuts, parts);
            if (shouldNotify()) {
                doQuery();
            }
        };
        const _doQuery = () => {
            if (closed ||
                !domDeps.indexedDB)
             {
                return;
            }
            accumMuts = {};
            const subscr = {};
            if (abortController)
                abortController.abort();
            abortController = new AbortController();
            const ctx = {
                subscr,
                signal: abortController.signal,
                requery: doQuery,
                querier,
                trans: null,
            };
            const ret = execute(ctx);
            if (!startedListening) {
                globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener);
                startedListening = true;
            }
            Promise.resolve(ret).then((result) => {
                hasValue = true;
                currentValue = result;
                if (closed || ctx.signal.aborted) {
                    return;
                }
                if (shouldNotify()) {
                    doQuery();
                }
                else {
                    currentObs = subscr;
                    if (shouldNotify()) {
                        doQuery();
                    }
                    else {
                        accumMuts = {};
                        execInGlobalContext(() => !closed && observer.next && observer.next(result));
                    }
                }
            }, (err) => {
                hasValue = false;
                if (!['DatabaseClosedError', 'AbortError'].includes(err?.name)) {
                    if (!closed)
                        execInGlobalContext(() => {
                            if (closed)
                                return;
                            observer.error && observer.error(err);
                        });
                }
            });
        };
        setTimeout(doQuery, 0);
        return subscription;
    });
    observable.hasValue = () => hasValue;
    observable.getValue = () => currentValue;
    return observable;
}

const Dexie = Dexie$1;
props(Dexie, {
    ...fullNameExceptions,
    delete(databaseName) {
        const db = new Dexie(databaseName, { addons: [] });
        return db.delete();
    },
    exists(name) {
        return new Dexie(name, { addons: [] })
            .open()
            .then((db) => {
            db.close();
            return true;
        })
            .catch('NoSuchDatabaseError', () => false);
    },
    getDatabaseNames(cb) {
        try {
            return getDatabaseNames(Dexie.dependencies).then(cb);
        }
        catch {
            return rejection(new exceptions.MissingAPI());
        }
    },
    defineClass() {
        function Class(content) {
            extend(this, content);
        }
        return Class;
    },
    ignoreTransaction(scopeFunc) {
        return PSD.trans
            ? usePSD(PSD.transless || globalPSD, scopeFunc)
            : scopeFunc();
    },
    vip,
    async: function (generatorFn) {
        return function () {
            try {
                var rv = awaitIterator(generatorFn.apply(this, arguments));
                if (!rv || typeof rv.then !== 'function')
                    return DexiePromise.resolve(rv);
                return rv;
            }
            catch (e) {
                return rejection(e);
            }
        };
    },
    spawn: function (generatorFn, args, thiz) {
        try {
            var rv = awaitIterator(generatorFn.apply(thiz, args || []));
            if (!rv || typeof rv.then !== 'function')
                return DexiePromise.resolve(rv);
            return rv;
        }
        catch (e) {
            return rejection(e);
        }
    },
    currentTransaction: {
        get: () => PSD.trans || null,
    },
    waitFor: function (promiseOrFunction, optionalTimeout) {
        const promise = DexiePromise.resolve(typeof promiseOrFunction === 'function'
            ? Dexie.ignoreTransaction(promiseOrFunction)
            : promiseOrFunction).timeout(optionalTimeout || 60000);
        return PSD.trans ? PSD.trans.waitFor(promise) : promise;
    },
    Promise: DexiePromise,
    debug: {
        get: () => debug,
        set: (value) => {
            setDebug(value);
        },
    },
    derive: derive,
    extend: extend,
    props: props,
    override: override,
    Events: Events,
    on: globalEvents,
    liveQuery,
    extendObservabilitySet,
    getByKeyPath: getByKeyPath,
    setByKeyPath: setByKeyPath,
    delByKeyPath: delByKeyPath,
    shallowClone: shallowClone,
    deepClone: deepClone,
    getObjectDiff: getObjectDiff,
    cmp,
    asap: asap$1,
    minKey: minKey,
    addons: [],
    connections: {
        get: connections.toArray,
    },
    errnames: errnames,
    dependencies: domDeps,
    cache,
    semVer: DEXIE_VERSION,
    version: DEXIE_VERSION.split('.')
        .map((n) => parseInt(n))
        .reduce((p, c, i) => p + c / Math.pow(10, i * 2)),
});
Dexie.maxKey = getMaxKey(Dexie.dependencies.IDBKeyRange);

if (typeof dispatchEvent !== 'undefined' &&
    typeof addEventListener !== 'undefined') {
    globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (updatedParts) => {
        if (!propagatingLocally) {
            let event;
            event = new CustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, {
                detail: updatedParts,
            });
            propagatingLocally = true;
            dispatchEvent(event);
            propagatingLocally = false;
        }
    });
    addEventListener(STORAGE_MUTATED_DOM_EVENT_NAME, ({ detail }) => {
        if (!propagatingLocally) {
            propagateLocally(detail);
        }
    });
}
function propagateLocally(updateParts) {
    let wasMe = propagatingLocally;
    try {
        propagatingLocally = true;
        globalEvents.storagemutated.fire(updateParts);
        signalSubscribersNow(updateParts, true);
    }
    finally {
        propagatingLocally = wasMe;
    }
}
let propagatingLocally = false;

let bc;
let createBC = () => { };
if (typeof BroadcastChannel !== 'undefined') {
    createBC = () => {
        bc = new BroadcastChannel(STORAGE_MUTATED_DOM_EVENT_NAME);
        bc.onmessage = (ev) => ev.data && propagateLocally(ev.data);
    };
    createBC();
    if (typeof bc.unref === 'function') {
        bc.unref();
    }
    globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, (changedParts) => {
        if (!propagatingLocally) {
            bc.postMessage(changedParts);
        }
    });
}

if (typeof addEventListener !== 'undefined') {
    addEventListener('pagehide', (event) => {
        if (!Dexie$1.disableBfCache && event.persisted) {
            if (debug)
                console.debug('Dexie: handling persisted pagehide');
            bc?.close();
            for (const db of connections.toArray()) {
                db.close({ disableAutoOpen: false });
            }
        }
    });
    addEventListener('pageshow', (event) => {
        if (!Dexie$1.disableBfCache && event.persisted) {
            if (debug)
                console.debug('Dexie: handling persisted pageshow');
            createBC();
            propagateLocally({ all: new RangeSet(-Infinity, [[]]) });
        }
    });
}

function add(value) {
    return new PropModification({ add: value });
}

function remove(value) {
    return new PropModification({ remove: value });
}

function replacePrefix(a, b) {
    return new PropModification({ replacePrefix: [a, b] });
}

DexiePromise.rejectionMapper = mapError;
setDebug(debug);

export { DEFAULT_MAX_CONNECTIONS, Dexie$1 as Dexie, Entity, PropModification, RangeSet, add, cmp, Dexie$1 as default, liveQuery, mergeRanges, rangesOverlap, remove, replacePrefix };
//# sourceMappingURL=dexie.mjs.map
