1b97923…0d31830e036b57aefc10476.js?1750661419218847

js ognisveta.ru collected 2026-10-06 13:59:40 UTC 171,437 bytes, 3,216 lines download raw bytes

1/* eslint-disable */
2this.BX = this.BX || {};(function (exports){'use strict';
3/*
4* Dexie.js - a minimalistic wrapper for IndexedDB
5* ===============================================
6*
7* By David Fahlander, [email protected]
8*
9* Version 4.0.9, Mon Oct 21 2024
10*
11* https://dexie.org
12*
13* Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
14*/
15/**
16* Modify list for integration with Bitrix Framework:
17* - removed integration with third-party package builders;
18* - add check variables before using them, see tags: 28122018;
19* - add alternative Promise check for Bitrix Cli, see tags: 02032020;
20* - add export for work in Bitrix CoreJS extensions;
21* - add export BX.Dexie and BX.Dexie3 for backward compatibility;
22*/
23/*! *****************************************************************************
24Copyright (c) Microsoft Corporation.
25Permission to use, copy, modify, and/or distribute this software for any
26purpose with or without fee is hereby granted.
27THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
28REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
29AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
30LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
31OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
32PERFORMANCE OF THIS SOFTWARE.
33***************************************************************************** */
34var _extendStatics = function extendStatics(d, b){_extendStatics = Object.setPrototypeOf || {
35__proto__: []
36} instanceof Array && function (d, b){d.__proto__ = b;} || function (d, b){for (var p in b) if(Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
37};return _extendStatics(d, b);};function __extends(d, b){if(typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
38_extendStatics(d, b);
39function __(){this.constructor = d;}
40d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());}
41var _assign = function __assign(){_assign = Object.assign || function __assign(t) {
42for (var s, i = 1, n = arguments.length; i < n; i++){s = arguments[i];
43for (var p in s) if(Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];}
44return t;};return _assign.apply(this, arguments);};function __spreadArray(to, from, pack){if(pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
45if(ar || !(i in from)){if(!ar) ar = Array.prototype.slice.call(from, 0, i);
46ar[i] = from[i];}
47}
48return to.concat(ar || Array.prototype.slice.call(from));}
49var _global = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : global;
50var keys = Object.keys;
51var isArray = Array.isArray;
52if(typeof Promise !== 'undefined' && !_global.Promise){_global.Promise = Promise;}
53function extend(obj, extension){if(babelHelpers["typeof"](extension) !== 'object') return obj;
54keys(extension).forEach(function (key){obj[key] = extension[key];});
55return obj;}
56var getProto = Object.getPrototypeOf;
57var _hasOwn = {}.hasOwnProperty;
58function hasOwn(obj, prop){return _hasOwn.call(obj, prop);}
59function props(proto, extension){if(typeof extension === 'function') extension = extension(getProto(proto));
60if(babelHelpers["typeof"](extension) !== 'object') return;
61(typeof Reflect === "undefined" ? keys : Reflect.ownKeys)(extension).forEach(function (key){setProp(proto, key, extension[key]);});
62}
63var defineProperty = Object.defineProperty;
64function setProp(obj, prop, functionOrGetSet, options){defineProperty(obj, prop, extend(functionOrGetSet && hasOwn(functionOrGetSet, "get") && typeof functionOrGetSet.get === 'function' ? {
65get: functionOrGetSet.get,set: functionOrGetSet.set,
66configurable: true
67} : {
68value: functionOrGetSet,configurable: true,
69writable: true
70}, options));}
71function derive(Child){return {
72from: function from(Parent){Child.prototype = Object.create(Parent.prototype);
73setProp(Child.prototype, "constructor", Child);
74return {
75extend: props.bind(null, Child.prototype)
76};}
77};}
78var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
79function getPropertyDescriptor(obj, prop){var pd = getOwnPropertyDescriptor(obj, prop);
80var proto;
81return pd || (proto = getProto(obj)) && getPropertyDescriptor(proto, prop

81);}
82var _slice = [].slice;
83function slice(args, start, end){return _slice.call(args, start, end);}
84function override(origFunc, overridedFactory){return overridedFactory(origFunc);}
85function assert(b){if(!b) throw new Error("Assertion Failed");}
86function asap$1(fn){if(_global.setImmediate) setImmediate(fn);else setTimeout(fn, 0);}
87function arrayToObject(array, extractor){return array.reduce(function (result, item, i) {
88var nameAndValue = extractor(item, i);
89if(nameAndValue) result[nameAndValue[0]] = nameAndValue[1];
90return result;}, {});
91}
92function getByKeyPath(obj, keyPath){if(typeof keyPath === 'string' && hasOwn(obj, keyPath)) return obj[keyPath];
93if(!keyPath) return obj;
94if(typeof keyPath !== 'string'){var rv = [];
95for (var i = 0, l = keyPath.length; i < l; ++i){var val = getByKeyPath(obj, keyPath[i]);
96rv.push(val);}
97return rv;}
98var period = keyPath.indexOf('.');
99if(period !== -1){var innerObj = obj[keyPath.substr(0, period)];
100return innerObj == null ? undefined : getByKeyPath(innerObj, keyPath.substr(period + 1));}
101return undefined;}
102function setByKeyPath(obj, keyPath, value){if(!obj || keyPath === undefined) return;
103if('isFrozen' in Object && Object.isFrozen(obj)) return;
104if(typeof keyPath !== 'string' && 'length' in keyPath){assert(typeof value !== 'string' && 'length' in value);
105for (var i = 0, l = keyPath.length; i < l; ++i){setByKeyPath(obj, keyPath[i], value[i]);}}else{var period = keyPath.indexOf('.');
106if(period !== -1){var currentKeyPath = keyPath.substr(0, period);
107var remainingKeyPath = keyPath.substr(period + 1);
108if(remainingKeyPath === ""){if(value === undefined) {
109if(isArray(obj) && !isNaN(parseInt(currentKeyPath))) obj.splice(currentKeyPath, 1);else delete obj[currentKeyPath];} else obj[currentKeyPath] = value;}else{var innerObj = obj[currentKeyPath];
110if(!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;
111}
112}
113}
114function delByKeyPath(obj, keyPath){if(typeof keyPath === 'string') setByKeyPath(obj, keyPath, undefined);else if('length' in keyPath) [].map.call(keyPath, function (kp) {
115setByKeyPath(obj, kp, undefined);});
116}
117function shallowClone(obj){var rv = {};for (var m in obj){if(hasOwn(obj, m)) rv[m] = obj[m];}
118return rv;}
119var concat = [].concat;
120function flatten(a){return concat.apply([], a);}
121var 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(function (num){return ["Int", "Uint", "Float"].map(function (t) {
122return t + num + "Array";});
123}))).filter(function (t){return _global[t];});
124var intrinsicTypes = new Set(intrinsicTypeNames.map(function (t){return _global[t];}));
125function cloneSimpleObjectTree(o){var rv = {};for (var k in o) if(hasOwn(o, k)){var v = o[k];
126rv[k] = !v || babelHelpers["typeof"](v) !== 'object' || intrinsicTypes.has(v.constructor) ? v : cloneSimpleObjectTree(v);}
127return rv;}
128function objectIsEmpty(o){for (var k in o) if(hasOwn(o, k)) return false;
129return true;}
130var circularRefs = null;
131function deepClone(any){circularRefs = new WeakMap();
132var rv = innerDeepClone(any);
133circularRefs = null;
134return rv;}
135function innerDeepClone(x){if(!x || babelHelpers["typeof"](x) !== 'object') return x;
136var rv = circularRefs.get(x);
137if(rv) return rv;
138if(isArray(x)){rv = [];
139circularRefs.set(x, rv);
140for (var i = 0, l = x.length; i < l; ++i){rv.push(innerDeepClone(x[i]));}
141} else if(intrinsicTypes.has(x.constructor)){rv = x;}else{var proto = getProto(x);
142rv = proto === Object.prototype ? {} : Object.create(proto);
143circularRefs.set(x, rv);
144for (var prop in x){if(hasOwn(x, prop)) {
145rv[prop] = innerDeepClone(x[prop]);}
146}
147}
148return rv;}
149var toString = {}.toString;
150function toStringTag(o){return toString.call(o).slice(8, -1);}
151var iteratorSymbol = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
152var getIteratorOf = babelHelpers["typeof"](iteratorSymbol) === "symbol" ? function (x){var i;
153return x != null && (i = x[iteratorSymbol]) && i.apply(x);} : function (){return null;
154};function delArrayItem(a, x){var i = a.indexOf(x);
155if(i >= 0) a.splice(i, 1);
156return i >= 0;}
157var NO_CHAR_ARRAY = {};function getArrayOf(arrayLike){var i, a, x, it;
158if(arguments.length === 1){if(isArray(arrayLike)) return arrayLike.slice();
159if(this === NO_CHAR_ARRAY && typeof arrayLike === 'string') return [arrayLike];
160if(it = getIteratorOf(arrayLike)){a = [];
161while (x = it.next(), !x.done) a.push(x.value);
162return a;}
163if(arrayLike == null) return [arrayLike];
164i = arrayLike.length;
165if(typeof i === 'number'){a = new Array(i);
166while (i--) a[i] = arrayLike[i];
167return a;}
168return [arrayLike];}
169i = arguments.length;
170a = new Array(i);
171while (i--) a[i] = arguments[i];
172return a;}
173var isAsyncFunction = typeof Symbol !== 'undefined' ? function (fn){return fn[Symbol.toStringTag] === 'AsyncFunction';} : function (){return false;

vendor: 4,114 bytes, lines 174-241

174};var dexieErrorNames = ['Modify', 'Bulk', 'OpenFailed', 'VersionChange', 'Schema', 'Upgrade', 'InvalidTable', 'MissingAPI', 'NoSuchDatabase', 'InvalidArgument', 'SubTransaction', 'Unsupported', 'Internal', 'DatabaseClosed', 'PrematureCommit', 'ForeignAwait'];
175var idbDomErrorNames = ['Unknown', 'Constraint', 'Data', 'TransactionInactive', 'ReadOnly', 'Version', 'NotFound', 'InvalidState', 'InvalidAccess', 'Abort', 'Timeout', 'QuotaExceeded', 'Syntax', 'DataClone'];
176var errorList = dexieErrorNames.concat(idbDomErrorNames);
177var defaultTexts = {
178VersionChanged: "Database version changed by other database connection",DatabaseClosed: "Database has been closed",
179Abort: "Transaction aborted",TransactionInactive: "Transaction has already completed or failed",
180MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb"
181};function DexieError(name, msg){this.name = name;
182this.message = msg;}
183derive(DexieError).from(Error).extend({
184toString: function toString(){return this.name + ": " + this.message;}
185});
186function getMultiErrorMessage(msg, failures){return msg + ". Errors: " + Object.keys(failures).map(function (key) {
187return failures[key].toString();}).filter(function (v, i, s){return s.indexOf(v) === i;
188}).join('\n');}
189function ModifyError(msg, failures, successCount, failedKeys){this.failures = failures;
190this.failedKeys = failedKeys;
191this.successCount = successCount;
192this.message = getMultiErrorMessage(msg, failures);}
193derive(ModifyError).from(DexieError);
194function BulkError(msg, failures){this.name = "BulkError";
195this.failures = Object.keys(failures).map(function (pos){return failures[pos];});
196this.failuresByPos = failures;
197this.message = getMultiErrorMessage(msg, this.failures);}
198derive(BulkError).from(DexieError);
199var errnames = errorList.reduce(function (obj, name){return obj[name] = name + "Error", obj;}, {});
200var BaseException = DexieError;
201var exceptions = errorList.reduce(function (obj, name){var fullName = name + "Error";
202function DexieError(msgOrInner, inner){this.name = fullName;
203if(!msgOrInner){this.message = defaultTexts[name] || fullName;
204this.inner = null;} else if(typeof msgOrInner === 'string'){this.message = "".concat(msgOrInner).concat(!inner ? '' : '\n ' + inner);
205this.inner = inner || null;} else if(babelHelpers["typeof"](msgOrInner) === 'object'){this.message = "".concat(msgOrInner.name, " ").concat(msgOrInner.message);
206this.inner = msgOrInner;}
207}
208derive(DexieError).from(BaseException);
209obj[name] = DexieError;
210return obj;}, {});
211exceptions.Syntax = SyntaxError;
212exceptions.Type = TypeError;
213exceptions.Range = RangeError;
214var exceptionMap = idbDomErrorNames.reduce(function (obj, name){obj[name + "Error"] = exceptions[name];
215return obj;}, {});
216function mapError(domError, message){if(!domError || domError instanceof DexieError || domError instanceof TypeError || domError instanceof SyntaxError || !domError.name || !exceptionMap[domError.name]) return domError;
217var rv = new exceptionMap[domError.name](message || domError.message, domError);
218if("stack" in domError){setProp(rv, "stack", {
219get: function get(){return this.inner.stack;}
220});}
221return rv;}
222var fullNameExceptions = errorList.reduce(function (obj, name){if(["Syntax", "Type", "Range"].indexOf(name) === -1) obj[name + "Error"] = exceptions[name];
223return obj;}, {});
224fullNameExceptions.ModifyError = ModifyError;
225fullNameExceptions.DexieError = DexieError;
226fullNameExceptions.BulkError = BulkError;
227function nop(){}
228function mirror(val){return val;}
229function pureFunctionChain(f1, f2){if(f1 == null || f1 === mirror) return f2;
230return function (val){return f2(f1(val));};}
231function callBoth(on1, on2){return function () {
232on1.apply(this, arguments);
233on2.apply(this, arguments);};}
234function hookCreatingChain(f1, f2){if(f1 === nop) return f2;
235return function (){var res = f1.apply(this, arguments);
236if(res !== undefined) arguments[0] = res;
237var onsuccess = this.onsuccess,onerror = this.onerror;
238this.onsuccess = null;
239this.onerror = null;
240var res2 = f2.apply(this, arguments);
241if(onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;

242if(onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
243return res2 !== undefined ? res2 : res;};}
244function hookDeletingChain(f1, f2){if(f1 === nop) return f2;
245return function (){f1.apply(this, arguments);
246var onsuccess = this.onsuccess,onerror = this.onerror;
247this.onsuccess = this.onerror = null;
248f2.apply(this, arguments);
249if(onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
250if(onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;};}
251function hookUpdatingChain(f1, f2){if(f1 === nop) return f2;
252return function (modifications){var res = f1.apply(this, arguments);
253extend(modifications, res);
254var onsuccess = this.onsuccess,onerror = this.onerror;
255this.onsuccess = null;
256this.onerror = null;
257var res2 = f2.apply(this, arguments);
258if(onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
259if(onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
260return res === undefined ? res2 === undefined ? undefined : res2 : extend(res, res2);};}
261function reverseStoppableEventChain(f1, f2){if(f1 === nop) return f2;
262return function (){if(f2.apply(this, arguments) === false) return false;
263return f1.apply(this, arguments);};}
264function promisableChain(f1, f2){if(f1 === nop) return f2;
265return function (){var res = f1.apply(this, arguments);
266if(res && typeof res.then === 'function'){var thiz = this,i = arguments.length,
267args = new Array(i);
268while (i--) args[i] = arguments[i];
269return res.then(function (){return f2.apply(thiz, args);});
270}
271return f2.apply(this, arguments);};}
272var debug = typeof location !== 'undefined' && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
273function setDebug(value, filter){debug = value;}
274var INTERNAL = {};var ZONE_ECHO_LIMIT = 100,_a$1 = typeof Promise === 'undefined' ? [] : function (){var globalP = Promise.resolve();
275if(typeof crypto === 'undefined' || !crypto.subtle) return [globalP, getProto(globalP), globalP];
276var nativeP = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
277return [nativeP, getProto(nativeP), globalP];}(),resolvedNativePromise = _a$1[0],
278nativePromiseProto = _a$1[1],resolvedGlobalPromise = _a$1[2],
279nativePromiseThen = nativePromiseProto && nativePromiseProto.then;
280var NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
281var patchGlobalPromise = !!resolvedGlobalPromise;
282function schedulePhysicalTick(){queueMicrotask(physicalTick);}
283var asap = function asap(callback, args){microtickQueue.push([callback, args]);
284if(needsNewPhysicalTick){schedulePhysicalTick();
285needsNewPhysicalTick = false;}
286};var isOutsideMicroTick = true,needsNewPhysicalTick = true,
287unhandledErrors = [],rejectingErrors = [],
288rejectionMapper = mirror;
289var globalPSD = {
290id: 'global',global: true,
291ref: 0,unhandleds: [],
292onunhandled: nop,pgp: false,
293env: {},finalize: nop
294};var PSD = globalPSD;
295var microtickQueue = [];
296var numScheduledCalls = 0;
297var tickFinalizers = [];
298function DexiePromise(fn){if(babelHelpers["typeof"](this) !== 'object') throw new TypeError('Promises must be constructed via new');
299this._listeners = [];
300this._lib = false;
301var psd = this._PSD = PSD;
302if(typeof fn !== 'function'){if(fn !== INTERNAL) throw new TypeError('Not a function');
303this._state = arguments[1];
304this._value = arguments[2];
305if(this._state === false) handleRejection(this, this._value);
306return;}
307this._state = null;
308this._value = null;
309++psd.ref;
310executePromiseTask(this, fn);}
311var thenProp = {
312get: function get(){var psd = PSD,microTaskId = totalEchoes;
313function then(onFulfilled, onRejected){var _this = this;
314var possibleAwait = !psd.global && (psd !== PSD || microTaskId !== totalEchoes);
315var cleanup = possibleAwait && !decrementExpectedAwaits();
316var rv = new DexiePromise(function (resolve, reject){propagateToListener(_this, new Listener(nativeAwaitCompatibleWrap(onFulfilled, psd, possibleAwait, cleanup), nativeAwaitCompatibleWrap(onRejected, psd, possibleAwait, cleanup), resolve, reject, psd));});
317if(this._consoleTask) rv._consoleTask = this._consoleTask;
318return rv;}
319then.prototype = INTERNAL;
320return then;},set: function set(value){setProp(this, 'then', value && value.prototype === INTERNAL ? thenProp : {
321get: function get(){return value;},set: thenProp.set
322});}
323};props(DexiePromise.prototype, {
324then: thenProp,_then: function _then(onFulfilled, onRejected){propagateToListener(this, new Listener(null, null, onFulfilled, onRejected, PSD));},

325"catch": function _catch(onRejected){if(arguments.length === 1) return this.then(null, onRejected);
326var type = arguments[0],handler = arguments[1];
327return typeof type === 'function' ? this.then(null, function (err){return err instanceof type ? handler(err) : PromiseReject(err);}) : this.then(null, function (err){return err && err.name === type ? handler(err) : PromiseReject(err);
328});},"finally": function _finally(onFinally){return this.then(function (value) {
329return DexiePromise.resolve(onFinally()).then(function (){return value;});
330}, function (err){return DexiePromise.resolve(onFinally()).then(function () {
331return PromiseReject(err);});
332});},timeout: function timeout(ms, msg){var _this = this;
333return ms < Infinity ? new DexiePromise(function (resolve, reject){var handle = setTimeout(function () {
334return reject(new exceptions.Timeout(msg));}, ms);
335_this.then(resolve, reject)["finally"](clearTimeout.bind(null, handle));}) : this;
336}
337});
338if(typeof Symbol !== 'undefined' && Symbol.toStringTag) setProp(DexiePromise.prototype, Symbol.toStringTag, 'Dexie.Promise');
339globalPSD.env = snapShot();
340function Listener(onFulfilled, onRejected, resolve, reject, zone){this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
341this.onRejected = typeof onRejected === 'function' ? onRejected : null;
342this.resolve = resolve;
343this.reject = reject;
344this.psd = zone;}
345props(DexiePromise, {
346all: function all(){var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
347return new DexiePromise(function (resolve, reject){if(values.length === 0) resolve([]);
348var remaining = values.length;
349values.forEach(function (a, i){return DexiePromise.resolve(a).then(function (x) {
350values[i] = x;
351if(! --remaining) resolve(values);}, reject);
352});});
353},resolve: function resolve(value){if(value instanceof DexiePromise) return value;
354if(value && typeof value.then === 'function') return new DexiePromise(function (resolve, reject){value.then(resolve, reject);});
355var rv = new DexiePromise(INTERNAL, true, value);
356return rv;},reject: PromiseReject,
357race: function race(){var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
358return new DexiePromise(function (resolve, reject){values.map(function (value) {
359return DexiePromise.resolve(value).then(resolve, reject);});
360});},PSD: {
361get: function get(){return PSD;},set: function set(value){return PSD = value;}
362},totalEchoes: {
363get: function get(){return totalEchoes;}
364},newPSD: newScope,
365usePSD: usePSD,scheduler: {
366get: function get(){return asap;},set: function set(value){asap = value;}
367},rejectionMapper: {
368get: function get(){return rejectionMapper;},set: function set(value){rejectionMapper = value;}
369},follow: function follow(fn, zoneProps){return new DexiePromise(function (resolve, reject) {
370return newScope(function (resolve, reject){var psd = PSD;
371psd.unhandleds = [];
372psd.onunhandled = reject;
373psd.finalize = callBoth(function (){var _this = this;
374run_at_end_of_this_or_next_physical_tick(function (){_this.unhandleds.length === 0 ? resolve() : reject(_this.unhandleds[0]);});
375}, psd.finalize);
376fn();}, zoneProps, resolve, reject);
377});}
378});
379if(NativePromise){if(NativePromise.allSettled) setProp(DexiePromise, "allSettled", function () {
380var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
381return new DexiePromise(function (resolve){if(possiblePromises.length === 0) resolve([]);
382var remaining = possiblePromises.length;
383var results = new Array(remaining);
384possiblePromises.forEach(function (p, i){return DexiePromise.resolve(p).then(function (value) {
385return results[i] = {
386status: "fulfilled",value: value
387};}, function (reason){return results[i] = {
388status: "rejected",reason: reason
389};}).then(function (){return --remaining || resolve(results);
390});});
391});});
392if(NativePromise.any && typeof AggregateError !== 'undefined') setProp(DexiePromise, "any", function (){var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
393return new DexiePromise(function (resolve, reject){if(possiblePromises.length === 0) reject(new AggregateError([]));
394var remaining = possiblePromises.length;
395var failures = new Array(remaining);

vendor: 4,790 bytes, lines 396-508

396possiblePromises.forEach(function (p, i){return DexiePromise.resolve(p).then(function (value) {
397return resolve(value);}, function (failure){failures[i] = failure;
398if(! --remaining) reject(new AggregateError(failures));});
399});});
400});
401if(NativePromise.withResolvers) DexiePromise.withResolvers = NativePromise.withResolvers;}
402function executePromiseTask(promise, fn){try {
403fn(function (value){if(promise._state !== null) return;
404if(value === promise) throw new TypeError('A promise cannot be resolved with itself.');
405var shouldExecuteTick = promise._lib && beginMicroTickScope();
406if(value && typeof value.then === 'function'){executePromiseTask(promise, function (resolve, reject) {
407value instanceof DexiePromise ? value._then(resolve, reject) : value.then(resolve, reject);});}else{promise._state = true;
408promise._value = value;
409propagateAllListeners(promise);}
410if(shouldExecuteTick) endMicroTickScope();}, handleRejection.bind(null, promise));
411} catch (ex){handleRejection(promise, ex);}
412}
413function handleRejection(promise, reason){rejectingErrors.push(reason);
414if(promise._state !== null) return;
415var shouldExecuteTick = promise._lib && beginMicroTickScope();
416reason = rejectionMapper(reason);
417promise._state = false;
418promise._value = reason;
419addPossiblyUnhandledError(promise);
420propagateAllListeners(promise);
421if(shouldExecuteTick) endMicroTickScope();}
422function propagateAllListeners(promise){var listeners = promise._listeners;
423promise._listeners = [];
424for (var i = 0, len = listeners.length; i < len; ++i){propagateToListener(promise, listeners[i]);}
425var psd = promise._PSD;
426--psd.ref || psd.finalize();
427if(numScheduledCalls === 0){++numScheduledCalls;
428asap(function (){if(--numScheduledCalls === 0) finalizePhysicalTick();}, []);
429}
430}
431function propagateToListener(promise, listener){if(promise._state === null) {
432promise._listeners.push(listener);
433return;}
434var cb = promise._state ? listener.onFulfilled : listener.onRejected;
435if(cb === null){return (promise._state ? listener.resolve : listener.reject)(promise._value);}
436++listener.psd.ref;
437++numScheduledCalls;
438asap(callListener, [cb, promise, listener]);}
439function callListener(cb, promise, listener){try {
440var ret,value = promise._value;
441if(!promise._state && rejectingErrors.length) rejectingErrors = [];
442ret = debug && promise._consoleTask ? promise._consoleTask.run(function (){return cb(value);}) : cb(value);
443if(!promise._state && rejectingErrors.indexOf(value) === -1){markErrorAsHandled(promise);}
444listener.resolve(ret);} catch (e){listener.reject(e);
445} finally {
446if(--numScheduledCalls === 0) finalizePhysicalTick();
447--listener.psd.ref || listener.psd.finalize();}
448}
449function physicalTick(){usePSD(globalPSD, function () {
450beginMicroTickScope() && endMicroTickScope();});
451}
452function beginMicroTickScope(){var wasRootExec = isOutsideMicroTick;
453isOutsideMicroTick = false;
454needsNewPhysicalTick = false;
455return wasRootExec;}
456function endMicroTickScope(){var callbacks, i, l;
457do {
458while (microtickQueue.length > 0){callbacks = microtickQueue;
459microtickQueue = [];
460l = callbacks.length;
461for (i = 0; i < l; ++i){var item = callbacks[i];
462item[0].apply(null, item[1]);}
463}
464} while (microtickQueue.length > 0);
465isOutsideMicroTick = true;
466needsNewPhysicalTick = true;}
467function finalizePhysicalTick(){var unhandledErrs = unhandledErrors;
468unhandledErrors = [];
469unhandledErrs.forEach(function (p){p._PSD.onunhandled.call(null, p._value, p);});
470var finalizers = tickFinalizers.slice(0);
471var i = finalizers.length;
472while (i) finalizers[--i]();}
473function run_at_end_of_this_or_next_physical_tick(fn){function finalizer() {
474fn();
475tickFinalizers.splice(tickFinalizers.indexOf(finalizer), 1);}
476tickFinalizers.push(finalizer);
477++numScheduledCalls;
478asap(function (){if(--numScheduledCalls === 0) finalizePhysicalTick();}, []);
479}
480function addPossiblyUnhandledError(promise){if(!unhandledErrors.some(function (p) {
481return p._value === promise._value;})) unhandledErrors.push(promise);
482}
483function markErrorAsHandled(promise){var i = unhandledErrors.length;
484while (i) if(unhandledErrors[--i]._value === promise._value){unhandledErrors.splice(i, 1);
485return;}
486}
487function PromiseReject(reason){return new DexiePromise(INTERNAL, false, reason);}
488function wrap(fn, errorCatcher){var psd = PSD;
489return function (){var wasRootExec = beginMicroTickScope(),outerScope = PSD;
490try {
491switchToZone(psd, true);
492return fn.apply(this, arguments);} catch (e){errorCatcher && errorCatcher(e);
493} finally {
494switchToZone(outerScope, false);
495if(wasRootExec) endMicroTickScope();}
496};}
497var task = {
498awaits: 0,echoes: 0,
499id: 0
500};var taskCounter = 0;
501var zoneStack = [];
502var zoneEchoes = 0;
503var totalEchoes = 0;
504var zone_id_counter = 0;
505function newScope(fn, props, a1, a2){var parent = PSD,psd = Object.create(parent);
506psd.parent = parent;
507psd.ref = 0;
508psd.global = false;

vendor: 12,227 bytes, lines 509-737

509psd.id = ++zone_id_counter;
510psd.env = patchGlobalPromise ? {
511Promise: DexiePromise,PromiseProp: {
512value: DexiePromise,configurable: true,
513writable: true
514},all: DexiePromise.all,
515race: DexiePromise.race,allSettled: DexiePromise.allSettled,
516any: DexiePromise.any,resolve: DexiePromise.resolve,
517reject: DexiePromise.reject
518} : {};if(props) extend(psd, props);
519++parent.ref;
520psd.finalize = function (){--this.parent.ref || this.parent.finalize();};var rv = usePSD(psd, fn, a1, a2);
521if(psd.ref === 0) psd.finalize();
522return rv;}
523function incrementExpectedAwaits(){if(!task.id) task.id = ++taskCounter;
524++task.awaits;
525task.echoes += ZONE_ECHO_LIMIT;
526return task.id;}
527function decrementExpectedAwaits(){if(!task.awaits) return false;
528if(--task.awaits === 0) task.id = 0;
529task.echoes = task.awaits * ZONE_ECHO_LIMIT;
530return true;}
531if(('' + nativePromiseThen).indexOf('[native code]') === -1){incrementExpectedAwaits = decrementExpectedAwaits = nop;}
532function onPossibleParallellAsync(possiblePromise){if(task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) {
533incrementExpectedAwaits();
534return possiblePromise.then(function (x){decrementExpectedAwaits();
535return x;}, function (e){decrementExpectedAwaits();
536return rejection(e);});
537}
538return possiblePromise;}
539function zoneEnterEcho(targetZone){++totalEchoes;
540if(!task.echoes || --task.echoes === 0){task.echoes = task.awaits = task.id = 0;}
541zoneStack.push(PSD);
542switchToZone(targetZone, true);}
543function zoneLeaveEcho(){var zone = zoneStack[zoneStack.length - 1];
544zoneStack.pop();
545switchToZone(zone, false);}
546function switchToZone(targetZone, bEnteringZone){var currentZone = PSD;
547if(bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (! --zoneEchoes || targetZone !== PSD)){queueMicrotask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);}
548if(targetZone === PSD) return;
549PSD = targetZone;
550if(currentZone === globalPSD) globalPSD.env = snapShot();
551if(patchGlobalPromise){var GlobalPromise = globalPSD.env.Promise;
552var targetEnv = targetZone.env;
553if(currentZone.global || targetZone.global){Object.defineProperty(_global, 'Promise', targetEnv.PromiseProp);
554GlobalPromise.all = targetEnv.all;
555GlobalPromise.race = targetEnv.race;
556GlobalPromise.resolve = targetEnv.resolve;
557GlobalPromise.reject = targetEnv.reject;
558if(targetEnv.allSettled) GlobalPromise.allSettled = targetEnv.allSettled;
559if(targetEnv.any) GlobalPromise.any = targetEnv.any;}
560}
561}
562function snapShot(){var GlobalPromise = _global.Promise || Promise; // tag 02032020
563return patchGlobalPromise ? {
564Promise: GlobalPromise,PromiseProp: Object.getOwnPropertyDescriptor(_global, "Promise"),
565all: GlobalPromise.all,race: GlobalPromise.race,
566allSettled: GlobalPromise.allSettled,any: GlobalPromise.any,
567resolve: GlobalPromise.resolve,reject: GlobalPromise.reject
568} : {};}
569function usePSD(psd, fn, a1, a2, a3){var outerScope = PSD;
570try {
571switchToZone(psd, true);
572return fn(a1, a2, a3);} finally {
573switchToZone(outerScope, false);}
574}
575function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup){return typeof fn !== 'function' ? fn : function () {
576var outerZone = PSD;
577if(possibleAwait) incrementExpectedAwaits();
578switchToZone(zone, true);
579try {
580return fn.apply(this, arguments);} finally {
581switchToZone(outerZone, false);
582if(cleanup) queueMicrotask(decrementExpectedAwaits);}
583};}
584function execInGlobalContext(cb){if(Promise === NativePromise && task.echoes === 0) {
585if(zoneEchoes === 0){cb();}else{enqueueNativeMicroTask(cb);}
586} else {
587setTimeout(cb, 0);}
588}
589var rejection = DexiePromise.reject;
590function tempTransaction(db, mode, storeNames, fn){if(!db.idbdb || !db._state.openComplete && !PSD.letThrough && !db._vip) {
591if(db._state.openComplete){return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));}
592if(!db._state.isBeingOpened){if(!db._state.autoOpen) return rejection(new exceptions.DatabaseClosed());
593db.open()["catch"](nop);}
594return db._state.dbReadyPromise.then(function (){return tempTransaction(db, mode, storeNames, fn);});}else{var trans = db._createTransaction(mode, storeNames, db._dbSchema);
595try {
596trans.create();
597db._state.PR1398_maxLoop = 3;} catch (ex){if(ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
598console.warn('Dexie: Need to reopen db');
599db.close({
600disableAutoOpen: false
601});
602return db.open().then(function (){return tempTransaction(db, mode, storeNames, fn);});
603}
604return rejection(ex);}
605return trans._promise(mode, function (resolve, reject){return newScope(function () {
606PSD.trans = trans;
607return fn(resolve, reject, trans);});
608}).then(function (result){if(mode === 'readwrite') try {
609trans.idbtrans.commit();} catch (_a){}
610return mode === 'readonly' ? result : trans._completion.then(function (){return result;});
611});}
612}
613var DEXIE_VERSION = '4.0.9';
614var maxString = String.fromCharCode(65535);
615var minKey = -Infinity;
616var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
617var STRING_EXPECTED = "String expected.";
618var connections = [];
619var DBNAMES_DB = '__dbnames';
620var READONLY = 'readonly';
621var READWRITE = 'readwrite';
622function combine(filter1, filter2){return filter1 ? filter2 ? function () {
623return filter1.apply(this, arguments) && filter2.apply(this, arguments);} : filter1 : filter2;
624}
625var AnyRange = {
626type: 3,lower: -Infinity,
627lowerOpen: false,upper: [[]],
628upperOpen: false
629};function workaroundForUndefinedPrimKey(keyPath){return typeof keyPath === "string" && !/\./.test(keyPath) ? function (obj) {
630if(obj[keyPath] === undefined && keyPath in obj){obj = deepClone(obj);
631delete obj[keyPath];}
632return obj;} : function (obj){return obj;
633};}
634function Entity(){throw exceptions.Type();}
635function cmp(a, b){try {
636var ta = type(a);
637var tb = type(b);
638if(ta !== tb){if(ta === 'Array') return 1;
639if(tb === 'Array') return -1;
640if(ta === 'binary') return 1;
641if(tb === 'binary') return -1;
642if(ta === 'string') return 1;
643if(tb === 'string') return -1;
644if(ta === 'Date') return 1;
645if(tb !== 'Date') return NaN;
646return -1;}
647switch (ta){case 'number':
648case 'Date':
649case 'string':
650return a > b ? 1 : a < b ? -1 : 0;
651case 'binary':
652{
653return compareUint8Arrays(getUint8Array(a), getUint8Array(b));}
654case 'Array':
655return compareArrays(a, b);}
656} catch (_a){}
657return NaN;}
658function compareArrays(a, b){var al = a.length;
659var bl = b.length;
660var l = al < bl ? al : bl;
661for (var i = 0; i < l; ++i){var res = cmp(a[i], b[i]);
662if(res !== 0) return res;}
663return al === bl ? 0 : al < bl ? -1 : 1;}
664function compareUint8Arrays(a, b){var al = a.length;
665var bl = b.length;
666var l = al < bl ? al : bl;
667for (var i = 0; i < l; ++i){if(a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;}
668return al === bl ? 0 : al < bl ? -1 : 1;}
669function type(x){var t = babelHelpers["typeof"](x);
670if(t !== 'object') return t;
671if(ArrayBuffer.isView(x)) return 'binary';
672var tsTag = toStringTag(x);
673return tsTag === 'ArrayBuffer' ? 'binary' : tsTag;}
674function getUint8Array(a){if(a instanceof Uint8Array) return a;
675if(ArrayBuffer.isView(a)) return new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
676return new Uint8Array(a);}
677var Table = function (){function Table() {}
678Table.prototype._trans = function (mode, fn, writeLocked){var trans = this._tx || PSD.trans;
679var tableName = this.name;
680var task = debug && typeof console !== 'undefined' && console.createTask && console.createTask("Dexie: ".concat(mode === 'readonly' ? 'read' : 'write', " ").concat(this.name));
681function checkTableInTransaction(resolve, reject, trans){if(!trans.schema[tableName]) throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
682return fn(trans.idbtrans, trans);}
683var wasRootExec = beginMicroTickScope();
684try {
685var p = trans && trans.db._novip === this.db._novip ? trans === PSD.trans ? trans._promise(mode, checkTableInTransaction, writeLocked) : newScope(function (){return trans._promise(mode, checkTableInTransaction, writeLocked);}, {
686trans: trans,transless: PSD.transless || PSD
687}) : tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
688if(task){p._consoleTask = task;
689p = p["catch"](function (err){console.trace(err);
690return rejection(err);});
691}
692return p;} finally {
693if(wasRootExec) endMicroTickScope();}
694};Table.prototype.get = function (keyOrCrit, cb){var _this = this;
695if(keyOrCrit && keyOrCrit.constructor === Object) return this.where(keyOrCrit).first(cb);
696if(keyOrCrit == null) return rejection(new exceptions.Type("Invalid argument to Table.get()"));
697return this._trans('readonly', function (trans){return _this.core.get({
698trans: trans,key: keyOrCrit
699}).then(function (res){return _this.hook.reading.fire(res);});
700}).then(cb);};Table.prototype.where = function (indexOrCrit){if(typeof indexOrCrit === 'string') return new this.db.WhereClause(this, indexOrCrit);
701if(isArray(indexOrCrit)) return new this.db.WhereClause(this, "[".concat(indexOrCrit.join('+'), "]"));
702var keyPaths = keys(indexOrCrit);
703if(keyPaths.length === 1) return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]);
704var compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter(function (ix){if(ix.compound && keyPaths.every(function (keyPath) {
705return ix.keyPath.indexOf(keyPath) >= 0;})){for (var i = 0; i < keyPaths.length; ++i) {
706if(keyPaths.indexOf(ix.keyPath[i]) === -1) return false;}
707return true;}
708return false;}).sort(function (a, b){return a.keyPath.length - b.keyPath.length;
709})[0];
710if(compoundIndex && this.db._maxKey !== maxString){var keyPathsInValidOrder = compoundIndex.keyPath.slice(0, keyPaths.length);
711return this.where(keyPathsInValidOrder).equals(keyPathsInValidOrder.map(function (kp){return indexOrCrit[kp];}));
712}
713if(!compoundIndex && debug) console.warn("The query ".concat(JSON.stringify(indexOrCrit), " on ").concat(this.name, " would benefit from a ") + "compound index [".concat(keyPaths.join('+'), "]"));
714var idxByName = this.schema.idxByName;
715function equals(a, b){return cmp(a, b) === 0;}
716var _a = keyPaths.reduce(function (_a, keyPath){var prevIndex = _a[0],prevFilterFn = _a[1];
717var index = idxByName[keyPath];
718var value = indexOrCrit[keyPath];
719return [prevIndex || index, prevIndex || !index ? combine(prevFilterFn, index && index.multi ? function (x){var prop = getByKeyPath(x, keyPath);
720return isArray(prop) && prop.some(function (item){return equals(value, item);});
721} : function (x){return equals(value, getByKeyPath(x, keyPath));}) : prevFilterFn];
722}, [null, null]),idx = _a[0],
723filterFunction = _a[1];
724return idx ? this.where(idx.name).equals(indexOrCrit[idx.keyPath]).filter(filterFunction) : compoundIndex ? this.filter(filterFunction) : this.where(keyPaths).equals('');};Table.prototype.filter = function (filterFunction){return this.toCollection().and(filterFunction);};Table.prototype.count = function (thenShortcut){return this.toCollection().count(thenShortcut);};Table.prototype.offset = function (offset){return this.toCollection().offset(offset);};Table.prototype.limit = function (numRows){return this.toCollection().limit(numRows);};Table.prototype.each = function (callback){return this.toCollection().each(callback);};Table.prototype.toArray = function (thenShortcut){return this.toCollection().toArray(thenShortcut);};Table.prototype.toCollection = function (){return new this.db.Collection(new this.db.WhereClause(this));};Table.prototype.orderBy = function (index){return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? "[".concat(index.join('+'), "]") : index));};Table.prototype.reverse = function (){return this.toCollection().reverse();};Table.prototype.mapToClass = function (constructor){var _a = this,db = _a.db,
725tableName = _a.name;
726this.schema.mappedClass = constructor;
727if(constructor.prototype instanceof Entity){constructor = function (_super) {
728__extends(class_1, _super);
729function class_1(){return _super !== null && _super.apply(this, arguments) || this;}
730Object.defineProperty(class_1.prototype, "db", {
731get: function get(){return db;},enumerable: false,
732configurable: true
733});
734class_1.prototype.table = function (){return tableName;};return class_1;}(constructor);
735}
736var inheritedProps = new Set();
737for (var proto = constructor.prototype; proto; proto = getProto(proto)){Object.getOwnPropertyNames(proto).forEac

737h(function (propName) {
738return inheritedProps.add(propName);});
739}
740var readHook = function readHook(obj){if(!obj) return obj;
741var res = Object.create(constructor.prototype);
742for (var m in obj) if(!inheritedProps.has(m)) try {
743res[m] = obj[m];} catch (_){}
744return res;};if(this.schema.readHook){this.hook.reading.unsubscribe(this.schema.readHook);}
745this.schema.readHook = readHook;
746this.hook("reading", readHook);
747return constructor;};Table.prototype.defineClass = function (){function Class(content) {
748extend(this, content);}
749return this.mapToClass(Class);};Table.prototype.add = function (obj, key){var _this = this;
750var _a = this.schema.primKey,auto = _a.auto,
751keyPath = _a.keyPath;
752var objToAdd = obj;
753if(keyPath && auto){objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);}
754return this._trans('readwrite', function (trans){return _this.core.mutate({
755trans: trans,type: 'add',
756keys: key != null ? [key] : null,values: [objToAdd]
757});}).then(function (res){return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult;
758}).then(function (lastResult){if(keyPath) {
759try {
760setByKeyPath(obj, keyPath, lastResult);} catch (_){}}
761return lastResult;});
762};Table.prototype.update = function (keyOrObject, modifications){if(babelHelpers["typeof"](keyOrObject) === 'object' && !isArray(keyOrObject)) {
763var key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
764if(key === undefined) return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key"));
765return this.where(":id").equals(key).modify(modifications);}else{return this.where(":id").equals(keyOrObject).modify(modifications);}
766};Table.prototype.put = function (obj, key){var _this = this;
767var _a = this.schema.primKey,auto = _a.auto,
768keyPath = _a.keyPath;
769var objToAdd = obj;

vendor: 2,051 bytes, lines 770-804

770if(keyPath && auto){objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);}
771return this._trans('readwrite', function (trans){return _this.core.mutate({
772trans: trans,type: 'put',
773values: [objToAdd],keys: key != null ? [key] : null
774});}).then(function (res){return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult;
775}).then(function (lastResult){if(keyPath) {
776try {
777setByKeyPath(obj, keyPath, lastResult);} catch (_){}}
778return lastResult;});
779};Table.prototype["delete"] = function (key){var _this = this;
780return this._trans('readwrite', function (trans){return _this.core.mutate({
781trans: trans,type: 'delete',
782keys: [key]
783});}).then(function (res){return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined;
784});};Table.prototype.clear = function (){var _this = this;
785return this._trans('readwrite', function (trans){return _this.core.mutate({
786trans: trans,type: 'deleteRange',
787range: AnyRange
788});}).then(function (res){return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined;
789});};Table.prototype.bulkGet = function (keys){var _this = this;
790return this._trans('readonly', function (trans){return _this.core.getMany({
791keys: keys,trans: trans
792}).then(function (result){return result.map(function (res) {
793return _this.hook.reading.fire(res);});
794});});
795};Table.prototype.bulkAdd = function (objects, keysOrOptions, options){var _this = this;
796var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
797options = options || (keys ? undefined : keysOrOptions);
798var wantResults = options ? options.allKeys : undefined;
799return this._trans('readwrite', function (trans){var _a = _this.schema.primKey,auto = _a.auto,
800keyPath = _a.keyPath;
801if(keyPath && keys) throw new exceptions.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");
802if(keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
803var numObjects = objects.length;
804var objectsToAdd = keyPath && auto ? objects.map(workaroundForUndef

vendor: 1,251 bytes, lines 804-823

804inedPrimKey(keyPath)) : objects;
805return _this.core.mutate({
806trans: trans,type: 'add',
807keys: keys,values: objectsToAdd,
808wantResults: wantResults
809}).then(function (_a){var numFailures = _a.numFailures,results = _a.results,
810lastResult = _a.lastResult,failures = _a.failures;
811var result = wantResults ? results : lastResult;
812if(numFailures === 0) return result;
813throw new BulkError("".concat(_this.name, ".bulkAdd(): ").concat(numFailures, " of ").concat(numObjects, " operations failed"), failures);});
814});};Table.prototype.bulkPut = function (objects, keysOrOptions, options){var _this = this;
815var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
816options = options || (keys ? undefined : keysOrOptions);
817var wantResults = options ? options.allKeys : undefined;
818return this._trans('readwrite', function (trans){var _a = _this.schema.primKey,auto = _a.auto,
819keyPath = _a.keyPath;
820if(keyPath && keys) throw new exceptions.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");
821if(keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
822var numObjects = objects.length;
823var objectsToPut = keyPath && auto ? objects.map(workaroundForUndef

823inedPrimKey(keyPath)) : objects;
824return _this.core.mutate({
825trans: trans,type: 'put',
826keys: keys,values: objectsToPut,
827wantResults: wantResults
828}).then(function (_a){var numFailures = _a.numFailures,results = _a.results,
829lastResult = _a.lastResult,failures = _a.failures;
830var result = wantResults ? results : lastResult;
831if(numFailures === 0) return result;
832throw new BulkError("".concat(_this.name, ".bulkPut(): ").concat(numFailures, " of ").concat(numObjects, " operations failed"), failures);});
833});};Table.prototype.bulkUpdate = function (keysAndChanges){var _this = this;
834var coreTable = this.core;
835var keys = keysAndChanges.map(function (entry){return entry.key;});
836var changeSpecs = keysAndChanges.map(function (entry){return entry.changes;});
837var offsetMap = [];
838return this._trans('readwrite', function (trans){return coreTable.getMany({
839trans: trans,keys: keys,
840cache: 'clone'
841}).then(function (objs){var resultKeys = [];
842var resultObjs = [];
843keysAndChanges.forEach(function (_a, idx){var key = _a.key,changes = _a.changes;
844var obj = objs[idx];
845if(obj){for (var _i = 0, _b = Object.keys(changes); _i < _b.length; _i++) {
846var keyPath = _b[_i];
847var value = changes[keyPath];
848if(keyPath === _this.schema.primKey.keyPath){if(cmp(value, key) !== 0) {
849throw new exceptions.Constraint("Cannot update primary key in bulkUpdate()");}}else{setByKeyPath(obj, keyPath, value);}
850}
851offsetMap.push(idx);
852resultKeys.push(key);
853resultObjs.push(obj);}
854});
855var numEntries = resultKeys.length;
856return coreTable.mutate({
857trans: trans,type: 'put',
858keys: resultKeys,values: resultObjs,
859updates: {
860keys: keys,changeSpecs: changeSpecs
861}
862}).then(function (_a){var numFailures = _a.numFailures,failures = _a.failures;
863if(numFailures === 0) return numEntries;
864for (var _i = 0, _b = Object.keys(failures); _i < _b.length; _i++){var offset = _b[_i];
865var mappedOffset = offsetMap[Number(offset)];
866if(mappedOffset != null){var failure = failures[offset];
867delete failures[offset];
868failures[mappedOffset] = failure;}
869}
870throw new BulkError("".concat(_this.name, ".bulkUpdate(): ").concat(numFailures, " of ").concat(numEntries, " operations failed"), failures);});
871});});
872};Table.prototype.bulkDelete = function (keys){var _this = this;
873var numKeys = keys.length;
874return this._trans('readwrite', function (trans){return _this.core.mutate({
875trans: trans,type: 'delete',
876keys: keys
877});}).then(function (_a){var numFailures = _a.numFailures,lastResult = _a.lastResult,
878failures = _a.failures;
879if(numFailures === 0) return lastResult;
880throw new BulkError("".concat(_this.name, ".bulkDelete(): ").concat(numFailures, " of ").concat(numKeys, " operations failed"), failures);});
881};return Table;}();
882function Events(ctx){var evs = {};var rv = function rv(eventName, subscriber){if(subscriber) {
883var i = arguments.length,args = new Array(i - 1);
884while (--i) args[i - 1] = arguments[i];
885evs[eventName].subscribe.apply(null, args);
886return ctx;} else if(typeof eventName === 'string'){return evs[eventName];
887}
888};rv.addEventType = add;
889for (var i = 1, l = arguments.length; i < l; ++i){add(arguments[i]);}
890return rv;
891function add(eventName, chainFunction, defaultFunction){if(babelHelpers["typeof"](eventName) === 'object') return addConfiguredEvents(eventName);
892if(!chainFunction) chainFunction = reverseStoppableEventChain;
893if(!defaultFunction) defaultFunction = nop;
894var context = {
895subscribers: [],fire: defaultFunction,
896subscribe: function subscribe(cb){if(context.subscribers.indexOf(cb) === -1) {
897context.subscribers.push(cb);
898context.fire = chainFunction(context.fire, cb);}
899},unsubscribe: function unsubscribe(cb){context.subscribers = context.subscribers.filter(function (fn) {
900return fn !== cb;});
901context.fire = context.subscribers.reduce(chainFunction, defaultFunction);}
902};evs[eventName] = rv[eventName] = context;
903return context;}
904function addConfiguredEvents(cfg){keys(cfg).forEach(function (eventName) {
905var args = cfg[eventName];
906if(isArray(args)){add(eventName, cfg[eventName][0], cfg[eventName][1]);} else if(args === 'asap'){var context = add(eventName, mirror, function fire() {
907var i = arguments.length,args = new Array(i);
908while (i--) args[i] = arguments[i];

vendor: 11,331 bytes, lines 909-1103

909context.subscribers.forEach(function (fn){asap$1(function fireEvent() {
910fn.apply(null, args);});
911});});
912} else throw new exceptions.InvalidArgument("Invalid event config");});
913}
914}
915function makeClassConstructor(prototype, constructor){derive(constructor).from({
916prototype: prototype
917});
918return constructor;}
919function createTableConstructor(db){return makeClassConstructor(Table.prototype, function Table(name, tableSchema, trans) {
920this.db = db;
921this._tx = trans;
922this.name = name;
923this.schema = tableSchema;
924this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, {
925"creating": [hookCreatingChain, nop],"reading": [pureFunctionChain, mirror],
926"updating": [hookUpdatingChain, nop],"deleting": [hookDeletingChain, nop]
927});});
928}
929function isPlainKeyRange(ctx, ignoreLimitFilter){return !(ctx.filter || ctx.algorithm || ctx.or) && (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter);}
930function addFilter(ctx, fn){ctx.filter = combine(ctx.filter, fn);}
931function addReplayFilter(ctx, factory, isLimitFilter){var curr = ctx.replayFilter;
932ctx.replayFilter = curr ? function (){return combine(curr(), factory());} : factory;
933ctx.justLimit = isLimitFilter && !curr;}
934function addMatchFilter(ctx, fn){ctx.isMatch = combine(ctx.isMatch, fn);}
935function getIndexOrStore(ctx, coreSchema){if(ctx.isPrimKey) return coreSchema.primaryKey;
936var index = coreSchema.getIndexByKeyPath(ctx.index);
937if(!index) throw new exceptions.Schema("KeyPath " + ctx.index + " on object store " + coreSchema.name + " is not indexed");
938return index;}
939function openCursor(ctx, coreTable, trans){var index = getIndexOrStore(ctx, coreTable.schema);
940return coreTable.openCursor({
941trans: trans,values: !ctx.keysOnly,
942reverse: ctx.dir === 'prev',unique: !!ctx.unique,
943query: {
944index: index,range: ctx.range
945}
946});}
947function iter(ctx, fn, coreTrans, coreTable){var filter = ctx.replayFilter ? combine(ctx.filter, ctx.replayFilter()) : ctx.filter;
948if(!ctx.or){return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper);}else{var set_1 = {};var union = function union(item, cursor, advance){if(!filter || filter(cursor, advance, function (result) {
949return cursor.stop(result);}, function (err){return cursor.fail(err);
950})){var primaryKey = cursor.primaryKey;
951var key = '' + primaryKey;
952if(key === '[object ArrayBuffer]') key = '' + new Uint8Array(primaryKey);
953if(!hasOwn(set_1, key)){set_1[key] = true;
954fn(item, cursor, advance);}
955}
956};return Promise.all([ctx.or._iterate(union, coreTrans), iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper)]);}
957}
958function iterate(cursorPromise, filter, fn, valueMapper){var mappedFn = valueMapper ? function (x, c, a) {
959return fn(valueMapper(x), c, a);} : fn;
960var wrappedFn = wrap(mappedFn);
961return cursorPromise.then(function (cursor){if(cursor) {
962return cursor.start(function (){var c = function c() {
963return cursor["continue"]();};if(!filter || filter(cursor, function (advancer){return c = advancer;}, function (val){cursor.stop(val);
964c = nop;}, function (e){cursor.fail(e);
965c = nop;})) wrappedFn(cursor.value, cursor, function (advancer){return c = advancer;
966});
967c();});
968}
969});}
970var PropModSymbol = Symbol();
971var PropModification = function (){function PropModification(spec) {
972Object.assign(this, spec);}
973PropModification.prototype.execute = function (value){var _a;
974if(this.add !== undefined){var term = this.add;
975if(isArray(term)){return __spreadArray(__spreadArray([], isArray(value) ? value : [], true), term, true).sort();}
976if(typeof term === 'number') return (Number(value) || 0) + term;
977if(typeof term === 'bigint'){try {
978return BigInt(value) + term;} catch (_b){return BigInt(0) + term;
979}
980}
981throw new TypeError("Invalid term ".concat(term));}
982if(this.remove !== undefined){var subtrahend_1 = this.remove;
983if(isArray(subtrahend_1)){return isArray(value) ? value.filter(function (item) {
984return !subtrahend_1.includes(item);}).sort() : [];
985}
986if(typeof subtrahend_1 === 'number') return Number(value) - subtrahend_1;
987if(typeof subtrahend_1 === 'bigint'){try {
988return BigInt(value) - subtrahend_1;} catch (_c){return BigInt(0) - subtrahend_1;
989}
990}
991throw new TypeError("Invalid subtrahend ".concat(subtrahend_1));}
992var prefixToReplace = (_a = this.replacePrefix) === null || _a === void 0 ? void 0 : _a[0];
993if(prefixToReplace && typeof value === 'string' && value.startsWith(prefixToReplace)){return this.replacePrefix[1] + value.substring(prefixToReplace.length);}
994return value;};return PropModification;}();
995var Collection = function (){function Collection() {}
996Collection.prototype._read = function (fn, cb){var ctx = this._ctx;
997return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readonly', fn).then(cb);};Collection.prototype._write = function (fn){var ctx = this._ctx;
998return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readwrite', fn, "locked");};Collection.prototype._addAlgorithm = function (fn){var ctx = this._ctx;
999ctx.algorithm = combine(ctx.algorithm, fn);};Collection.prototype._iterate = function (fn, coreTrans){return iter(this._ctx, fn, coreTrans, this._ctx.table.core);};Collection.prototype.clone = function (props){var rv = Object.create(this.constructor.prototype),ctx = Object.create(this._ctx);
1000if(props) extend(ctx, props);
1001rv._ctx = ctx;
1002return rv;};Collection.prototype.raw = function (){this._ctx.valueMapper = null;
1003return this;};Collection.prototype.each = function (fn){var ctx = this._ctx;
1004return this._read(function (trans){return iter(ctx, fn, trans, ctx.table.core);});
1005};Collection.prototype.count = function (cb){var _this = this;
1006return this._read(function (trans){var ctx = _this._ctx;
1007var coreTable = ctx.table.core;
1008if(isPlainKeyRange(ctx, true)){return coreTable.count({
1009trans: trans,query: {
1010index: getIndexOrStore(ctx, coreTable.schema),range: ctx.range
1011}
1012}).then(function (count){return Math.min(count, ctx.limit);});}else{var count = 0;
1013return iter(ctx, function (){++count;
1014return false;}, trans, coreTable).then(function (){return count;
1015});}
1016}).then(cb);};Collection.prototype.sortBy = function (keyPath, cb){var parts = keyPath.split('.').reverse(),lastPart = parts[0],
1017lastIndex = parts.length - 1;
1018function getval(obj, i){if(i) return getval(obj[parts[i]], i - 1);
1019return obj[lastPart];}
1020var order = this._ctx.dir === "next" ? 1 : -1;
1021function sorter(a, b){var aVal = getval(a, lastIndex),bVal = getval(b, lastIndex);
1022return cmp(aVal, bVal) * order;}
1023return this.toArray(function (a){return a.sort(sorter);}).then(cb);
1024};Collection.prototype.toArray = function (cb){var _this = this;
1025return this._read(function (trans){var ctx = _this._ctx;
1026if(ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0){var valueMapper_1 = ctx.valueMapper;
1027var index = getIndexOrStore(ctx, ctx.table.core.schema);
1028return ctx.table.core.query({
1029trans: trans,limit: ctx.limit,
1030values: true,query: {
1031index: index,range: ctx.range
1032}
1033}).then(function (_a){var result = _a.result;
1034return valueMapper_1 ? result.map(valueMapper_1) : result;});}else{var a_1 = [];
1035return iter(ctx, function (item){return a_1.push(item);}, trans, ctx.table.core).then(function (){return a_1;
1036});}
1037}, cb);};Collection.prototype.offset = function (offset){var ctx = this._ctx;
1038if(offset <= 0) return this;
1039ctx.offset += offset;
1040if(isPlainKeyRange(ctx)){addReplayFilter(ctx, function () {
1041var offsetLeft = offset;
1042return function (cursor, advance){if(offsetLeft === 0) return true;
1043if(offsetLeft === 1){--offsetLeft;
1044return false;}
1045advance(function (){cursor.advance(offsetLeft);
1046offsetLeft = 0;});
1047return false;};});}else{addReplayFilter(ctx, function (){var offsetLeft = offset;
1048return function (){return --offsetLeft < 0;};});}
1049return this;};Collection.prototype.limit = function (numRows){this._ctx.limit = Math.min(this._ctx.limit, numRows);
1050addReplayFilter(this._ctx, function (){var rowsLeft = numRows;
1051return function (cursor, advance, resolve){if(--rowsLeft <= 0) advance(resolve);
1052return rowsLeft >= 0;};}, true);
1053return this;};Collection.prototype.until = function (filterFunction, bIncludeStopEntry){addFilter(this._ctx, function (cursor, advance, resolve) {
1054if(filterFunction(cursor.value)){advance(resolve);
1055return bIncludeStopEntry;}else{return true;}
1056});
1057return this;};Collection.prototype.first = function (cb){return this.limit(1).toArray(function (a) {
1058return a[0];}).then(cb);
1059};Collection.prototype.last = function (cb){return this.reverse().first(cb);};Collection.prototype.filter = function (filterFunction){addFilter(this._ctx, function (cursor) {
1060return filterFunction(cursor.value);});
1061addMatchFilter(this._ctx, filterFunction);
1062return this;};Collection.prototype.and = function (filter){return this.filter(filter);};Collection.prototype.or = function (indexName){return new this.db.WhereClause(this._ctx.table, indexName, this);};Collection.prototype.reverse = function (){this._ctx.dir = this._ctx.dir === "prev" ? "next" : "prev";
1063if(this._ondirectionchange) this._ondirectionchange(this._ctx.dir);
1064return this;};Collection.prototype.desc = function (){return this.reverse();};Collection.prototype.eachKey = function (cb){var ctx = this._ctx;
1065ctx.keysOnly = !ctx.isMatch;
1066return this.each(function (val, cursor){cb(cursor.key, cursor);});
1067};Collection.prototype.eachUniqueKey = function (cb){this._ctx.unique = "unique";
1068return this.eachKey(cb);};Collection.prototype.eachPrimaryKey = function (cb){var ctx = this._ctx;
1069ctx.keysOnly = !ctx.isMatch;
1070return this.each(function (val, cursor){cb(cursor.primaryKey, cursor);});
1071};Collection.prototype.keys = function (cb){var ctx = this._ctx;
1072ctx.keysOnly = !ctx.isMatch;
1073var a = [];
1074return this.each(function (item, cursor){a.push(cursor.key);}).then(function (){return a;
1075}).then(cb);};Collection.prototype.primaryKeys = function (cb){var ctx = this._ctx;
1076if(ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0){return this._read(function (trans) {
1077var index = getIndexOrStore(ctx, ctx.table.core.schema);
1078return ctx.table.core.query({
1079trans: trans,values: false,
1080limit: ctx.limit,query: {
1081index: index,range: ctx.range
1082}
1083});}).then(function (_a){var result = _a.result;
1084return result;}).then(cb);
1085}
1086ctx.keysOnly = !ctx.isMatch;
1087var a = [];
1088return this.each(function (item, cursor){a.push(cursor.primaryKey);}).then(function (){return a;
1089}).then(cb);};Collection.prototype.uniqueKeys = function (cb){this._ctx.unique = "unique";
1090return this.keys(cb);};Collection.prototype.firstKey = function (cb){return this.limit(1).keys(function (a) {
1091return a[0];}).then(cb);
1092};Collection.prototype.lastKey = function (cb){return this.reverse().firstKey(cb);};Collection.prototype.distinct = function (){var ctx = this._ctx,idx = ctx.index && ctx.table.schema.idxByName[ctx.index];
1093if(!idx || !idx.multi) return this;
1094var set = {};addFilter(this._ctx, function (cursor){var strKey = cursor.primaryKey.toString();
1095var found = hasOwn(set, strKey);
1096set[strKey] = true;
1097return !found;});
1098return this;};Collection.prototype.modify = function (changes){var _this = this;
1099var ctx = this._ctx;
1100return this._write(function (trans){var modifyer;
1101if(typeof changes === 'function'){modifyer = changes;}else{var keyPaths = keys(changes);
1102var numKeys = keyPaths.length;
1103modifyer = function modifyer(item){var anythingModified = false;

1104for (var i = 0; i < numKeys; ++i){var keyPath = keyPaths[i];
1105var val = changes[keyPath];
1106var origVal = getByKeyPath(item, keyPath);
1107if(val instanceof PropModification){setByKeyPath(item, keyPath, val.execute(origVal));
1108anythingModified = true;} else if(origVal !== val){setByKeyPath(item, keyPath, val);
1109anythingModified = true;}
1110}
1111return anythingModified;};}
1112var coreTable = ctx.table.core;
1113var _a = coreTable.schema.primaryKey,outbound = _a.outbound,
1114extractKey = _a.extractKey;
1115var limit = _this.db._options.modifyChunkSize || 200;
1116var totalFailures = [];
1117var successCount = 0;
1118var failedKeys = [];
1119var applyMutateResult = function applyMutateResult(expectedCount, res){var failures = res.failures,numFailures = res.numFailures;
1120successCount += expectedCount - numFailures;
1121for (var _i = 0, _a = keys(failures); _i < _a.length; _i++){var pos = _a[_i];
1122totalFailures.push(failures[pos]);}
1123};return _this.clone().primaryKeys().then(function (keys){var criteria = isPlainKeyRange(ctx) && ctx.limit === Infinity && (typeof changes !== 'function' || changes === deleteCallback) && {
1124index: ctx.index,range: ctx.range
1125};var nextChunk = function nextChunk(offset){var count = Math.min(limit, keys.length - offset);
1126return coreTable.getMany({
1127trans: trans,keys: keys.slice(offset, offset + count),
1128cache: "immutable"
1129}).then(function (values){var addValues = [];
1130var putValues = [];
1131var putKeys = outbound ? [] : null;
1132var deleteKeys = [];
1133for (var i = 0; i < count; ++i){var origValue = values[i];
1134var ctx_1 = {
1135value: deepClone(origValue),primKey: keys[offset + i]
1136};if(modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false){if(ctx_1.value == null) {
1137deleteKeys.push(keys[offset + i]);} else if(!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0){deleteKeys.push(keys[offset + i]);
1138addValues.push(ctx_1.value);}else{putValues.push(ctx_1.value);
1139if(outbound) putKeys.push(keys[offset + i]);}
1140}
1141}
1142return Promise.resolve(addValues.length > 0 && coreTable.mutate({
1143trans: trans,type: 'add',
1144values: addValues
1145}).then(function (res){for (var pos in res.failures) {
1146deleteKeys.splice(parseInt(pos), 1);}
1147applyMutateResult(addValues.length, res);})).then(function (){return (putValues.length > 0 || criteria && babelHelpers["typeof"](changes) === 'object') && coreTable.mutate({
1148trans: trans,type: 'put',
1149keys: putKeys,values: putValues,
1150criteria: criteria,changeSpec: typeof changes !== 'function' && changes,
1151isAdditionalChunk: offset > 0
1152}).then(function (res){return applyMutateResult(putValues.length, res);});
1153}).then(function (){return (deleteKeys.length > 0 || criteria && changes === deleteCallback) && coreTable.mutate({
1154trans: trans,type: 'delete',
1155keys: deleteKeys,criteria: criteria,
1156isAdditionalChunk: offset > 0
1157}).then(function (res){return applyMutateResult(deleteKeys.length, res);});
1158}).then(function (){return keys.length > offset + count && nextChunk(offset + limit);});
1159});};return nextChunk(0).then(function (){if(totalFailures.length > 0) throw new ModifyError("Error modifying one or more objects", totalFailures, successCount, failedKeys);
1160return keys.length;});
1161});});
1162};Collection.prototype["delete"] = function (){var ctx = this._ctx,range = ctx.range;
1163if(isPlainKeyRange(ctx) && (ctx.isPrimKey || range.type === 3)){return this._write(function (trans) {
1164var primaryKey = ctx.table.core.schema.primaryKey;
1165var coreRange = range;
1166return ctx.table.core.count({
1167trans: trans,query: {
1168index: primaryKey,range: coreRange
1169}
1170}).then(function (count){return ctx.table.core.mutate({
1171trans: trans,type: 'deleteRange',
1172range: coreRange
1173}).then(function (_a){var failures = _a.failures;
1174_a.lastResult;
1175_a.results;
1176var numFailures = _a.numFailures;
1177if(numFailures) throw new ModifyError("Could not delete some values", Object.keys(failures).map(function (pos){return failures[pos];}), count - numFailures);
1178return count - numFailures;});
1179});});
1180}
1181return this.modify(deleteCallback);};return Collection;}();
1182var deleteCallback = function deleteCallback(value, ctx){return ctx.value = null;};function createCollectionConstructor(db){return makeClassConstructor(Collection.prototype, function Collection(whereClause, keyRangeGenerator) {
1183this.db = db;
1184var keyRange = AnyRange,error = null;
1185if(keyRangeGenerator) try {

vendor: 9,532 bytes, lines 1186-1345

1186keyRange = keyRangeGenerator();} catch (ex){error = ex;
1187}
1188var whereCtx = whereClause._ctx;
1189var table = whereCtx.table;
1190var readingHook = table.hook.reading.fire;
1191this._ctx = {
1192table: table,index: whereCtx.index,
1193isPrimKey: !whereCtx.index || table.schema.primKey.keyPath && whereCtx.index === table.schema.primKey.name,range: keyRange,
1194keysOnly: false,dir: "next",
1195unique: "",algorithm: null,
1196filter: null,replayFilter: null,
1197justLimit: true,isMatch: null,
1198offset: 0,limit: Infinity,
1199error: error,or: whereCtx.or,
1200valueMapper: readingHook !== mirror ? readingHook : null
1201};});
1202}
1203function simpleCompare(a, b){return a < b ? -1 : a === b ? 0 : 1;}
1204function simpleCompareReverse(a, b){return a > b ? -1 : a === b ? 0 : 1;}
1205function fail(collectionOrWhereClause, err, T){var collection = collectionOrWhereClause instanceof WhereClause ? new collectionOrWhereClause.Collection(collectionOrWhereClause) : collectionOrWhereClause;
1206collection._ctx.error = T ? new T(err) : new TypeError(err);
1207return collection;}
1208function emptyCollection(whereClause){return new whereClause.Collection(whereClause, function () {
1209return rangeEqual("");}).limit(0);
1210}
1211function upperFactory(dir){return dir === "next" ? function (s) {
1212return s.toUpperCase();} : function (s){return s.toLowerCase();
1213};}
1214function lowerFactory(dir){return dir === "next" ? function (s) {
1215return s.toLowerCase();} : function (s){return s.toUpperCase();
1216};}
1217function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir){var length = Math.min(key.length, lowerNeedle.length);
1218var llp = -1;
1219for (var i = 0; i < length; ++i){var lwrKeyChar = lowerKey[i];
1220if(lwrKeyChar !== lowerNeedle[i]){if(cmp(key[i], upperNeedle[i]) < 0) return key.substr(0, i) + upperNeedle[i] + upperNeedle.substr(i + 1);
1221if(cmp(key[i], lowerNeedle[i]) < 0) return key.substr(0, i) + lowerNeedle[i] + upperNeedle.substr(i + 1);
1222if(llp >= 0) return key.substr(0, llp) + lowerKey[llp] + upperNeedle.substr(llp + 1);
1223return null;}
1224if(cmp(key[i], lwrKeyChar) < 0) llp = i;}
1225if(length < lowerNeedle.length && dir === "next") return key + upperNeedle.substr(key.length);
1226if(length < key.length && dir === "prev") return key.substr(0, upperNeedle.length);
1227return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);}
1228function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix){var upper,lower,
1229compare,upperNeedles,
1230lowerNeedles,direction,
1231nextKeySuffix,needlesLen = needles.length;
1232if(!needles.every(function (s){return typeof s === 'string';})){return fail(whereClause, STRING_EXPECTED);
1233}
1234function initDirection(dir){upper = upperFactory(dir);
1235lower = lowerFactory(dir);
1236compare = dir === "next" ? simpleCompare : simpleCompareReverse;
1237var needleBounds = needles.map(function (needle){return {
1238lower: lower(needle),upper: upper(needle)
1239};}).sort(function (a, b){return compare(a.lower, b.lower);
1240});
1241upperNeedles = needleBounds.map(function (nb){return nb.upper;});
1242lowerNeedles = needleBounds.map(function (nb){return nb.lower;});
1243direction = dir;
1244nextKeySuffix = dir === "next" ? "" : suffix;}
1245initDirection("next");
1246var c = new whereClause.Collection(whereClause, function (){return createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix);});
1247c._ondirectionchange = function (direction){initDirection(direction);};var firstPossibleNeedle = 0;
1248c._addAlgorithm(function (cursor, advance, resolve){var key = cursor.key;
1249if(typeof key !== 'string') return false;
1250var lowerKey = lower(key);
1251if(match(lowerKey, lowerNeedles, firstPossibleNeedle)){return true;}else{var lowestPossibleCasing = null;
1252for (var i = firstPossibleNeedle; i < needlesLen; ++i){var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction);
1253if(casing === null && lowestPossibleCasing === null) firstPossibleNeedle = i + 1;else if(lowestPossibleCasing === null || compare(lowestPossibleCasing, casing) > 0){lowestPossibleCasing = casing;}
1254}
1255if(lowestPossibleCasing !== null){advance(function () {
1256cursor["continue"](lowestPossibleCasing + nextKeySuffix);});}else{advance(resolve);}
1257return false;}
1258});
1259return c;}
1260function createRange(lower, upper, lowerOpen, upperOpen){return {
1261type: 2,lower: lower,
1262upper: upper,lowerOpen: lowerOpen,
1263upperOpen: upperOpen
1264};}
1265function rangeEqual(value){return {
1266type: 1,lower: value,
1267upper: value
1268};}
1269var WhereClause = function (){function WhereClause() {}
1270Object.defineProperty(WhereClause.prototype, "Collection", {
1271get: function get(){return this._ctx.table.db.Collection;},enumerable: false,
1272configurable: true
1273});
1274WhereClause.prototype.between = function (lower, upper, includeLower, includeUpper){includeLower = includeLower !== false;
1275includeUpper = includeUpper === true;
1276try {
1277if(this._cmp(lower, upper) > 0 || this._cmp(lower, upper) === 0 && (includeLower || includeUpper) && !(includeLower && includeUpper)) return emptyCollection(this);
1278return new this.Collection(this, function (){return createRange(lower, upper, !includeLower, !includeUpper);});
1279} catch (e){return fail(this, INVALID_KEY_ARGUMENT);}
1280};WhereClause.prototype.equals = function (value){if(value == null) return fail(this, INVALID_KEY_ARGUMENT);
1281return new this.Collection(this, function (){return rangeEqual(value);});
1282};WhereClause.prototype.above = function (value){if(value == null) return fail(this, INVALID_KEY_ARGUMENT);
1283return new this.Collection(this, function (){return createRange(value, undefined, true);});
1284};WhereClause.prototype.aboveOrEqual = function (value){if(value == null) return fail(this, INVALID_KEY_ARGUMENT);
1285return new this.Collection(this, function (){return createRange(value, undefined, false);});
1286};WhereClause.prototype.below = function (value){if(value == null) return fail(this, INVALID_KEY_ARGUMENT);
1287return new this.Collection(this, function (){return createRange(undefined, value, false, true);});
1288};WhereClause.prototype.belowOrEqual = function (value){if(value == null) return fail(this, INVALID_KEY_ARGUMENT);
1289return new this.Collection(this, function (){return createRange(undefined, value);});
1290};WhereClause.prototype.startsWith = function (str){if(typeof str !== 'string') return fail(this, STRING_EXPECTED);
1291return this.between(str, str + maxString, true, true);};WhereClause.prototype.startsWithIgnoreCase = function (str){if(str === "") return this.startsWith(str);
1292return addIgnoreCaseAlgorithm(this, function (x, a){return x.indexOf(a[0]) === 0;}, [str], maxString);
1293};WhereClause.prototype.equalsIgnoreCase = function (str){return addIgnoreCaseAlgorithm(this, function (x, a) {
1294return x === a[0];}, [str], "");
1295};WhereClause.prototype.anyOfIgnoreCase = function (){var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
1296if(set.length === 0) return emptyCollection(this);
1297return addIgnoreCaseAlgorithm(this, function (x, a){return a.indexOf(x) !== -1;}, set, "");
1298};WhereClause.prototype.startsWithAnyOfIgnoreCase = function (){var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
1299if(set.length === 0) return emptyCollection(this);
1300return addIgnoreCaseAlgorithm(this, function (x, a){return a.some(function (n) {
1301return x.indexOf(n) === 0;});
1302}, set, maxString);};WhereClause.prototype.anyOf = function (){var _this = this;
1303var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
1304var compare = this._cmp;
1305try {
1306set.sort(compare);} catch (e){return fail(this, INVALID_KEY_ARGUMENT);
1307}
1308if(set.length === 0) return emptyCollection(this);
1309var c = new this.Collection(this, function (){return createRange(set[0], set[set.length - 1]);});
1310c._ondirectionchange = function (direction){compare = direction === "next" ? _this._ascending : _this._descending;
1311set.sort(compare);};var i = 0;
1312c._addAlgorithm(function (cursor, advance, resolve){var key = cursor.key;
1313while (compare(key, set[i]) > 0){++i;
1314if(i === set.length){advance(resolve);
1315return false;}
1316}
1317if(compare(key, set[i]) === 0){return true;}else{advance(function (){cursor["continue"](set[i]);});
1318return false;}
1319});
1320return c;};WhereClause.prototype.notEqual = function (value){return this.inAnyRange([[minKey, value], [value, this.db._maxKey]], {
1321includeLowers: false,includeUppers: false
1322});};WhereClause.prototype.noneOf = function (){var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
1323if(set.length === 0) return new this.Collection(this);
1324try {
1325set.sort(this._ascending);} catch (e){return fail(this, INVALID_KEY_ARGUMENT);
1326}
1327var ranges = set.reduce(function (res, val){return res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]];}, null);
1328ranges.push([set[set.length - 1], this.db._maxKey]);
1329return this.inAnyRange(ranges, {
1330includeLowers: false,includeUppers: false
1331});};WhereClause.prototype.inAnyRange = function (ranges, options){var _this = this;
1332var cmp = this._cmp,ascending = this._ascending,
1333descending = this._descending,min = this._min,
1334max = this._max;
1335if(ranges.length === 0) return emptyCollection(this);
1336if(!ranges.every(function (range){return 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);
1337}
1338var includeLowers = !options || options.includeLowers !== false;
1339var includeUppers = options && options.includeUppers === true;
1340function addRange(ranges, newRange){var i = 0,l = ranges.length;
1341for (; i < l; ++i){var range = ranges[i];
1342if(cmp(newRange[0], range[1]) < 0 && cmp(newRange[1], range[0]) > 0){range[0] = min(range[0], newRange[0]);
1343range[1] = max(range[1], newRange[1]);
1344break;}
1345}

vendor: 4,743 bytes, lines 1346-1432

1346if(i === l) ranges.push(newRange);
1347return ranges;}
1348var sortDirection = ascending;
1349function rangeSorter(a, b){return sortDirection(a[0], b[0]);}
1350var set;
1351try {
1352set = ranges.reduce(addRange, []);
1353set.sort(rangeSorter);} catch (ex){return fail(this, INVALID_KEY_ARGUMENT);
1354}
1355var rangePos = 0;
1356var keyIsBeyondCurrentEntry = includeUppers ? function (key){return ascending(key, set[rangePos][1]) > 0;} : function (key){return ascending(key, set[rangePos][1]) >= 0;
1357};var keyIsBeforeCurrentEntry = includeLowers ? function (key){return descending(key, set[rangePos][0]) > 0;} : function (key){return descending(key, set[rangePos][0]) >= 0;
1358};function keyWithinCurrentRange(key){return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key);}
1359var checkKey = keyIsBeyondCurrentEntry;
1360var c = new this.Collection(this, function (){return createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers);});
1361c._ondirectionchange = function (direction){if(direction === "next") {
1362checkKey = keyIsBeyondCurrentEntry;
1363sortDirection = ascending;}else{checkKey = keyIsBeforeCurrentEntry;
1364sortDirection = descending;}
1365set.sort(rangeSorter);};c._addAlgorithm(function (cursor, advance, resolve){var key = cursor.key;
1366while (checkKey(key)){++rangePos;
1367if(rangePos === set.length){advance(resolve);
1368return false;}
1369}
1370if(keyWithinCurrentRange(key)){return true;} else if(_this._cmp(key, set[rangePos][1]) === 0 || _this._cmp(key, set[rangePos][0]) === 0){return false;}else{advance(function (){if(sortDirection === ascending) cursor["continue"](set[rangePos][0]);else cursor["continue"](set[rangePos][1]);});
1371return false;}
1372});
1373return c;};WhereClause.prototype.startsWithAnyOf = function (){var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
1374if(!set.every(function (s){return typeof s === 'string';})){return fail(this, "startsWithAnyOf() only works with strings");
1375}
1376if(set.length === 0) return emptyCollection(this);
1377return this.inAnyRange(set.map(function (str){return [str, str + maxString];}));
1378};return WhereClause;}();
1379function createWhereClauseConstructor(db){return makeClassConstructor(WhereClause.prototype, function WhereClause(table, index, orCollection) {
1380this.db = db;
1381this._ctx = {
1382table: table,index: index === ":id" ? null : index,
1383or: orCollection
1384};this._cmp = this._ascending = cmp;
1385this._descending = function (a, b){return cmp(b, a);};this._max = function (a, b){return cmp(a, b) > 0 ? a : b;};this._min = function (a, b){return cmp(a, b) < 0 ? a : b;};this._IDBKeyRange = db._deps.IDBKeyRange;
1386if(!this._IDBKeyRange) throw new exceptions.MissingAPI();});
1387}
1388function eventRejectHandler(reject){return wrap(function (event) {
1389preventDefault(event);
1390reject(event.target.error);
1391return false;});
1392}
1393function preventDefault(event){if(event.stopPropagation) event.stopPropagation();
1394if(event.preventDefault) event.preventDefault();}
1395var DEXIE_STORAGE_MUTATED_EVENT_NAME = 'storagemutated';
1396var STORAGE_MUTATED_DOM_EVENT_NAME = 'x-storagemutated-1';
1397var globalEvents = Events(null, DEXIE_STORAGE_MUTATED_EVENT_NAME);
1398var Transaction = function (){function Transaction() {}
1399Transaction.prototype._lock = function (){assert(!PSD.global);
1400++this._reculock;
1401if(this._reculock === 1 && !PSD.global) PSD.lockOwnerFor = this;
1402return this;};Transaction.prototype._unlock = function (){assert(!PSD.global);
1403if(--this._reculock === 0){if(!PSD.global) PSD.lockOwnerFor = null;
1404while (this._blockedFuncs.length > 0 && !this._locked()){var fnAndPSD = this._blockedFuncs.shift();
1405try {
1406usePSD(fnAndPSD[1], fnAndPSD[0]);} catch (e){}}
1407}
1408return this;};Transaction.prototype._locked = function (){return this._reculock && PSD.lockOwnerFor !== this;};Transaction.prototype.create = function (idbtrans){var _this = this;
1409if(!this.mode) return this;
1410var idbdb = this.db.idbdb;
1411var dbOpenError = this.db._state.dbOpenError;
1412assert(!this.idbtrans);
1413if(!idbtrans && !idbdb){switch (dbOpenError && dbOpenError.name) {
1414case "DatabaseClosedError":
1415throw new exceptions.DatabaseClosed(dbOpenError);
1416case "MissingAPIError":
1417throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError);
1418default:
1419throw new exceptions.OpenFailed(dbOpenError);}
1420}
1421if(!this.active) throw new exceptions.TransactionInactive();
1422assert(this._completion._state === null);
1423idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, {
1424durability: this.chromeTransactionDurability
1425}) : idbdb.transaction(this.storeNames, this.mode, {
1426durability: this.chromeTransactionDurability
1427}));
1428idbtrans.onerror = wrap(function (ev){preventDefault(ev);
1429_this._reject(idbtrans.error);});
1430idbtrans.onabort = wrap(function (ev){preventDefault(ev);
1431_this.active && _this._reject(new exceptions.Abort(idbtrans.error));
1432_this.active = false;

vendor: 4,265 bytes, lines 1433-1514

1433_this.on("abort").fire(ev);});
1434idbtrans.oncomplete = wrap(function (){_this.active = false;
1435_this._resolve();
1436if('mutatedParts' in idbtrans){globalEvents.storagemutated.fire(idbtrans["mutatedParts"]);}
1437});
1438return this;};Transaction.prototype._promise = function (mode, fn, bWriteLock){var _this = this;
1439if(mode === 'readwrite' && this.mode !== 'readwrite') return rejection(new exceptions.ReadOnly("Transaction is readonly"));
1440if(!this.active) return rejection(new exceptions.TransactionInactive());
1441if(this._locked()){return new DexiePromise(function (resolve, reject) {
1442_this._blockedFuncs.push([function (){_this._promise(mode, fn, bWriteLock).then(resolve, reject);}, PSD]);
1443});} else if(bWriteLock){return newScope(function () {
1444var p = new DexiePromise(function (resolve, reject){_this._lock();
1445var rv = fn(resolve, reject, _this);
1446if(rv && rv.then) rv.then(resolve, reject);});
1447p["finally"](function (){return _this._unlock();});
1448p._lib = true;
1449return p;});}else{var p = new DexiePromise(function (resolve, reject){var rv = fn(resolve, reject, _this);
1450if(rv && rv.then) rv.then(resolve, reject);});
1451p._lib = true;
1452return p;}
1453};Transaction.prototype._root = function (){return this.parent ? this.parent._root() : this;};Transaction.prototype.waitFor = function (promiseLike){var root = this._root();
1454var promise = DexiePromise.resolve(promiseLike);
1455if(root._waitingFor){root._waitingFor = root._waitingFor.then(function () {
1456return promise;});}else{root._waitingFor = promise;
1457root._waitingQueue = [];
1458var store = root.idbtrans.objectStore(root.storeNames[0]);
1459(function spin(){++root._spinCount;
1460while (root._waitingQueue.length) root._waitingQueue.shift()();
1461if(root._waitingFor) store.get(-Infinity).onsuccess = spin;})();
1462}
1463var currentWaitPromise = root._waitingFor;
1464return new DexiePromise(function (resolve, reject){promise.then(function (res) {
1465return root._waitingQueue.push(wrap(resolve.bind(null, res)));}, function (err){return root._waitingQueue.push(wrap(reject.bind(null, err)));
1466})["finally"](function (){if(root._waitingFor === currentWaitPromise) {
1467root._waitingFor = null;}
1468});});
1469};Transaction.prototype.abort = function (){if(this.active) {
1470this.active = false;
1471if(this.idbtrans) this.idbtrans.abort();
1472this._reject(new exceptions.Abort());}
1473};Transaction.prototype.table = function (tableName){var memoizedTables = this._memoizedTables || (this._memoizedTables = {});
1474if(hasOwn(memoizedTables, tableName)) return memoizedTables[tableName];
1475var tableSchema = this.schema[tableName];
1476if(!tableSchema){throw new exceptions.NotFound("Table " + tableName + " not part of transaction");}
1477var transactionBoundTable = new this.db.Table(tableName, tableSchema, this);
1478transactionBoundTable.core = this.db.core.table(tableName);
1479memoizedTables[tableName] = transactionBoundTable;
1480return transactionBoundTable;};return Transaction;}();
1481function createTransactionConstructor(db){return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
1482var _this = this;
1483this.db = db;
1484this.mode = mode;
1485this.storeNames = storeNames;
1486this.schema = dbschema;
1487this.chromeTransactionDurability = chromeTransactionDurability;
1488this.idbtrans = null;
1489this.on = Events(this, "complete", "error", "abort");
1490this.parent = parent || null;
1491this.active = true;
1492this._reculock = 0;
1493this._blockedFuncs = [];
1494this._resolve = null;
1495this._reject = null;
1496this._waitingFor = null;
1497this._waitingQueue = null;
1498this._spinCount = 0;
1499this._completion = new DexiePromise(function (resolve, reject){_this._resolve = resolve;
1500_this._reject = reject;});
1501this._completion.then(function (){_this.active = false;
1502_this.on.complete.fire();}, function (e){var wasActive = _this.active;
1503_this.active = false;
1504_this.on.error.fire(e);
1505_this.parent ? _this.parent._reject(e) : wasActive && _this.idbtrans && _this.idbtrans.abort();
1506return rejection(e);});
1507});}
1508function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey){return {
1509name: name,keyPath: keyPath,
1510unique: unique,multi: multi,
1511auto: auto,compound: compound,
1512src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
1513};}
1514function nameFromKeyPath(keyPath){return typeof keyPath === 'string' ?

1514keyPath : keyPath ? '[' + [].join.call(keyPath, '+') + ']' : "";}
1515function createTableSchema(name, primKey, indexes){return {
1516name: name,primKey: primKey,
1517indexes: indexes,mappedClass: null,
1518idxByName: arrayToObject(indexes, function (index){return [index.name, index];})
1519};}
1520function safariMultiStoreFix(storeNames){return storeNames.length === 1 ? storeNames[0] : storeNames;}
1521var _getMaxKey = function getMaxKey(IdbKeyRange){try {
1522IdbKeyRange.only([[]]);
1523_getMaxKey = function getMaxKey(){return [[]];};return [[]];} catch (e){_getMaxKey = function getMaxKey() {
1524return maxString;};return maxString;}
1525};function getKeyExtractor(keyPath){if(keyPath == null) {
1526return function (){return undefined;};} else if(typeof keyPath === 'string'){return getSinglePathKeyExtractor(keyPath);}else{return function (obj){return getByKeyPath(obj, keyPath);};}
1527}
1528function getSinglePathKeyExtractor(keyPath){var split = keyPath.split('.');
1529if(split.length === 1){return function (obj) {
1530return obj[keyPath];};}else{return function (obj){return getByKeyPath(obj, keyPath);};}
1531}
1532function arrayify(arrayLike){return [].slice.call(arrayLike);}
1533var _id_counter = 0;
1534function getKeyPathAlias(keyPath){return keyPath == null ? ":id" : typeof keyPath === 'string' ? keyPath : "[".concat(keyPath.join('+'), "]");}
1535function createDBCore(db, IdbKeyRange, tmpTrans){function extractSchema(db, trans) {
1536var tables = arrayify(db.objectStoreNames);
1537return {
1538schema: {
1539name: db.name,tables: tables.map(function (table){return trans.objectStore(table);}).map(function (store){var keyPath = store.keyPath,
1540autoIncrement = store.autoIncrement;
1541var compound = isArray(keyPath);
1542var outbound = keyPath == null;
1543var indexByKeyPath = {};var result = {
1544name: store.name,primaryKey: {
1545name: null,isPrimaryKey: true,
1546outbound: outbound,compound: compound,
1547keyPath: keyPath,autoIncrement: autoIncrement,
1548unique: true,extractKey: getKeyExtractor(keyPath)
1549},indexes: arrayify(store.indexNames).map(function (indexName){return store.index(indexName);}).map(function (index){var name = index.name,
1550unique = index.unique,multiEntry = index.multiEntry,
1551keyPath = index.keyPath;
1552var compound = isArray(keyPath);
1553var result = {
1554name: name,compound: compound,
1555keyPath: keyPath,unique: unique,
1556multiEntry: multiEntry,extractKey: getKeyExtractor(keyPath)
1557};indexByKeyPath[getKeyPathAlias(keyPath)] = result;
1558return result;}),getIndexByKeyPath: function getIndexByKeyPath(keyPath){return indexByKeyPath[getKeyPathAlias(keyPath)];}
1559};indexByKeyPath[":id"] = result.primaryKey;
1560if(keyPath != null){indexByKeyPath[getKeyPathAlias(keyPath)] = result.primaryKey;}
1561return result;})
1562},hasGetAll: tables.length > 0 && 'getAll' in trans.objectStore(tables[0]) && !(typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604)
1563};}
1564function makeIDBKeyRange(range){if(range.type === 3) return null;
1565if(range.type === 4) throw new Error("Cannot convert never type to IDBKeyRange");
1566var lower = range.lower,upper = range.upper,
1567lowerOpen = range.lowerOpen,upperOpen = range.upperOpen;
1568var idbRange = lower === undefined ? upper === undefined ? null : IdbKeyRange.upperBound(upper, !!upperOpen) : upper === undefined ? IdbKeyRange.lowerBound(lower, !!lowerOpen) : IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen);
1569return idbRange;}
1570function createDbCoreTable(tableSchema){var tableName = tableSchema.name;
1571function mutate(_a){var trans = _a.trans,type = _a.type,
1572keys = _a.keys,values = _a.values,
1573range = _a.range;
1574return new Promise(function (resolve, reject){resolve = wrap(resolve);
1575var store = trans.objectStore(tableName);
1576var outbound = store.keyPath == null;
1577var isAddOrPut = type === "put" || type === "add";
1578if(!isAddOrPut && type !== 'delete' && type !== 'deleteRange') throw new Error("Invalid operation type: " + type);
1579var length = (keys || values || {
1580length: 1
1581}).length;
1582if(keys && values && keys.length !== values.length){throw new Error("Given keys array must have same length as given values array.");}
1583if(length === 0) return resolve({
1584numFailures: 0,failures: {},
1585results: [],lastResult: undefined
1586});
1587var req;
1588var reqs = [];
1589var failures = [];
1590var numFailures = 0;
1591var errorHandler = function errorHandler(event){++numFailures;
1592preventDefault(event);};

1592if(type === 'deleteRange'){if(range.type === 4) return resolve({
1593numFailures: numFailures,failures: failures,
1594results: [],lastResult: undefined
1595});
1596if(range.type === 3) reqs.push(req = store.clear());else reqs.push(req = store["delete"](makeIDBKeyRange(range)));}else{var _a = isAddOrPut ? outbound ? [values, keys] : [values, null] : [keys, null],args1 = _a[0],
1597args2 = _a[1];
1598if(isAddOrPut){for (var i = 0; i < length; ++i) {
1599reqs.push(req = args2 && args2[i] !== undefined ? store[type](args1[i], args2[i]) : store[type](args1[i]));
1600req.onerror = errorHandler;}}else{for (var i = 0; i < length; ++i){reqs.push(req = store[type](args1[i]));
1601req.onerror = errorHandler;}
1602}
1603}
1604var done = function done(event){var lastResult = event.target.result;
1605reqs.forEach(function (req, i){return req.error != null && (failures[i] = req.error);});
1606resolve({
1607numFailures: numFailures,failures: failures,
1608results: type === "delete" ? keys : reqs.map(function (req){return req.result;}),lastResult: lastResult
1609});};req.onerror = function (event){errorHandler(event);
1610done(event);};req.onsuccess = done;});
1611}
1612function openCursor(_a){var trans = _a.trans,values = _a.values,
1613query = _a.query,reverse = _a.reverse,
1614unique = _a.unique;
1615return new Promise(function (resolve, reject){resolve = wrap(resolve);
1616var index = query.index,range = query.range;
1617var store = trans.objectStore(tableName);
1618var source = index.isPrimaryKey ? store : store.index(index.name);
1619var direction = reverse ? unique ? "prevunique" : "prev" : unique ? "nextunique" : "next";
1620var req = values || !('openKeyCursor' in source) ? source.openCursor(makeIDBKeyRange(range), direction) : source.openKeyCursor(makeIDBKeyRange(range), direction);
1621req.onerror = eventRejectHandler(reject);
1622req.onsuccess = wrap(function (ev){var cursor = req.result;
1623if(!cursor){resolve(null);
1624return;}
1625cursor.___id = ++_id_counter;
1626cursor.done = false;
1627var _cursorContinue = cursor["continue"].bind(cursor);
1628var _cursorContinuePrimaryKey = cursor.continuePrimaryKey;
1629if(_cursorContinuePrimaryKey) _cursorContinuePrimaryKey = _cursorContinuePrimaryKey.bind(cursor);
1630var _cursorAdvance = cursor.advance.bind(cursor);
1631var doThrowCursorIsNotStarted = function doThrowCursorIsNotStarted(){throw new Error("Cursor not started");};var doThrowCursorIsStopped = function doThrowCursorIsStopped(){throw new Error("Cursor not stopped");};cursor.trans = trans;
1632cursor.stop = cursor["continue"] = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsNotStarted;
1633cursor.fail = wrap(reject);
1634cursor.next = function (){var _this = this;
1635var gotOne = 1;
1636return this.start(function (){return gotOne-- ? _this["continue"]() : _this.stop();}).then(function (){return _this;
1637});};cursor.start = function (callback){var iterationPromise = new Promise(function (resolveIteration, rejectIteration) {
1638resolveIteration = wrap(resolveIteration);
1639req.onerror = eventRejectHandler(rejectIteration);
1640cursor.fail = rejectIteration;
1641cursor.stop = function (value){cursor.stop = cursor["continue"] = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsStopped;
1642resolveIteration(value);};});
1643var guardedCallback = function guardedCallback(){if(req.result) {
1644try {
1645callback();} catch (err){cursor.fail(err);
1646}}else{cursor.done = true;
1647cursor.start = function (){throw new Error("Cursor behind last entry");};cursor.stop();}
1648};req.onsuccess = wrap(function (ev){req.onsuccess = guardedCallback;
1649guardedCallback();});
1650cursor["continue"] = _cursorContinue;
1651cursor.continuePrimaryKey = _cursorContinuePrimaryKey;
1652cursor.advance = _cursorAdvance;
1653guardedCallback();
1654return iterationPromise;};resolve(cursor);}, reject);
1655});}
1656function query(hasGetAll){return function (request) {
1657return new Promise(function (resolve, reject){resolve = wrap(resolve);
1658var trans = request.trans,values = request.values,
1659limit = request.limit,query = request.query;
1660var nonInfinitLimit = limit === Infinity ? undefined : limit;
1661var index = query.index,range = query.range;
1662var store = trans.objectStore(tableName);
1663var source = index.isPrimaryKey ? store : store.index(index.name);
1664var idbKeyRange = makeIDBKeyRange(range);
1665if(limit === 0) return resolve({
1666result: []
1667});
1668if(hasGetAll){var req = values ? source.getAll(idbKeyRange, nonInfinitLimit) : source.getAllKeys(idbKeyRange, nonInfinitLimit);
1669req.onsuccess = function (event){return resolve({
1670result: event.target.result
1671});};req.onerror = eventRejectHandler(reject);}else{var count_1 = 0;
1672var req_1 = values || !('openKeyCursor' in source) ? source.openCursor(idbKeyRange) : source.openKeyCursor(idbKeyRange);
1673var result_1 = [];
1674req_1.onsuccess = function (event){var cursor = req_1.result;
1675if(!cursor) return resolve({
1676result: result_1
1677});

1678result_1.push(values ? cursor.value : cursor.primaryKey);
1679if(++count_1 === limit) return resolve({
1680result: result_1
1681});
1682cursor["continue"]();};req_1.onerror = eventRejectHandler(reject);}
1683});};}
1684return {
1685name: tableName,schema: tableSchema,
1686mutate: mutate,getMany: function getMany(_a){var trans = _a.trans,
1687keys = _a.keys;
1688return new Promise(function (resolve, reject){resolve = wrap(resolve);
1689var store = trans.objectStore(tableName);
1690var length = keys.length;
1691var result = new Array(length);
1692var keyCount = 0;
1693var callbackCount = 0;
1694var req;
1695var successHandler = function successHandler(event){var req = event.target;
1696if((result[req._pos] = req.result) != null) ;
1697if(++callbackCount === keyCount) resolve(result);};var errorHandler = eventRejectHandler(reject);
1698for (var i = 0; i < length; ++i){var key = keys[i];
1699if(key != null){req = store.get(keys[i]);
1700req._pos = i;
1701req.onsuccess = successHandler;
1702req.onerror = errorHandler;
1703++keyCount;}
1704}
1705if(keyCount === 0) resolve(result);});
1706},get: function get(_a){var trans = _a.trans,
1707key = _a.key;
1708return new Promise(function (resolve, reject){resolve = wrap(resolve);
1709var store = trans.objectStore(tableName);
1710var req = store.get(key);
1711req.onsuccess = function (event){return resolve(event.target.result);};req.onerror = eventRejectHandler(reject);});
1712},query: query(hasGetAll),
1713openCursor: openCursor,count: function count(_a){var query = _a.query,
1714trans = _a.trans;
1715var index = query.index,range = query.range;
1716return new Promise(function (resolve, reject){var store = trans.objectStore(tableName);
1717var source = index.isPrimaryKey ? store : store.index(index.name);
1718var idbKeyRange = makeIDBKeyRange(range);
1719var req = idbKeyRange ? source.count(idbKeyRange) : source.count();
1720req.onsuccess = wrap(function (ev){return resolve(ev.target.result);});
1721req.onerror = eventRejectHandler(reject);});
1722}
1723};}
1724var _a = extractSchema(db, tmpTrans),schema = _a.schema,
1725hasGetAll = _a.hasGetAll;
1726var tables = schema.tables.map(function (tableSchema){return createDbCoreTable(tableSchema);});
1727var tableMap = {};tables.forEach(function (table){return tableMap[table.name] = table;});
1728return {
1729stack: "dbcore",transaction: db.transaction.bind(db),
1730table: function table(name){var result = tableMap[name];
1731if(!result) throw new Error("Table '".concat(name, "' not found"));
1732return tableMap[name];},MIN_KEY: -Infinity,
1733MAX_KEY: _getMaxKey(IdbKeyRange),schema: schema
1734};}
1735function createMiddlewareStack(stackImpl, middlewares){return middlewares.reduce(function (down, _a) {
1736var create = _a.create;
1737return _assign(_assign({}, down), create(down));}, stackImpl);
1738}
1739function createMiddlewareStacks(middlewares, idbdb, _a, tmpTrans){var IDBKeyRange = _a.IDBKeyRange;
1740_a.indexedDB;
1741var dbcore = createMiddlewareStack(createDBCore(idbdb, IDBKeyRange, tmpTrans), middlewares.dbcore);
1742return {
1743dbcore: dbcore
1744};}
1745function generateMiddlewareStacks(db, tmpTrans){var idbdb = tmpTrans.db;
1746var stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans);
1747db.core = stacks.dbcore;
1748db.tables.forEach(function (table){var tableName = table.name;
1749if(db.core.schema.tables.some(function (tbl){return tbl.name === tableName;})){table.core = db.core.table(tableName);
1750if(db[tableName] instanceof db.Table){db[tableName].core = table.core;}
1751}
1752});}
1753function setApiOnPlace(db, objs, tableNames, dbschema){tableNames.forEach(function (tableName) {
1754var schema = dbschema[tableName];
1755objs.forEach(function (obj){var propDesc = getPropertyDescriptor(obj, tableName);
1756if(!propDesc || "value" in propDesc && propDesc.value === undefined){if(obj === db.Transaction.prototype || obj instanceof db.Transaction) {
1757setProp(obj, tableName, {
1758get: function get(){return this.table(tableName);},set: function set(value){defineProperty(this, tableName, {
1759value: value,writable: true,
1760configurable: true,enumerable: true
1761});}
1762});}else{obj[tableName] = new db.Table(tableName, schema);}
1763}
1764});});
1765}
1766function removeTablesApi(db, objs){objs.forEach(function (obj) {
1767for (var key in obj){if(obj[key] instanceof db.Table) delete obj[key];}
1768});}
1769function lowerVersionFirst(a, b){return a._cfg.version - b._cfg.version;}
1770function runUpgraders(db, oldVersion, idbUpgradeTrans, reject){var globalSchema = db._dbSchema;
1771if(idbUpgradeTrans.objectStoreNames.contains('$meta') && !globalSchema.$meta){globalSchema.$meta = createTableSchema("$meta", parseIndexSyntax("")[0], []);
1772db._storeNames.push('$meta');}
1773var trans = db._createTransaction('readwrite', db._storeNames, globalSchema);
1774trans.create(idbUpgradeTrans);
1775trans._completion["catch"](reject);
1776var rejectTransaction = trans._reject.bind(trans);
1777var transless = PSD.transless || PSD;
1778newScope(function (){PSD.trans = trans;
1779PSD.transless = transless;

vendor: 8,941 bytes, lines 1780-1926

1780if(oldVersion === 0){keys(globalSchema).forEach(function (tableName) {
1781createTable(idbUpgradeTrans, tableName, globalSchema[tableName].primKey, globalSchema[tableName].indexes);});
1782generateMiddlewareStacks(db, idbUpgradeTrans);
1783DexiePromise.follow(function (){return db.on.populate.fire(trans);})["catch"](rejectTransaction);}else{generateMiddlewareStacks(db, idbUpgradeTrans);
1784return getExistingVersion(db, trans, oldVersion).then(function (oldVersion){return updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans);})["catch"](rejectTransaction);
1785}
1786});}
1787function patchCurrentVersion(db, idbUpgradeTrans){createMissingTables(db._dbSchema, idbUpgradeTrans);
1788if(idbUpgradeTrans.db.version % 10 === 0 && !idbUpgradeTrans.objectStoreNames.contains('$meta')){idbUpgradeTrans.db.createObjectStore('$meta').add(Math.ceil(idbUpgradeTrans.db.version / 10 - 1), 'version');
1789}
1790var globalSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
1791adjustToExistingIndexNames(db, db._dbSchema, idbUpgradeTrans);
1792var diff = getSchemaDiff(globalSchema, db._dbSchema);
1793var _loop_1 = function _loop_1(tableChange){if(tableChange.change.length || tableChange.recreate) {
1794console.warn("Unable to patch indexes of table ".concat(tableChange.name, " because it has changes on the type of index or primary key."));
1795return {
1796value: void 0
1797};}
1798var store = idbUpgradeTrans.objectStore(tableChange.name);
1799tableChange.add.forEach(function (idx){if(debug) console.debug("Dexie upgrade patch: Creating missing index ".concat(tableChange.name, ".").concat(idx.src));
1800addIndex(store, idx);});
1801};for (var _i = 0, _a = diff.change; _i < _a.length; _i++){var tableChange = _a[_i];
1802var state_1 = _loop_1(tableChange);
1803if(babelHelpers["typeof"](state_1) === "object") return state_1.value;}
1804}
1805function getExistingVersion(db, trans, oldVersion){if(trans.storeNames.includes('$meta')) {
1806return trans.table('$meta').get('version').then(function (metaVersion){return metaVersion != null ? metaVersion : oldVersion;});}else{return DexiePromise.resolve(oldVersion);}
1807}
1808function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans){var queue = [];
1809var versions = db._versions;
1810var globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
1811var versToRun = versions.filter(function (v){return v._cfg.version >= oldVersion;});
1812if(versToRun.length === 0){return DexiePromise.resolve();}
1813versToRun.forEach(function (version){queue.push(function () {
1814var oldSchema = globalSchema;
1815var newSchema = version._cfg.dbschema;
1816adjustToExistingIndexNames(db, oldSchema, idbUpgradeTrans);
1817adjustToExistingIndexNames(db, newSchema, idbUpgradeTrans);
1818globalSchema = db._dbSchema = newSchema;
1819var diff = getSchemaDiff(oldSchema, newSchema);
1820diff.add.forEach(function (tuple){createTable(idbUpgradeTrans, tuple[0], tuple[1].primKey, tuple[1].indexes);});
1821diff.change.forEach(function (change){if(change.recreate) {
1822throw new exceptions.Upgrade("Not yet support for changing primary key");}else{var store_1 = idbUpgradeTrans.objectStore(change.name);
1823change.add.forEach(function (idx){return addIndex(store_1, idx);});
1824change.change.forEach(function (idx){store_1.deleteIndex(idx.name);
1825addIndex(store_1, idx);});
1826change.del.forEach(function (idxName){return store_1.deleteIndex(idxName);});
1827}
1828});
1829var contentUpgrade = version._cfg.contentUpgrade;
1830if(contentUpgrade && version._cfg.version > oldVersion){generateMiddlewareStacks(db, idbUpgradeTrans);
1831trans._memoizedTables = {};var upgradeSchema_1 = shallowClone(newSchema);
1832diff.del.forEach(function (table){upgradeSchema_1[table] = oldSchema[table];});
1833removeTablesApi(db, [db.Transaction.prototype]);
1834setApiOnPlace(db, [db.Transaction.prototype], keys(upgradeSchema_1), upgradeSchema_1);
1835trans.schema = upgradeSchema_1;
1836var contentUpgradeIsAsync_1 = isAsyncFunction(contentUpgrade);
1837if(contentUpgradeIsAsync_1){incrementExpectedAwaits();}
1838var returnValue_1;
1839var promiseFollowed = DexiePromise.follow(function (){returnValue_1 = contentUpgrade(trans);
1840if(returnValue_1){if(contentUpgradeIsAsync_1) {
1841var decrementor = decrementExpectedAwaits.bind(null, null);
1842returnValue_1.then(decrementor, decrementor);}
1843}
1844});
1845return returnValue_1 && typeof returnValue_1.then === 'function' ? DexiePromise.resolve(returnValue_1) : promiseFollowed.then(function (){return returnValue_1;});
1846}
1847});
1848queue.push(function (idbtrans){var newSchema = version._cfg.dbschema;
1849deleteRemovedTables(newSchema, idbtrans);
1850removeTablesApi(db, [db.Transaction.prototype]);
1851setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema);
1852trans.schema = db._dbSchema;});
1853queue.push(function (idbtrans){if(db.idbdb.objectStoreNames.contains('$meta')) {
1854if(Math.ceil(db.idbdb.version / 10) === version._cfg.version) {
1855db.idbdb.deleteObjectStore('$meta');
1856delete db._dbSchema.$meta;
1857db._storeNames = db._storeNames.filter(function (name){return name !== '$meta';});}else{idbtrans.objectStore('$meta').put(version._cfg.version, 'version');}
1858}
1859});});
1860function runQueue(){return queue.length ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue) : DexiePromise.resolve();}
1861return runQueue().then(function (){createMissingTables(globalSchema, idbUpgradeTrans);});
1862}
1863function getSchemaDiff(oldSchema, newSchema){var diff = {
1864del: [],add: [],
1865change: []
1866};var table;
1867for (table in oldSchema){if(!newSchema[table]) diff.del.push(table);}
1868for (table in newSchema){var oldDef = oldSchema[table],newDef = newSchema[table];
1869if(!oldDef){diff.add.push([table, newDef]);}else{var change = {
1870name: table,def: newDef,
1871recreate: false,del: [],
1872add: [],change: []
1873};if('' + (oldDef.primKey.keyPath || '') !== '' + (newDef.primKey.keyPath || '') || oldDef.primKey.auto !== newDef.primKey.auto){change.recreate = true;
1874diff.change.push(change);}else{var oldIndexes = oldDef.idxByName;
1875var newIndexes = newDef.idxByName;
1876var idxName = void 0;
1877for (idxName in oldIndexes){if(!newIndexes[idxName]) change.del.push(idxName);}
1878for (idxName in newIndexes){var oldIdx = oldIndexes[idxName],newIdx = newIndexes[idxName];
1879if(!oldIdx) change.add.push(newIdx);else if(oldIdx.src !== newIdx.src) change.change.push(newIdx);}
1880if(change.del.length > 0 || change.add.length > 0 || change.change.length > 0){diff.change.push(change);}
1881}
1882}
1883}
1884return diff;}
1885function createTable(idbtrans, tableName, primKey, indexes){var store = idbtrans.db.createObjectStore(tableName, primKey.keyPath ? {
1886keyPath: primKey.keyPath,autoIncrement: primKey.auto
1887} : {
1888autoIncrement: primKey.auto
1889});
1890indexes.forEach(function (idx){return addIndex(store, idx);});
1891return store;}
1892function createMissingTables(newSchema, idbtrans){keys(newSchema).forEach(function (tableName) {
1893if(!idbtrans.db.objectStoreNames.contains(tableName)){if(debug) console.debug('Dexie: Creating missing table', tableName);
1894createTable(idbtrans, tableName, newSchema[tableName].primKey, newSchema[tableName].indexes);}
1895});}
1896function deleteRemovedTables(newSchema, idbtrans){[].slice.call(idbtrans.db.objectStoreNames).forEach(function (storeName) {
1897return newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName);});
1898}
1899function addIndex(store, idx){store.createIndex(idx.name, idx.keyPath, {
1900unique: idx.unique,multiEntry: idx.multi
1901});}
1902function buildGlobalSchema(db, idbdb, tmpTrans){var globalSchema = {};var dbStoreNames = slice(idbdb.objectStoreNames, 0);
1903dbStoreNames.forEach(function (storeName){var store = tmpTrans.objectStore(storeName);
1904var keyPath = store.keyPath;
1905var primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", true, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string", true);
1906var indexes = [];
1907for (var j = 0; j < store.indexNames.length; ++j){var idbindex = store.index(store.indexNames[j]);
1908keyPath = idbindex.keyPath;
1909var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string", false);
1910indexes.push(index);}
1911globalSchema[storeName] = createTableSchema(storeName, primKey, indexes);});
1912return globalSchema;}
1913function readGlobalSchema(db, idbdb, tmpTrans){db.verno = idbdb.version / 10;
1914var globalSchema = db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans);
1915db._storeNames = slice(idbdb.objectStoreNames, 0);
1916setApiOnPlace(db, [db._allTables], keys(globalSchema), globalSchema);}
1917function verifyInstalledSchema(db, tmpTrans){var installedSchema = buildGlobalSchema(db, db.idbdb, tmpTrans);
1918var diff = getSchemaDiff(installedSchema, db._dbSchema);
1919return !(diff.add.length || diff.change.some(function (ch){return ch.add.length || ch.change.length;}));
1920}
1921function adjustToExistingIndexNames(db, schema, idbtrans){var storeNames = idbtrans.db.objectStoreNames;
1922for (var i = 0; i < storeNames.length; ++i){var storeName = storeNames[i];
1923var store = idbtrans.objectStore(storeName);
1924db._hasGetAll = 'getAll' in store;
1925for (var j = 0; j < store.indexNames.length; ++j){var indexName = store.indexNames[j];
1926var keyPath = store.index(indexName).keyPath;

1927var dexieName = typeof keyPath === 'string' ? keyPath : "[" + slice(keyPath).join('+') + "]";
1928if(schema[storeName]){var indexSpec = schema[storeName].idxByName[dexieName];
1929if(indexSpec){indexSpec.name = indexName;
1930delete schema[storeName].idxByName[dexieName];
1931schema[storeName].idxByName[indexName] = indexSpec;}
1932}
1933}
1934}
1935if(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) {
1936db._hasGetAll = false;}
1937}
1938function parseIndexSyntax(primKeyAndIndexes){return primKeyAndIndexes.split(',').map(function (index, indexNum) {
1939index = index.trim();
1940var name = index.replace(/([&*]|\+\+)/g, "");
1941var keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name;
1942return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0);
1943});}
1944var Version = function (){function Version() {}
1945Version.prototype._parseStoresSpec = function (stores, outSchema){keys(stores).forEach(function (tableName) {
1946if(stores[tableName] !== null){var indexes = parseIndexSyntax(stores[tableName]);
1947var primKey = indexes.shift();
1948primKey.unique = true;
1949if(primKey.multi) throw new exceptions.Schema("Primary key cannot be multi-valued");
1950indexes.forEach(function (idx){if(idx.auto) throw new exceptions.Schema("Only primary key can be marked as autoIncrement (++)");
1951if(!idx.keyPath) throw new exceptions.Schema("Index must have a name and cannot be an empty string");});
1952outSchema[tableName] = createTableSchema(tableName, primKey, indexes);}
1953});};Version.prototype.stores = function (stores){var db = this.db;
1954this._cfg.storesSource = this._cfg.storesSource ? extend(this._cfg.storesSource, stores) : stores;
1955var versions = db._versions;
1956var storesSpec = {};var dbschema = {};versions.forEach(function (version){extend(storesSpec, version._cfg.storesSource);
1957dbschema = version._cfg.dbschema = {};version._parseStoresSpec(storesSpec, dbschema);});
1958db._dbSchema = dbschema;
1959removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]);
1960setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema);
1961db._storeNames = keys(dbschema);
1962return this;};Version.prototype.upgrade = function (upgradeFunction){this._cfg.contentUpgrade = promisableChain(this._cfg.contentUpgrade || nop, upgradeFunction);
1963return this;};return Version;}();
1964function createVersionConstructor(db){return makeClassConstructor(Version.prototype, function Version(versionNumber) {
1965this.db = db;
1966this._cfg = {
1967version: versionNumber,storesSource: null,
1968dbschema: {},tables: {},
1969contentUpgrade: null
1970};});
1971}
1972function getDbNamesTable(indexedDB, IDBKeyRange){var dbNamesDB = indexedDB["_dbNamesDB"];
1973if(!dbNamesDB){dbNamesDB = indexedDB["_dbNamesDB"] = new Dexie$1(DBNAMES_DB, {
1974addons: [],indexedDB: indexedDB,
1975IDBKeyRange: IDBKeyRange
1976});
1977dbNamesDB.version(1).stores({
1978dbnames: "name"
1979});}
1980return dbNamesDB.table("dbnames");}
1981function hasDatabasesNative(indexedDB){return indexedDB && typeof indexedDB.databases === "function";}
1982function _getDatabaseNames(_a){var indexedDB = _a.indexedDB,IDBKeyRange = _a.IDBKeyRange;
1983return hasDatabasesNative(indexedDB) ? Promise.resolve(indexedDB.databases()).then(function (infos){return infos.map(function (info) {
1984return info.name;}).filter(function (name){return name !== DBNAMES_DB;
1985});}) : getDbNamesTable(indexedDB, IDBKeyRange).toCollection().primaryKeys();
1986}
1987function _onDatabaseCreated(_a, name){var indexedDB = _a.indexedDB,IDBKeyRange = _a.IDBKeyRange;
1988!hasDatabasesNative(indexedDB) && name !== DBNAMES_DB && getDbNamesTable(indexedDB, IDBKeyRange).put({
1989name: name
1990})["catch"](nop);}
1991function _onDatabaseDeleted(_a, name){var indexedDB = _a.indexedDB,IDBKeyRange = _a.IDBKeyRange;
1992!hasDatabasesNative(indexedDB) && name !== DBNAMES_DB && getDbNamesTable(indexedDB, IDBKeyRange)["delete"](name)["catch"](nop);}
1993function vip(fn){return newScope(function () {
1994PSD.letThrough = true;
1995return fn();});
1996}
1997function idbReady(){var isSafari = !navigator.userAgentData && /Safari\//.test(navigator.userAgent) && !/Chrom(e|ium)\//.test(navigator.userAgent);
1998if(!isSafari || !indexedDB.databases) return Promise.resolve();
1999var intervalId;
2000return new Promise(function (resolve){var tryIdb = function tryIdb() {
2001return indexedDB.databases()["finally"](resolve);};intervalId = setInterval(tryIdb, 100);

2002tryIdb();})["finally"](function (){return clearInterval(intervalId);
2003});}
2004var _a;
2005function isEmptyRange(node){return !("from" in node);}
2006var RangeSet = function RangeSet(fromOrTree, to){if(this) {
2007extend(this, arguments.length ? {
2008d: 1,from: fromOrTree,
2009to: arguments.length > 1 ? to : fromOrTree
2010} : {
2011d: 0
2012});}else{var rv = new RangeSet();
2013if(fromOrTree && "d" in fromOrTree){extend(rv, fromOrTree);}
2014return rv;}
2015};props(RangeSet.prototype, (_a = {
2016add: function add(rangeSet){mergeRanges(this, rangeSet);
2017return this;},addKey: function addKey(key){addRange(this, key, key);
2018return this;},addKeys: function addKeys(keys){var _this = this;
2019keys.forEach(function (key){return addRange(_this, key, key);});
2020return this;},hasKey: function hasKey(key){var node = getRangeSetIterator(this).next(key).value;
2021return node && cmp(node.from, key) <= 0 && cmp(node.to, key) >= 0;}
2022}, _a[iteratorSymbol] = function (){return getRangeSetIterator(this);}, _a));
2023function addRange(target, from, to){var diff = cmp(from, to);
2024if(isNaN(diff)) return;
2025if(diff > 0) throw RangeError();
2026if(isEmptyRange(target)) return extend(target, {
2027from: from,to: to,
2028d: 1
2029});
2030var left = target.l;
2031var right = target.r;
2032if(cmp(to, target.from) < 0){left ? addRange(left, from, to) : target.l = {
2033from: from,to: to,
2034d: 1,l: null,
2035r: null
2036};return rebalance(target);}
2037if(cmp(from, target.to) > 0){right ? addRange(right, from, to) : target.r = {
2038from: from,to: to,
2039d: 1,l: null,
2040r: null
2041};return rebalance(target);}
2042if(cmp(from, target.from) < 0){target.from = from;
2043target.l = null;
2044target.d = right ? right.d + 1 : 1;}
2045if(cmp(to, target.to) > 0){target.to = to;
2046target.r = null;
2047target.d = target.l ? target.l.d + 1 : 1;}
2048var rightWasCutOff = !target.r;
2049if(left && !target.l){mergeRanges(target, left);}
2050if(right && rightWasCutOff){mergeRanges(target, right);}
2051}
2052function mergeRanges(target, newSet){function _addRangeSet(target, _a) {
2053var from = _a.from,to = _a.to,
2054l = _a.l,r = _a.r;
2055addRange(target, from, to);
2056if(l) _addRangeSet(target, l);
2057if(r) _addRangeSet(target, r);}
2058if(!isEmptyRange(newSet)) _addRangeSet(target, newSet);}
2059function rangesOverlap(rangeSet1, rangeSet2){var i1 = getRangeSetIterator(rangeSet2);
2060var nextResult1 = i1.next();
2061if(nextResult1.done) return false;
2062var a = nextResult1.value;
2063var i2 = getRangeSetIterator(rangeSet1);
2064var nextResult2 = i2.next(a.from);
2065var b = nextResult2.value;
2066while (!nextResult1.done && !nextResult2.done){if(cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0) return true;
2067cmp(a.from, b.from) < 0 ? a = (nextResult1 = i1.next(b.from)).value : b = (nextResult2 = i2.next(a.from)).value;}
2068return false;}
2069function getRangeSetIterator(node){var state = isEmptyRange(node) ? null : {
2070s: 0,n: node
2071};return {
2072next: function next(key){var keyProvided = arguments.length > 0;
2073while (state){switch (state.s) {
2074case 0:
2075state.s = 1;
2076if(keyProvided){while (state.n.l && cmp(key, state.n.from) < 0) state = {
2077up: state,n: state.n.l,
2078s: 1
2079};}else{while (state.n.l) state = {
2080up: state,n: state.n.l,
2081s: 1
2082};}
2083case 1:
2084state.s = 2;
2085if(!keyProvided || cmp(key, state.n.to) <= 0) return {
2086value: state.n,done: false
2087};case 2:
2088if(state.n.r){state.s = 3;
2089state = {
2090up: state,n: state.n.r,
2091s: 0
2092};continue;}
2093case 3:
2094state = state.up;}
2095}
2096return {
2097done: true
2098};}
2099};}
2100function rebalance(target){var _a, _b;
2101var diff = (((_a = target.r) === null || _a === void 0 ? void 0 : _a.d) || 0) - (((_b = target.l) === null || _b === void 0 ? void 0 : _b.d) || 0);
2102var r = diff > 1 ? "r" : diff < -1 ? "l" : "";
2103if(r){var l = r === "r" ? "l" : "r";
2104var rootClone = _assign({}, target);
2105var oldRootRight = target[r];
2106target.from = oldRootRight.from;
2107target.to = oldRootRight.to;
2108target[r] = oldRootRight[r];
2109rootClone[r] = oldRootRight[l];
2110target[l] = rootClone;
2111rootClone.d = computeDepth(rootClone);}
2112target.d = computeDepth(target);}
2113function computeDepth(_a){var r = _a.r,l = _a.l;
2114return (r ? l ? Math.max(r.d, l.d) : r.d : l ? l.d : 0) + 1;}
2115function extendObservabilitySet(target, newSet){keys(newSet).forEach(function (part) {
2116if(target[part]) mergeRanges(target[part], newSet[part]);else target[part] = cloneSimpleObjectTree(newSet[part]);});
2117return target;}
2118function obsSetsOverlap(os1, os2){return os1.all || os2.all || Object.keys(os1).some(function (key) {
2119return os2[key] && rangesOverlap(os2[key], os1[key]);});
2120}
2121var cache = {};var unsignaledParts = {};var isTaskEnqueued = false;

vendor: 4,345 bytes, lines 2122-2198

2122function signalSubscribersLazily(part, optimistic){extendObservabilitySet(unsignaledParts, part);
2123if(!isTaskEnqueued){isTaskEnqueued = true;
2124setTimeout(function (){isTaskEnqueued = false;
2125var parts = unsignaledParts;
2126unsignaledParts = {};signalSubscribersNow(parts, false);}, 0);
2127}
2128}
2129function signalSubscribersNow(updatedParts, deleteAffectedCacheEntries){if(deleteAffectedCacheEntries === void 0) {
2130deleteAffectedCacheEntries = false;}
2131var queriesToSignal = new Set();
2132if(updatedParts.all){for (var _i = 0, _a = Object.values(cache); _i < _a.length; _i++) {
2133var tblCache = _a[_i];
2134collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);}}else{for (var key in updatedParts){var parts = /^idb\:\/\/(.*)\/(.*)\//.exec(key);
2135if(parts){var dbName = parts[1],tableName = parts[2];
2136var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
2137if(tblCache) collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);}
2138}
2139}
2140queriesToSignal.forEach(function (requery){return requery();});
2141}
2142function collectTableSubscribers(tblCache, updatedParts, outQueriesToSignal, deleteAffectedCacheEntries){var updatedEntryLists = [];
2143for (var _i = 0, _a = Object.entries(tblCache.queries.query); _i < _a.length; _i++){var _b = _a[_i],indexName = _b[0],
2144entries = _b[1];
2145var filteredEntries = [];
2146for (var _c = 0, entries_1 = entries; _c < entries_1.length; _c++){var entry = entries_1[_c];
2147if(obsSetsOverlap(updatedParts, entry.obsSet)){entry.subscribers.forEach(function (requery) {
2148return outQueriesToSignal.add(requery);});
2149} else if(deleteAffectedCacheEntries){filteredEntries.push(entry);}
2150}
2151if(deleteAffectedCacheEntries) updatedEntryLists.push([indexName, filteredEntries]);}
2152if(deleteAffectedCacheEntries){for (var _d = 0, updatedEntryLists_1 = updatedEntryLists; _d < updatedEntryLists_1.length; _d++) {
2153var _e = updatedEntryLists_1[_d],indexName = _e[0],
2154filteredEntries = _e[1];
2155tblCache.queries.query[indexName] = filteredEntries;}
2156}
2157}
2158function dexieOpen(db){var state = db._state;
2159var indexedDB = db._deps.indexedDB;
2160if(state.isBeingOpened || db.idbdb) return state.dbReadyPromise.then(function (){return state.dbOpenError ? rejection(state.dbOpenError) : db;});
2161state.isBeingOpened = true;
2162state.dbOpenError = null;
2163state.openComplete = false;
2164var openCanceller = state.openCanceller;
2165var nativeVerToOpen = Math.round(db.verno * 10);
2166var schemaPatchMode = false;
2167function throwIfCancelled(){if(state.openCanceller !== openCanceller) throw new exceptions.DatabaseClosed('db.open() was cancelled');}
2168var resolveDbReady = state.dbReadyResolve,upgradeTransaction = null,
2169wasCreated = false;
2170var tryOpenDB = function tryOpenDB(){return new DexiePromise(function (resolve, reject) {
2171throwIfCancelled();
2172if(!indexedDB) throw new exceptions.MissingAPI();
2173var dbName = db.name;
2174var req = state.autoSchema || !nativeVerToOpen ? indexedDB.open(dbName) : indexedDB.open(dbName, nativeVerToOpen);
2175if(!req) throw new exceptions.MissingAPI();
2176req.onerror = eventRejectHandler(reject);
2177req.onblocked = wrap(db._fireOnBlocked);
2178req.onupgradeneeded = wrap(function (e){upgradeTransaction = req.transaction;
2179if(state.autoSchema && !db._options.allowEmptyDB){req.onerror = preventDefault;
2180upgradeTransaction.abort();
2181req.result.close();
2182var delreq = indexedDB.deleteDatabase(dbName);
2183delreq.onsuccess = delreq.onerror = wrap(function (){reject(new exceptions.NoSuchDatabase("Database ".concat(dbName, " doesnt exist")));});}else{upgradeTransaction.onerror = eventRejectHandler(reject);
2184var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
2185wasCreated = oldVer < 1;
2186db.idbdb = req.result;
2187if(schemaPatchMode){patchCurrentVersion(db, upgradeTransaction);}
2188runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
2189}
2190}, reject);
2191req.onsuccess = wrap(function (){upgradeTransaction = null;
2192var idbdb = db.idbdb = req.result;
2193var objectStoreNames = slice(idbdb.objectStoreNames);
2194if(objectStoreNames.length > 0) try {
2195var tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), 'readonly');
2196if(state.autoSchema) readGlobalSchema(db, idbdb, tmpTrans);else {
2197adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
2198if(!verifyInstalledSchema(db, tmpTrans) && !schemaPatchMode){console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.ver

2198sion(). Dexie will add missing parts and increment native version number to workaround this.");
2199idbdb.close();
2200nativeVerToOpen = idbdb.version + 1;
2201schemaPatchMode = true;
2202return resolve(tryOpenDB());}
2203}
2204generateMiddlewareStacks(db, tmpTrans);} catch (e){}
2205connections.push(db);
2206idbdb.onversionchange = wrap(function (ev){state.vcFired = true;
2207db.on("versionchange").fire(ev);});
2208idbdb.onclose = wrap(function (ev){db.on("close").fire(ev);});
2209if(wasCreated) _onDatabaseCreated(db._deps, dbName);
2210resolve();}, reject);
2211})["catch"](function (err){switch (err === null || err === void 0 ? void 0 : err.name) {
2212case "UnknownError":
2213if(state.PR1398_maxLoop > 0){state.PR1398_maxLoop--;
2214console.warn('Dexie: Workaround for Chrome UnknownError on open()');
2215return tryOpenDB();}
2216break;
2217case "VersionError":
2218if(nativeVerToOpen > 0){nativeVerToOpen = 0;
2219return tryOpenDB();}
2220break;}
2221return DexiePromise.reject(err);});
2222};return DexiePromise.race([openCanceller, (typeof navigator === 'undefined' ? DexiePromise.resolve() : idbReady()).then(tryOpenDB)]).then(function (){throwIfCancelled();
2223state.onReadyBeingFired = [];
2224return DexiePromise.resolve(vip(function (){return db.on.ready.fire(db.vip);})).then(function fireRemainders(){if(state.onReadyBeingFired.length > 0) {
2225var remainders_1 = state.onReadyBeingFired.reduce(promisableChain, nop);
2226state.onReadyBeingFired = [];
2227return DexiePromise.resolve(vip(function (){return remainders_1(db.vip);})).then(fireRemainders);
2228}
2229});})["finally"](function (){if(state.openCanceller === openCanceller) {
2230state.onReadyBeingFired = null;
2231state.isBeingOpened = false;}
2232})["catch"](function (err){state.dbOpenError = err;
2233try {
2234upgradeTransaction && upgradeTransaction.abort();} catch (_a){}
2235if(openCanceller === state.openCanceller){db._close();}
2236return rejection(err);})["finally"](function (){state.openComplete = true;
2237resolveDbReady();}).then(function (){if(wasCreated) {
2238var everything_1 = {};db.tables.forEach(function (table){table.schema.indexes.forEach(function (idx) {
2239if(idx.name) everything_1["idb://".concat(db.name, "/").concat(table.name, "/").concat(idx.name)] = new RangeSet(-Infinity, [[[]]]);
2240});
2241everything_1["idb://".concat(db.name, "/").concat(table.name, "/")] = everything_1["idb://".concat(db.name, "/").concat(table.name, "/:dels")] = new RangeSet(-Infinity, [[[]]]);
2242});
2243globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME).fire(everything_1);
2244signalSubscribersNow(everything_1, true);}
2245return db;});
2246}
2247function awaitIterator(iterator){var callNext = function callNext(result) {
2248return iterator.next(result);},doThrow = function doThrow(error){return iterator["throw"](error);},
2249onSuccess = step(callNext),onError = step(doThrow);
2250function step(getNext){return function (val) {
2251var next = getNext(val),value = next.value;
2252return next.done ? value : !value || typeof value.then !== 'function' ? isArray(value) ? Promise.all(value).then(onSuccess, onError) : onSuccess(value) : value.then(onSuccess, onError);};}
2253return step(callNext)();}
2254function extractTransactionArgs(mode, _tableArgs_, scopeFunc){var i = arguments.length;
2255if(i < 2) throw new exceptions.InvalidArgument("Too few arguments");
2256var args = new Array(i - 1);
2257while (--i) args[i - 1] = arguments[i];
2258scopeFunc = args.pop();
2259var tables = flatten(args);
2260return [mode, tables, scopeFunc];}
2261function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFunc){return DexiePromise.resolve().then(function () {
2262var transless = PSD.transless || PSD;
2263var trans = db._createTransaction(mode, storeNames, db._dbSchema, parentTransaction);
2264trans.explicit = true;
2265var zoneProps = {
2266trans: trans,transless: transless
2267};if(parentTransaction){trans.idbtrans = parentTransaction.idbtrans;}else{try {
2268trans.create();
2269trans.idbtrans._explicit = true;
2270db._state.PR1398_maxLoop = 3;} catch (ex){if(ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
2271console.warn('Dexie: Need to reopen db');
2272db.close({
2273disableAutoOpen: false
2274});
2275return db.open().then(function (){return enterTransactionScope(db, mode, storeNames, null, scopeFunc);});
2276}
2277return rejection(ex);}
2278}
2279var scopeFuncIsAsync = isAsyncFunction(scopeFunc);
2280if(scopeFuncIsAsync){incrementExpectedAwaits();}
2281var returnValue;
2282var promiseFollowed = DexiePromise.follow(function (){returnValue = scopeFunc.call(trans, trans);
2283if(returnValue){if(scopeFuncIsAsync) {
2284var decrementor = decrementExpectedAwaits.bind(null, null);
2285returnValue.then(decrementor, decrementor);} else if(typeof returnValue.next === 'function' && typeof returnValue["throw"] === 'function'){returnValue = awaitIterator(returnValue);
2286}
2287}
2288}, zoneProps);
2289return (returnValue && typeof returnValue.then === 'function' ? DexiePromise.resolve(returnValue).then(function (x){return trans.active ? x : rejection(new exceptions.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn"));
2290}) : promiseFollowed.then(function (){return returnValue;})).then(function (x){if(parentTransaction) trans._resolve();
2291return trans._completion.then(function (){return x;});
2292})["catch"](function (e){trans._reject(e);
2293return rejection(e);});
2294});}
2295function pad(a, value, count){var result = isArray(a) ? a.slice() : [a];
2296for (var i = 0; i < count; ++i) result.push(value);
2297return result;}
2298function createVirtualIndexMiddleware(down){return _assign(_assign({}, down), {
2299table: function table(tableName){var table = down.table(tableName);
2300var schema = table.schema;
2301var indexLookup = {};

2301var allVirtualIndexes = [];
2302function addVirtualIndexes(keyPath, keyTail, lowLevelIndex){var keyPathAlias = getKeyPathAlias(keyPath);
2303var indexList = indexLookup[keyPathAlias] = indexLookup[keyPathAlias] || [];
2304var keyLength = keyPath == null ? 0 : typeof keyPath === 'string' ? 1 : keyPath.length;
2305var isVirtual = keyTail > 0;
2306var virtualIndex = _assign(_assign({}, lowLevelIndex), {
2307name: isVirtual ? "".concat(keyPathAlias, "(virtual-from:").concat(lowLevelIndex.name, ")") : lowLevelIndex.name,lowLevelIndex: lowLevelIndex,
2308isVirtual: isVirtual,keyTail: keyTail,
2309keyLength: keyLength,extractKey: getKeyExtractor(keyPath),
2310unique: !isVirtual && lowLevelIndex.unique
2311});
2312indexList.push(virtualIndex);
2313if(!virtualIndex.isPrimaryKey){allVirtualIndexes.push(virtualIndex);}
2314if(keyLength > 1){var virtualKeyPath = keyLength === 2 ? keyPath[0] : keyPath.slice(0, keyLength - 1);
2315addVirtualIndexes(virtualKeyPath, keyTail + 1, lowLevelIndex);}
2316indexList.sort(function (a, b){return a.keyTail - b.keyTail;});
2317return virtualIndex;}

vendor: 1,354 bytes, lines 2318-2343

2318var primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey);
2319indexLookup[":id"] = [primaryKey];
2320for (var _i = 0, _a = schema.indexes; _i < _a.length; _i++){var index = _a[_i];
2321addVirtualIndexes(index.keyPath, 0, index);}
2322function findBestIndex(keyPath){var result = indexLookup[getKeyPathAlias(keyPath)];
2323return result && result[0];}
2324function translateRange(range, keyTail){return {
2325type: range.type === 1 ? 2 : range.type,lower: pad(range.lower, range.lowerOpen ? down.MAX_KEY : down.MIN_KEY, keyTail),
2326lowerOpen: true,upper: pad(range.upper, range.upperOpen ? down.MIN_KEY : down.MAX_KEY, keyTail),
2327upperOpen: true
2328};}
2329function translateRequest(req){var index = req.query.index;
2330return index.isVirtual ? _assign(_assign({}, req), {
2331query: {
2332index: index.lowLevelIndex,range: translateRange(req.query.range, index.keyTail)
2333}
2334}) : req;}
2335var result = _assign(_assign({}, table), {
2336schema: _assign(_assign({}, schema), {
2337primaryKey: primaryKey,indexes: allVirtualIndexes,
2338getIndexByKeyPath: findBestIndex
2339}),count: function count(req){return table.count(translateRequest(req));},
2340query: function query(req){return table.query(translateRequest(req));},openCursor: function openCursor(req){var _a = req.query.index,
2341keyTail = _a.keyTail,isVirtual = _a.isVirtual,
2342keyLength = _a.keyLength;
2343if(!isVirtual) return table.openCursor(req);

2344function createVirtualCursor(cursor){function _continue(key) {
2345key != 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"]();}
2346var virtualCursor = Object.create(cursor, {
2347"continue": {
2348value: _continue
2349},continuePrimaryKey: {
2350value: function value(key, primaryKey){cursor.continuePrimaryKey(pad(key, down.MAX_KEY, keyTail), primaryKey);}
2351},primaryKey: {
2352get: function get(){return cursor.primaryKey;}
2353},key: {
2354get: function get(){var key = cursor.key;
2355return keyLength === 1 ? key[0] : key.slice(0, keyLength);}
2356},value: {
2357get: function get(){return cursor.value;}
2358}
2359});
2360return virtualCursor;}
2361return table.openCursor(translateRequest(req)).then(function (cursor){return cursor && createVirtualCursor(cursor);});
2362}
2363});
2364return result;}
2365});}
2366var virtualIndexMiddleware = {
2367stack: "dbcore",name: "VirtualIndexMiddleware",
2368level: 1,create: createVirtualIndexMiddleware
2369};function getObjectDiff(a, b, rv, prfx){rv = rv || {};prfx = prfx || '';
2370keys(a).forEach(function (prop){if(!hasOwn(b, prop)) {
2371rv[prfx + prop] = undefined;}else{var ap = a[prop],bp = b[prop];
2372if(babelHelpers["typeof"](ap) === 'object' && babelHelpers["typeof"](bp) === 'object' && ap && bp){var apTypeName = toStringTag(ap);
2373var bpTypeName = toStringTag(bp);
2374if(apTypeName !== bpTypeName){rv[prfx + prop] = b[prop];} else if(apTypeName === 'Object'){getObjectDiff(ap, bp, rv, prfx + prop + '.');
2375} else if(ap !== bp){rv[prfx + prop] = b[prop];}
2376} else if(ap !== bp) rv[prfx + prop] = b[prop];}
2377});
2378keys(b).forEach(function (prop){if(!hasOwn(a, prop)) {
2379rv[prfx + prop] = b[prop];}
2380});
2381return rv;}
2382function getEffectiveKeys(primaryKey, req){if(req.type === 'delete') return req.keys;
2383return req.keys || req.values.map(primaryKey.extractKey);}
2384var hooksMiddleware = {
2385stack: "dbcore",name: "HooksMiddleware",
2386level: 2,create: function create(downCore){return _assign(_assign({}, downCore), {
2387table: function table(tableName){var downTable = downCore.table(tableName);
2388var primaryKey = downTable.schema.primaryKey;
2389var tableMiddleware = _assign(_assign({}, downTable), {
2390mutate: function mutate(req){var dxTrans = PSD.trans;
2391var _a = dxTrans.table(tableName).hook,deleting = _a.deleting,
2392creating = _a.creating,updating = _a.updating;
2393switch (req.type){case 'add':
2394if(creating.fire === nop) break;
2395return dxTrans._promise('readwrite', function (){return addPutOrDelete(req);}, true);
2396case 'put':
2397if(creating.fire === nop && updating.fire === nop) break;
2398return dxTrans._promise('readwrite', function (){return addPutOrDelete(req);}, true);
2399case 'delete':
2400if(deleting.fire === nop) break;
2401return dxTrans._promise('readwrite', function (){return addPutOrDelete(req);}, true);
2402case 'deleteRange':
2403if(deleting.fire === nop) break;
2404return dxTrans._promise('readwrite', function (){return deleteRange(req);}, true);
2405}
2406return downTable.mutate(req);
2407function addPutOrDelete(req){var dxTrans = PSD.trans;
2408var keys = req.keys || getEffectiveKeys(primaryKey, req);
2409if(!keys) throw new Error("Keys missing");
2410req = req.type === 'add' || req.type === 'put' ? _assign(_assign({}, req), {
2411keys: keys
2412}) : _assign({}, req);
2413if(req.type !== 'delete') req.values = __spreadArray([], req.values, true);
2414if(req.keys) req.keys = __spreadArray([], req.keys, true);
2415return getExistingValues(downTable, req, keys).then(function (existingValues){var contexts = keys.map(function (key, i) {

vendor: 1,482 bytes, lines 2416-2440

2416var existingValue = existingValues[i];
2417var ctx = {
2418onerror: null,onsuccess: null
2419};if(req.type === 'delete'){deleting.fire.call(ctx, key, existingValue, dxTrans);} else if(req.type === 'add' || existingValue === undefined){var generatedPrimaryKey = creating.fire.call(ctx, key, req.values[i], dxTrans);
2420if(key == null && generatedPrimaryKey != null){key = generatedPrimaryKey;
2421req.keys[i] = key;
2422if(!primaryKey.outbound){setByKeyPath(req.values[i], primaryKey.keyPath, key);}
2423}}else{var objectDiff = getObjectDiff(existingValue, req.values[i]);
2424var additionalChanges_1 = updating.fire.call(ctx, objectDiff, key, existingValue, dxTrans);
2425if(additionalChanges_1){var requestedValue_1 = req.values[i];
2426Object.keys(additionalChanges_1).forEach(function (keyPath){if(hasOwn(requestedValue_1, keyPath)) {
2427requestedValue_1[keyPath] = additionalChanges_1[keyPath];}else{setByKeyPath(requestedValue_1, keyPath, additionalChanges_1[keyPath]);}
2428});}
2429}
2430return ctx;});
2431return downTable.mutate(req).then(function (_a){var failures = _a.failures,results = _a.results,
2432numFailures = _a.numFailures,lastResult = _a.lastResult;
2433for (var i = 0; i < keys.length; ++i){var primKey = results ? results[i] : keys[i];
2434var ctx = contexts[i];
2435if(primKey == null){ctx.onerror && ctx.onerror(failures[i]);}else{ctx.onsuccess && ctx.onsuccess(req.type === 'put' && existingValues[i] ? req.values[i] : primKey);}
2436}
2437return {
2438failures: failures,results: results,
2439numFailures: numFailures,lastResult: lastResult
2440};}

2440)["catch"](function (error){contexts.forEach(function (ctx) {
2441return ctx.onerror && ctx.onerror(error);});
2442return Promise.reject(error);});
2443});}
2444function deleteRange(req){return deleteNextChunk(req.trans, req.range, 10000);}
2445function deleteNextChunk(trans, range, limit){return downTable.query({
2446trans: trans,values: false,
2447query: {
2448index: primaryKey,range: range
2449},limit: limit
2450}).then(function (_a){var result = _a.result;
2451return addPutOrDelete({
2452type: 'delete',keys: result,
2453trans: trans
2454}).then(function (res){if(res.numFailures > 0) return Promise.reject(res.failures[0]);
2455if(result.length < limit){return {
2456failures: [],numFailures: 0,
2457lastResult: undefined
2458};}else{return deleteNextChunk(trans, _assign(_assign({}, range), {
2459lower: result[result.length - 1],lowerOpen: true
2460}), limit);}
2461});});
2462}
2463}
2464});
2465return tableMiddleware;}
2466});}
2467};function getExistingValues(table, req, effectiveKeys){return req.type === "add" ? Promise.resolve([]) : table.getMany({
2468trans: req.trans,keys: effectiveKeys,
2469cache: "immutable"
2470});}
2471function getFromTransactionCache(keys, cache, clone){try {
2472if(!cache) return null;
2473if(cache.keys.length < keys.length) return null;
2474var result = [];
2475for (var i = 0, j = 0; i < cache.keys.length && j < keys.length; ++i){if(cmp(cache.keys[i], keys[j]) !== 0) continue;
2476result.push(clone ? deepClone(cache.values[i]) : cache.values[i]);
2477++j;}
2478return result.length === keys.length ? result : null;} catch (_a){return null;
2479}
2480}
2481var cacheExistingValuesMiddleware = {
2482stack: "dbcore",level: -1,
2483create: function create(core){return {
2484table: function table(tableName){var table = core.table(tableName);
2485return _assign(_assign({}, table), {
2486getMany: function getMany(req){if(!req.cache) {
2487return table.getMany(req);}
2488var cachedResult = getFromTransactionCache(req.keys, req.trans["_cache"], req.cache === "clone");
2489if(cachedResult){return DexiePromise.resolve(cachedResult);}
2490return table.getMany(req).then(function (res){req.trans["_cache"] = {
2491keys: req.keys,values: req.cache === "clone" ? deepClone(res) : res
2492};return res;});
2493},mutate: function mutate(req){if(req.type !== "add") req.trans["_cache"] = null;
2494return table.mutate(req);}
2495});}
2496};}
2497};function isCachableContext(ctx, table){return ctx.trans.mode === 'readonly' && !!ctx.subscr && !ctx.trans.explicit && ctx.trans.db._options.cache !== 'disabled' && !table.schema.primaryKey.outbound;}
2498function isCachableRequest(type, req){switch (type) {
2499case 'query':
2500return req.values && !req.unique;
2501case 'get':
2502return false;
2503case 'getMany':
2504return false;
2505case 'count':
2506return false;
2507case 'openCursor':
2508return false;}
2509}
2510var observabilityMiddleware = {
2511stack: "dbcore",level: 0,
2512name: "Observability",create: function create(core){var dbName = core.schema.name;
2513var FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY);
2514return _assign(_assign({}, core), {
2515transaction: function transaction(stores, mode, options){if(PSD.subscr && mode !== 'readonly') {
2516throw new exceptions.ReadOnly("Readwrite transaction in liveQuery context. Querier source: ".concat(PSD.querier));}
2517return core.transaction(stores, mode, options);},table: function table(tableName){var table = core.table(tableName);
2518var schema = table.schema;
2519var primaryKey = schema.primaryKey,indexes = schema.indexes;
2520var extractKey = primaryKey.extractKey,outbound = primaryKey.outbound;
2521var indexesWithAutoIncPK = primaryKey.autoIncrement && indexes.filter(function (index){return index.compound && index.keyPath.includes(primaryKey.keyPath);});
2522var tableClone = _assign(_assign({}, table), {
2523mutate: function mutate(req){var _a, _b;
2524var trans = req.trans;
2525var mutatedParts = req.mutatedParts || (req.mutatedParts = {});
2526var getRangeSet = function getRangeSet(indexName){var part = "idb://".concat(dbName, "/").concat(tableName, "/").concat(indexName);
2527return mutatedParts[part] || (mutatedParts[part] = new RangeSet());};var pkRangeSet = getRangeSet("");
2528var delsRangeSet = getRangeSet(":dels");
2529var type = req.type;
2530var _c = req.type === "deleteRange" ? [req.range] : req.type === "delete" ? [req.keys] : req.values.length < 50 ? [getEffectiveKeys(primaryKey, req).filter(function (id){return id;}), req.values] : [],keys = _c[0],
2531newObjs = _c[1];
2532var oldCache = req.trans["_cache"];
2533if(isArray(keys)){pkRangeSet.addKeys(keys);
2534var oldObjs = type === 'delete' || keys.length === newObjs.length ? getFromTransactionCache(keys, oldCache) : null;
2535if(!oldObjs){delsRangeSet.addKeys(keys);}
2536if(oldObjs || newObjs){trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs);}
2537} else if(keys){var range = {
2538from: (_a = keys.lower) !== null && _a !== void 0 ? _a : core.MIN_KEY,to: (_b = keys.upper) !== null && _b !== void 0 ? _b : core.MAX_KEY
2539};delsRangeSet.add(range);
2540pkRangeSet.add(range);}else{pkRangeSet.add(FULL_RANGE);
2541delsRangeSet.add(FULL_RANGE);

2542schema.indexes.forEach(function (idx){return getRangeSet(idx.name).add(FULL_RANGE);});
2543}
2544return table.mutate(req).then(function (res){if(keys && (req.type === 'add' || req.type === 'put')) {
2545pkRangeSet.addKeys(res.results);
2546if(indexesWithAutoIncPK){indexesWithAutoIncPK.forEach(function (idx) {
2547var idxVals = req.values.map(function (v){return idx.extractKey(v);});
2548var pkPos = idx.keyPath.findIndex(function (prop){return prop === primaryKey.keyPath;});
2549res.results.forEach(function (pk){return idxVals[pkPos] = pk;});
2550getRangeSet(idx.name).addKeys(idxVals);});
2551}
2552}
2553trans.mutatedParts = extendObservabilitySet(trans.mutatedParts || {}, mutatedParts);
2554return res;});
2555}
2556});
2557var getRange = function getRange(_a){var _b, _c;
2558var _d = _a.query,index = _d.index,
2559range = _d.range;
2560return [index, new RangeSet((_b = range.lower) !== null && _b !== void 0 ? _b : core.MIN_KEY, (_c = range.upper) !== null && _c !== void 0 ? _c : core.MAX_KEY)];};var readSubscribers = {
2561get: function get(req){return [primaryKey, new RangeSet(req.key)];},getMany: function getMany(req){return [primaryKey, new RangeSet().addKeys(req.keys)];},
2562count: getRange,query: getRange,
2563openCursor: getRange
2564};keys(readSubscribers).forEach(function (method){tableClone[method] = function (req) {
2565var subscr = PSD.subscr;
2566var isLiveQuery = !!subscr;
2567var cachable = isCachableContext(PSD, table) && isCachableRequest(method, req);
2568var obsSet = cachable ? req.obsSet = {} : subscr;
2569if(isLiveQuery){var getRangeSet = function getRangeSet(indexName) {
2570var part = "idb://".concat(dbName, "/").concat(tableName, "/").concat(indexName);
2571return obsSet[part] || (obsSet[part] = new RangeSet());};var pkRangeSet_1 = getRangeSet("");
2572var delsRangeSet_1 = getRangeSet(":dels");
2573var _a = readSubscribers[method](req),queriedIndex = _a[0],
2574queriedRanges = _a[1];
2575if(method === 'query' && queriedIndex.isPrimaryKey && !req.values){delsRangeSet_1.add(queriedRanges);}else{getRangeSet(queriedIndex.name || "").add(queriedRanges);}
2576if(!queriedIndex.isPrimaryKey){if(method === "count") {
2577delsRangeSet_1.add(FULL_RANGE);}else{var keysPromise_1 = method === "query" && outbound && req.values && table.query(_assign(_assign({}, req), {
2578values: false
2579}));
2580return table[method].apply(this, arguments).then(function (res){if(method === "query") {
2581if(outbound && req.values){return keysPromise_1.then(function (_a) {
2582var resultingKeys = _a.result;
2583pkRangeSet_1.addKeys(resultingKeys);
2584return res;});
2585}
2586var pKeys = req.values ? res.result.map(extractKey) : res.result;
2587if(req.values){pkRangeSet_1.addKeys(pKeys);}else{delsRangeSet_1.addKeys(pKeys);}
2588} else if(method === "openCursor"){var cursor_1 = res;
2589var wantValues_1 = req.values;
2590return cursor_1 && Object.create(cursor_1, {
2591key: {
2592get: function get(){delsRangeSet_1.addKey(cursor_1.primaryKey);
2593return cursor_1.key;}
2594},primaryKey: {
2595get: function get(){var pkey = cursor_1.primaryKey;
2596delsRangeSet_1.addKey(pkey);
2597return pkey;}
2598},value: {
2599get: function get(){wantValues_1 && pkRangeSet_1.addKey(cursor_1.primaryKey);
2600return cursor_1.value;}
2601}
2602});}
2603return res;});
2604}
2605}
2606}
2607return table[method].apply(this, arguments);};});
2608return tableClone;}
2609});}
2610};function trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs){function addAffectedIndex(ix) {
2611var rangeSet = getRangeSet(ix.name || "");
2612function extractKey(obj){return obj != null ? ix.extractKey(obj) : null;}
2613var addKeyOrKeys = function addKeyOrKeys(key){return ix.multiEntry && isArray(key) ? key.forEach(function (key) {
2614return rangeSet.addKey(key);}) : rangeSet.addKey(key);
2615};(oldObjs || newObjs).forEach(function (_, i){var oldKey = oldObjs && extractKey(oldObjs[i]);
2616var newKey = newObjs && extractKey(newObjs[i]);
2617if(cmp(oldKey, newKey) !== 0){if(oldKey != null) addKeyOrKeys(oldKey);
2618if(newKey != null) addKeyOrKeys(newKey);}
2619});}
2620schema.indexes.forEach(addAffectedIndex);}
2621function adjustOptimisticFromFailures(tblCache, req, res){if(res.numFailures === 0) return req;
2622if(req.type === 'deleteRange'){return null;}
2623var numBulkOps = req.keys ? req.keys.length : 'values' in req && req.values ? req.values.length : 1;
2624if(res.numFailures === numBulkOps){return null;}
2625var clone = _assign({}, req);

vendor: 3,213 bytes, lines 2626-2684

2626if(isArray(clone.keys)){clone.keys = clone.keys.filter(function (_, i) {
2627return !(i in res.failures);});
2628}
2629if('values' in clone && isArray(clone.values)){clone.values = clone.values.filter(function (_, i) {
2630return !(i in res.failures);});
2631}
2632return clone;}
2633function isAboveLower(key, range){return range.lower === undefined ? true : range.lowerOpen ? cmp(key, range.lower) > 0 : cmp(key, range.lower) >= 0;}
2634function isBelowUpper(key, range){return range.upper === undefined ? true : range.upperOpen ? cmp(key, range.upper) < 0 : cmp(key, range.upper) <= 0;}
2635function isWithinRange(key, range){return isAboveLower(key, range) && isBelowUpper(key, range);}
2636function applyOptimisticOps(result, req, ops, table, cacheEntry, immutable){if(!ops || ops.length === 0) return result;
2637var index = req.query.index;
2638var multiEntry = index.multiEntry;
2639var queryRange = req.query.range;
2640var primaryKey = table.schema.primaryKey;
2641var extractPrimKey = primaryKey.extractKey;
2642var extractIndex = index.extractKey;
2643var extractLowLevelIndex = (index.lowLevelIndex || index).extractKey;
2644var finalResult = ops.reduce(function (result, op){var modifedResult = result;
2645var includedValues = [];
2646if(op.type === 'add' || op.type === 'put'){var includedPKs = new RangeSet();
2647for (var i = op.values.length - 1; i >= 0; --i){var value = op.values[i];
2648var pk = extractPrimKey(value);
2649if(includedPKs.hasKey(pk)) continue;
2650var key = extractIndex(value);
2651if(multiEntry && isArray(key) ? key.some(function (k){return isWithinRange(k, queryRange);}) : isWithinRange(key, queryRange)){includedPKs.addKey(pk);
2652includedValues.push(value);}
2653}
2654}
2655switch (op.type){case 'add':
2656{
2657var existingKeys_1 = new RangeSet().addKeys(req.values ? result.map(function (v){return extractPrimKey(v);}) : result);
2658modifedResult = result.concat(req.values ? includedValues.filter(function (v){var key = extractPrimKey(v);
2659if(existingKeys_1.hasKey(key)) return false;
2660existingKeys_1.addKey(key);
2661return true;}) : includedValues.map(function (v){return extractPrimKey(v);
2662}).filter(function (k){if(existingKeys_1.hasKey(k)) return false;
2663existingKeys_1.addKey(k);
2664return true;}));
2665break;}
2666case 'put':
2667{
2668var keySet_1 = new RangeSet().addKeys(op.values.map(function (v){return extractPrimKey(v);}));
2669modifedResult = result.filter(function (item){return !keySet_1.hasKey(req.values ? extractPrimKey(item) : item);}).concat(req.values ? includedValues : includedValues.map(function (v){return extractPrimKey(v);
2670}));
2671break;}
2672case 'delete':
2673var keysToDelete_1 = new RangeSet().addKeys(op.keys);
2674modifedResult = result.filter(function (item){return !keysToDelete_1.hasKey(req.values ? extractPrimKey(item) : item);});
2675break;
2676case 'deleteRange':
2677var range_1 = op.range;
2678modifedResult = result.filter(function (item){return !isWithinRange(extractPrimKey(item), range_1);});
2679break;}
2680return modifedResult;}, result);
2681if(finalResult === result) return result;
2682finalResult.sort(function (a, b){return cmp(extractLowLevelIndex(a), extractLowLevelIndex(b)) || cmp(extractPrimKey(a), extractPrimKey(b));});
2683if(req.limit && req.limit < Infinity){if(finalResult.length > req.limit) {
2684finalResult.length = req.limit;} else if(result.length === req.limit && finalResult.length < req.limit){cac

2684heEntry.dirty = true;
2685}
2686}
2687return immutable ? Object.freeze(finalResult) : finalResult;}
2688function areRangesEqual(r1, r2){return cmp(r1.lower, r2.lower) === 0 && cmp(r1.upper, r2.upper) === 0 && !!r1.lowerOpen === !!r2.lowerOpen && !!r1.upperOpen === !!r2.upperOpen;}
2689function compareLowers(lower1, lower2, lowerOpen1, lowerOpen2){if(lower1 === undefined) return lower2 !== undefined ? -1 : 0;
2690if(lower2 === undefined) return 1;
2691var c = cmp(lower1, lower2);
2692if(c === 0){if(lowerOpen1 && lowerOpen2) return 0;
2693if(lowerOpen1) return 1;
2694if(lowerOpen2) return -1;}
2695return c;}
2696function compareUppers(upper1, upper2, upperOpen1, upperOpen2){if(upper1 === undefined) return upper2 !== undefined ? 1 : 0;
2697if(upper2 === undefined) return -1;
2698var c = cmp(upper1, upper2);
2699if(c === 0){if(upperOpen1 && upperOpen2) return 0;
2700if(upperOpen1) return -1;
2701if(upperOpen2) return 1;}
2702return c;}
2703function isSuperRange(r1, r2){return compareLowers(r1.lower, r2.lower, r1.lowerOpen, r2.lowerOpen) <= 0 && compareUppers(r1.upper, r2.upper, r1.upperOpen, r2.upperOpen) >= 0;}
2704function findCompatibleQuery(dbName, tableName, type, req){var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
2705if(!tblCache) return [];
2706var queries = tblCache.queries[type];
2707if(!queries) return [null, false, tblCache, null];
2708var indexName = req.query ? req.query.index.name : null;
2709var entries = queries[indexName || ''];
2710if(!entries) return [null, false, tblCache, null];
2711switch (type){case 'query':
2712var equalEntry = entries.find(function (entry){return entry.req.limit === req.limit && entry.req.values === req.values && areRangesEqual(entry.req.query.range, req.query.range);});
2713if(equalEntry) return [equalEntry, true, tblCache, entries];
2714var superEntry = entries.find(function (entry){var limit = 'limit' in entry.req ? entry.req.limit : Infinity;
2715return limit >= req.limit && (req.values ? entry.req.values : true) && isSuperRange(entry.req.query.range, req.query.range);});
2716return [superEntry, false, tblCache, entries];
2717case 'count':
2718var countQuery = entries.find(function (entry){return areRangesEqual(entry.req.query.range, req.query.range);});
2719return [countQuery, !!countQuery, tblCache, entries];}
2720}
2721function subscribeToCacheEntry(cacheEntry, container, requery, signal){cacheEntry.subscribers.add(requery);
2722signal.addEventListener("abort", function (){cacheEntry.subscribers["delete"](requery);
2723if(cacheEntry.subscribers.size === 0){enqueForDeletion(cacheEntry, container);}
2724});}
2725function enqueForDeletion(cacheEntry, container){setTimeout(function () {
2726if(cacheEntry.subscribers.size === 0){delArrayItem(container, cacheEntry);}
2727}, 3000);}
2728var cacheMiddleware = {
2729stack: 'dbcore',level: 0,
2730name: 'Cache',create: function create(core){var dbName = core.schema.name;
2731var coreMW = _assign(_assign({}, core), {
2732transaction: function transaction(stores, mode, options){var idbtrans = core.transaction(stores, mode, options);
2733if(mode === 'readwrite'){var ac_1 = new AbortController();
2734var signal = ac_1.signal;
2735var endTransaction = function endTransaction(wasCommitted){return function () {
2736ac_1.abort();
2737if(mode === 'readwrite'){var affectedSubscribers_1 = new Set();
2738for (var _i = 0, stores_1 = stores; _i < stores_1.length; _i++){var storeName = stores_1[_i];
2739var tblCache = cache["idb://".concat(dbName, "/").concat(storeName)];
2740if(tblCache){var table = core.table(storeName);
2741var ops = tblCache.optimisticOps.filter(function (op){return op.trans === idbtrans;});
2742if(idbtrans._explicit && wasCommitted && idbtrans.mutatedParts){for (var _a = 0, _b = Object.values(tblCache.queries.query); _a < _b.length; _a++) {
2743var entries = _b[_a];
2744for (var _c = 0, _d = entries.slice(); _c < _d.length; _c++){var entry = _d[_c];
2745if(obsSetsOverlap(entry.obsSet, idbtrans.mutatedParts)){delArrayItem(entries, entry);
2746entry.subscribers.forEach(function (requery){return affectedSubscribers_1.add(requery);});
2747}
2748}
2749}
2750} else if(ops.length > 0){tblCache.optimisticOps = tblCache.optimisticOps.filter(function (op) {
2751return op.trans !== idbtrans;});
2752for (var _e = 0, _f = Object.values(tblCache.queries.query); _e < _f.length; _e++){var entries = _f[_e];
2753for (var _g = 0, _h = entries.slice(); _g < _h.length; _g++){var entry = _h[_g];
2754if(entry.res != null && idbtrans.mutatedParts){if(wasCommitted && !entry.dirty) {
2755var freezeResults = Object.isFrozen(entry.res);
2756var modRes = applyOptimisticOps(entry.res, entry.req, ops, table, entry, freezeResults);
2757if(entry.dirty){delArrayItem(entries, entry);

2758entry.subscribers.forEach(function (requery){return affectedSubscribers_1.add(requery);});
2759} else if(modRes !== entry.res){entry.res = modRes;
2760entry.promise = DexiePromise.resolve({
2761result: modRes
2762});}}else{if(entry.dirty){delArrayItem(entries, entry);}
2763entry.subscribers.forEach(function (requery){return affectedSubscribers_1.add(requery);});
2764}
2765}
2766}
2767}
2768}
2769}
2770}
2771affectedSubscribers_1.forEach(function (requery){return requery();});
2772}
2773};};idbtrans.addEventListener('abort', endTransaction(false), {
2774signal: signal
2775});
2776idbtrans.addEventListener('error', endTransaction(false), {
2777signal: signal
2778});
2779idbtrans.addEventListener('complete', endTransaction(true), {
2780signal: signal
2781});}
2782return idbtrans;},table: function table(tableName){var downTable = core.table(tableName);
2783var primKey = downTable.schema.primaryKey;
2784var tableMW = _assign(_assign({}, downTable), {
2785mutate: function mutate(req){var trans = PSD.trans;
2786if(primKey.outbound || trans.db._options.cache === 'disabled' || trans.explicit || trans.idbtrans.mode !== 'readwrite'){return downTable.mutate(req);}
2787var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
2788if(!tblCache) return downTable.mutate(req);
2789var promise = downTable.mutate(req);
2790if((req.type === 'add' || req.type === 'put') && (req.values.length >= 50 || getEffectiveKeys(primKey, req).some(function (key){return key == null;}))){promise.then(function (res) {
2791var reqWithResolvedKeys = _assign(_assign({}, req), {
2792values: req.values.map(function (value, i){var _a;
2793if(res.failures[i]) return value;
2794var valueWithKey = ((_a = primKey.keyPath) === null || _a === void 0 ? void 0 : _a.includes('.')) ? deepClone(value) : _assign({}, value);
2795setByKeyPath(valueWithKey, primKey.keyPath, res.results[i]);
2796return valueWithKey;})
2797});
2798var adjustedReq = adjustOptimisticFromFailures(tblCache, reqWithResolvedKeys, res);
2799tblCache.optimisticOps.push(adjustedReq);
2800queueMicrotask(function (){return req.mutatedParts && signalSubscribersLazily(req.mutatedParts);});
2801});}else{tblCache.optimisticOps.push(req);
2802req.mutatedParts && signalSubscribersLazily(req.mutatedParts);
2803promise.then(function (res){if(res.numFailures > 0) {
2804delArrayItem(tblCache.optimisticOps, req);
2805var adjustedReq = adjustOptimisticFromFailures(tblCache, req, res);
2806if(adjustedReq){tblCache.optimisticOps.push(adjustedReq);}
2807req.mutatedParts && signalSubscribersLazily(req.mutatedParts);}
2808});
2809promise["catch"](function (){delArrayItem(tblCache.optimisticOps, req);
2810req.mutatedParts && signalSubscribersLazily(req.mutatedParts);});
2811}
2812return promise;},query: function query(req){var _a;
2813if(!isCachableContext(PSD, downTable) || !isCachableRequest("query", req)) return downTable.query(req);
2814var freezeResults = ((_a = PSD.trans) === null || _a === void 0 ? void 0 : _a.db._options.cache) === 'immutable';
2815var _b = PSD,requery = _b.requery,
2816signal = _b.signal;
2817var _c = findCompatibleQuery(dbName, tableName, 'query', req),cacheEntry = _c[0],
2818exactMatch = _c[1],tblCache = _c[2],
2819container = _c[3];
2820if(cacheEntry && exactMatch){cacheEntry.obsSet = req.obsSet;}else{var promise = downTable.query(req).then(function (res){var result = res.result;
2821if(cacheEntry) cacheEntry.res = result;
2822if(freezeResults){for (var i = 0, l = result.length; i < l; ++i) {
2823Object.freeze(result[i]);}
2824Object.freeze(result);}else{res.result = deepClone(result);}
2825return res;})["catch"](function (error){if(container && cacheEntry) delArrayItem(container, cacheEntry);
2826return Promise.reject(error);});
2827cacheEntry = {
2828obsSet: req.obsSet,promise: promise,
2829subscribers: new Set(),type: 'query',
2830req: req,dirty: false
2831};if(container){container.push(cacheEntry);}else{container = [cacheEntry];
2832if(!tblCache){tblCache = cache["idb://".concat(dbName, "/").concat(tableName)] = {
2833queries: {
2834query: {},count: {}},
2835objs: new Map(),optimisticOps: [],
2836unsignaledParts: {}};}
2837tblCache.queries.query[req.query.index.name || ''] = container;}
2838}
2839subscribeToCacheEntry(cacheEntry, container, requery, signal);
2840return cacheEntry.promise.then(function (res){return {
2841result: applyOptimisticOps(res.result, req, tblCache === null || tblCache === void 0 ? void 0 : tblCache.optimisticOps, downTable, cacheEntry, freezeResults)
2842};});
2843}
2844});
2845return tableMW;}
2846});
2847return coreMW;}
2848};function vipify(target, vipDb){return new Proxy(target, {
2849get: function get(target, prop, receiver){if(prop === 'db') return vipDb;
2850return Reflect.get(target, prop, receiver);}
2851});}
2852var Dexie$1 = function (){function Dexie(name, options) {
2853var _this = this;
2854this._middlewares = {};this.verno = 0;
2855var deps = Dexie.dependencies;
2856this._options = options = _assign({

vendor: 4,377 bytes, lines 2857-2933

2857addons: Dexie.addons,autoOpen: true,
2858indexedDB: deps.indexedDB,IDBKeyRange: deps.IDBKeyRange,
2859cache: 'cloned'
2860}, options);
2861this._deps = {
2862indexedDB: options.indexedDB,IDBKeyRange: options.IDBKeyRange
2863};var addons = options.addons;
2864this._dbSchema = {};this._versions = [];
2865this._storeNames = [];
2866this._allTables = {};this.idbdb = null;
2867this._novip = this;
2868var state = {
2869dbOpenError: null,isBeingOpened: false,
2870onReadyBeingFired: null,openComplete: false,
2871dbReadyResolve: nop,dbReadyPromise: null,
2872cancelOpen: nop,openCanceller: null,
2873autoSchema: true,PR1398_maxLoop: 3,
2874autoOpen: options.autoOpen
2875};state.dbReadyPromise = new DexiePromise(function (resolve){state.dbReadyResolve = resolve;});
2876state.openCanceller = new DexiePromise(function (_, reject){state.cancelOpen = reject;});
2877this._state = state;
2878this.name = name;
2879this.on = Events(this, "populate", "blocked", "versionchange", "close", {
2880ready: [promisableChain, nop]
2881});
2882this.on.ready.subscribe = override(this.on.ready.subscribe, function (subscribe){return function (subscriber, bSticky) {
2883Dexie.vip(function (){var state = _this._state;
2884if(state.openComplete){if(!state.dbOpenError) DexiePromise.resolve().then(subscriber);
2885if(bSticky) subscribe(subscriber);} else if(state.onReadyBeingFired){state.onReadyBeingFired.push(subscriber);
2886if(bSticky) subscribe(subscriber);}else{subscribe(subscriber);
2887var db_1 = _this;
2888if(!bSticky) subscribe(function unsubscribe(){db_1.on.ready.unsubscribe(subscriber);
2889db_1.on.ready.unsubscribe(unsubscribe);});
2890}
2891});};});
2892this.Collection = createCollectionConstructor(this);
2893this.Table = createTableConstructor(this);
2894this.Transaction = createTransactionConstructor(this);
2895this.Version = createVersionConstructor(this);
2896this.WhereClause = createWhereClauseConstructor(this);
2897this.on("versionchange", function (ev){if(ev.newVersion > 0) console.warn("Another connection wants to upgrade database '".concat(_this.name, "'. Closing db now to resume the upgrade."));else console.warn("Another connection wants to delete database '".concat(_this.name, "'. Closing db now to resume the delete request."));
2898_this.close({
2899disableAutoOpen: false
2900});});
2901this.on("blocked", function (ev){if(!ev.newVersion || ev.newVersion < ev.oldVersion) console.warn("Dexie.delete('".concat(_this.name, "') was blocked"));else console.warn("Upgrade '".concat(_this.name, "' blocked by other connection holding version ").concat(ev.oldVersion / 10));
2902});
2903this._maxKey = _getMaxKey(options.IDBKeyRange);
2904this._createTransaction = function (mode, storeNames, dbschema, parentTransaction){return new _this.Transaction(mode, storeNames, dbschema, _this._options.chromeTransactionDurability, parentTransaction);};this._fireOnBlocked = function (ev){_this.on("blocked").fire(ev);
2905connections.filter(function (c){return c.name === _this.name && c !== _this && !c._state.vcFired;}).map(function (c){return c.on("versionchange").fire(ev);
2906});};this.use(cacheExistingValuesMiddleware);
2907this.use(cacheMiddleware);
2908this.use(observabilityMiddleware);
2909this.use(virtualIndexMiddleware);
2910this.use(hooksMiddleware);
2911var vipDB = new Proxy(this, {
2912get: function get(_, prop, receiver){if(prop === '_vip') return true;
2913if(prop === 'table') return function (tableName){return vipify(_this.table(tableName), vipDB);};var rv = Reflect.get(_, prop, receiver);
2914if(rv instanceof Table) return vipify(rv, vipDB);
2915if(prop === 'tables') return rv.map(function (t){return vipify(t, vipDB);});
2916if(prop === '_createTransaction') return function (){var tx = rv.apply(this, arguments);
2917return vipify(tx, vipDB);};return rv;}
2918});
2919this.vip = vipDB;
2920addons.forEach(function (addon){return addon(_this);});
2921}
2922Dexie.prototype.version = function (versionNumber){if(isNaN(versionNumber) || versionNumber < 0.1) throw new exceptions.Type("Given version is not a positive number");
2923versionNumber = Math.round(versionNumber * 10) / 10;
2924if(this.idbdb || this._state.isBeingOpened) throw new exceptions.Schema("Cannot add version when database is open");
2925this.verno = Math.max(this.verno, versionNumber);
2926var versions = this._versions;
2927var versionInstance = versions.filter(function (v){return v._cfg.version === versionNumber;})[0];
2928if(versionInstance) return versionInstance;
2929versionInstance = new this.Version(versionNumber);
2930versions.push(versionInstance);
2931versions.sort(lowerVersionFirst);
2932versionInstance.stores({});
2933this._state.autoSchema = false;

2934return versionInstance;};Dexie.prototype._whenReady = function (fn){var _this = this;
2935return this.idbdb && (this._state.openComplete || PSD.letThrough || this._vip) ? fn() : new DexiePromise(function (resolve, reject){if(_this._state.openComplete) {
2936return reject(new exceptions.DatabaseClosed(_this._state.dbOpenError));}
2937if(!_this._state.isBeingOpened){if(!_this._state.autoOpen) {
2938reject(new exceptions.DatabaseClosed());
2939return;}
2940_this.open()["catch"](nop);}
2941_this._state.dbReadyPromise.then(resolve, reject);}).then(fn);
2942};Dexie.prototype.use = function (_a){var stack = _a.stack,create = _a.create,
2943level = _a.level,name = _a.name;
2944if(name) this.unuse({
2945stack: stack,name: name
2946});
2947var middlewares = this._middlewares[stack] || (this._middlewares[stack] = []);
2948middlewares.push({
2949stack: stack,create: create,
2950level: level == null ? 10 : level,name: name
2951});
2952middlewares.sort(function (a, b){return a.level - b.level;});
2953return this;};Dexie.prototype.unuse = function (_a){var stack = _a.stack,name = _a.name,
2954create = _a.create;
2955if(stack && this._middlewares[stack]){this._middlewares[stack] = this._middlewares[stack].filter(function (mw) {
2956return create ? mw.create !== create : name ? mw.name !== name : false;});
2957}
2958return this;};Dexie.prototype.open = function (){var _this = this;
2959return usePSD(globalPSD, function (){return dexieOpen(_this);});
2960};Dexie.prototype._close = function (){var state = this._state;
2961var idx = connections.indexOf(this);
2962if(idx >= 0) connections.splice(idx, 1);
2963if(this.idbdb){try {
2964this.idbdb.close();} catch (e){}
2965this.idbdb = null;}
2966if(!state.isBeingOpened){state.dbReadyPromise = new DexiePromise(function (resolve) {
2967state.dbReadyResolve = resolve;});
2968state.openCanceller = new DexiePromise(function (_, reject){state.cancelOpen = reject;});
2969}
2970};Dexie.prototype.close = function (_a){var _b = _a === void 0 ? {
2971disableAutoOpen: true
2972} : _a,disableAutoOpen = _b.disableAutoOpen;
2973var state = this._state;
2974if(disableAutoOpen){if(state.isBeingOpened) {
2975state.cancelOpen(new exceptions.DatabaseClosed());}
2976this._close();
2977state.autoOpen = false;
2978state.dbOpenError = new exceptions.DatabaseClosed();}else{this._close();
2979state.autoOpen = this._options.autoOpen || state.isBeingOpened;
2980state.openComplete = false;
2981state.dbOpenError = null;}
2982};Dexie.prototype["delete"] = function (closeOptions){var _this = this;
2983if(closeOptions === void 0){closeOptions = {
2984disableAutoOpen: true
2985};}
2986var hasInvalidArguments = arguments.length > 0 && babelHelpers["typeof"](arguments[0]) !== 'object';
2987var state = this._state;
2988return new DexiePromise(function (resolve, reject){var doDelete = function doDelete() {
2989_this.close(closeOptions);
2990var req = _this._deps.indexedDB.deleteDatabase(_this.name);
2991req.onsuccess = wrap(function (){_onDatabaseDeleted(_this._deps, _this.name);
2992resolve();});
2993req.onerror = eventRejectHandler(reject);
2994req.onblocked = _this._fireOnBlocked;};if(hasInvalidArguments) throw new exceptions.InvalidArgument("Invalid closeOptions argument to db.delete()");
2995if(state.isBeingOpened){state.dbReadyPromise.then(doDelete);}else{doDelete();}
2996});};Dexie.prototype.backendDB = function (){return this.idbdb;};Dexie.prototype.isOpen = function (){return this.idbdb !== null;};Dexie.prototype.hasBeenClosed = function (){var dbOpenError = this._state.dbOpenError;
2997return dbOpenError && dbOpenError.name === 'DatabaseClosed';};Dexie.prototype.hasFailed = function (){return this._state.dbOpenError !== null;};Dexie.prototype.dynamicallyOpened = function (){return this._state.autoSchema;};Object.defineProperty(Dexie.prototype, "tables", {
2998get: function get(){var _this = this;
2999return keys(this._allTables).map(function (name){return _this._allTables[name];});
3000},enumerable: false,
3001configurable: true
3002});
3003Dexie.prototype.transaction = function (){var args = extractTransactionArgs.apply(this, arguments);
3004return this._transaction.apply(this, args);};Dexie.prototype._transaction = function (mode, tables, scopeFunc){var _this = this;
3005var parentTransaction = PSD.trans;
3006if(!parentTransaction || parentTransaction.db !== this || mode.indexOf('!') !== -1) parentTransaction = null;
3007var onlyIfCompatible = mode.indexOf('?') !== -1;
3008mode = mode.replace('!', '').replace('?', '');
3009var idbMode, storeNames;
3010try {
3011storeNames = tables.map(function (table){var storeName = table instanceof _this.Table ? table.name : table;
3012if(typeof storeName !== 'string') throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed");
3013return storeName;});
3014if(mode == "r" || mode === READONLY) idbMode = READONLY;else if(mode == "rw" || mode == READWRITE) idbMode = READWRITE;else throw new exceptions.InvalidArgument("Invalid transaction mode: " + mode);
3015if(parentTransaction){if(parentTransaction.mode === READONLY && idbMode === READWRITE) {
3016if(onlyIfCompatible){parentTransaction = null;} else throw new exceptions.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY");
3017}

3018if(parentTransaction){storeNames.forEach(function (storeName) {
3019if(parentTransaction && parentTransaction.storeNames.indexOf(storeName) === -1){if(onlyIfCompatible) {
3020parentTransaction = null;} else throw new exceptions.SubTransaction("Table " + storeName + " not included in parent transaction.");
3021}
3022});}
3023if(onlyIfCompatible && parentTransaction && !parentTransaction.active){parentTransaction = null;}
3024}
3025} catch (e){return parentTransaction ? parentTransaction._promise(null, function (_, reject) {
3026reject(e);}) : rejection(e);
3027}
3028var enterTransaction = enterTransactionScope.bind(null, this, idbMode, storeNames, parentTransaction, scopeFunc);
3029return parentTransaction ? parentTransaction._promise(idbMode, enterTransaction, "lock") : PSD.trans ? usePSD(PSD.transless, function (){return _this._whenReady(enterTransaction);}) : this._whenReady(enterTransaction);
3030};Dexie.prototype.table = function (tableName){if(!hasOwn(this._allTables, tableName)) {
3031throw new exceptions.InvalidTable("Table ".concat(tableName, " does not exist"));}
3032return this._allTables[tableName];};return Dexie;}();
3033var symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol ? Symbol.observable : "@@observable";
3034var Observable = function (){function Observable(subscribe) {
3035this._subscribe = subscribe;}
3036Observable.prototype.subscribe = function (x, error, complete){return this._subscribe(!x || typeof x === "function" ? {
3037next: x,error: error,
3038complete: complete
3039} : x);};Observable.prototype[symbolObservable] = function (){return this;};return Observable;}();
3040var domDeps;
3041try {
3042domDeps = {
3043indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB,IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange
3044};} catch (e){domDeps = {
3045indexedDB: null,IDBKeyRange: null
3046};}
3047function liveQuery(querier){var hasValue = false;
3048var currentValue;
3049var observable = new Observable(function (observer){var scopeFuncIsAsync = isAsyncFunction(querier);
3050function execute(ctx){var wasRootExec = beginMicroTickScope();
3051try {
3052if(scopeFuncIsAsync){incrementExpectedAwaits();}
3053var rv = newScope(querier, ctx);
3054if(scopeFuncIsAsync){rv = rv["finally"](decrementExpectedAwaits);}
3055return rv;} finally {
3056wasRootExec && endMicroTickScope();}
3057}
3058var closed = false;
3059var abortController;
3060var accumMuts = {};var currentObs = {};var subscription = {
3061get closed(){return closed;},unsubscribe: function unsubscribe(){if(closed) return;
3062closed = true;
3063if(abortController) abortController.abort();
3064if(startedListening) globalEvents.storagemutated.unsubscribe(mutationListener);}
3065};observer.start && observer.start(subscription);
3066var startedListening = false;
3067var doQuery = function doQuery(){return execInGlobalContext(_doQuery);};function shouldNotify(){return obsSetsOverlap(currentObs, accumMuts);}
3068var mutationListener = function mutationListener(parts){extendObservabilitySet(accumMuts, parts);
3069if(shouldNotify()){doQuery();}
3070};var _doQuery = function _doQuery(){if(closed || !domDeps.indexedDB) {
3071return;}
3072accumMuts = {};var subscr = {};if(abortController) abortController.abort();
3073abortController = new AbortController();
3074var ctx = {
3075subscr: subscr,signal: abortController.signal,
3076requery: doQuery,querier: querier,
3077trans: null
3078};var ret = execute(ctx);
3079Promise.resolve(ret).then(function (result){hasValue = true;
3080currentValue = result;
3081if(closed || ctx.signal.aborted){return;}
3082accumMuts = {};currentObs = subscr;
3083if(!objectIsEmpty(currentObs) && !startedListening){globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener);
3084startedListening = true;}
3085execInGlobalContext(function (){return !closed && observer.next && observer.next(result);});
3086}, function (err){hasValue = false;
3087if(!['DatabaseClosedError', 'AbortError'].includes(err === null || err === void 0 ? void 0 : err.name)){if(!closed) execInGlobalContext(function () {
3088if(closed) return;
3089observer.error && observer.error(err);});
3090}
3091});};setTimeout(doQuery, 0);
3092return subscription;});
3093observable.hasValue = function (){return hasValue;};observable.getValue = function (){return currentValue;};return observable;}
3094var Dexie = Dexie$1;
3095props(Dexie, _assign(_assign({}, fullNameExceptions), {

3096"delete": function _delete(databaseName){var db = new Dexie(databaseName, {
3097addons: []
3098});
3099return db["delete"]();},exists: function exists(name){return new Dexie(name, {
3100addons: []
3101}).open().then(function (db){db.close();
3102return true;})["catch"]('NoSuchDatabaseError', function (){return false;
3103});},getDatabaseNames: function getDatabaseNames(cb){try {
3104return _getDatabaseNames(Dexie.dependencies).then(cb);} catch (_a){return rejection(new exceptions.MissingAPI());
3105}
3106},defineClass: function defineClass(){function Class(content) {
3107extend(this, content);}
3108return Class;},ignoreTransaction: function ignoreTransaction(scopeFunc){return PSD.trans ? usePSD(PSD.transless, scopeFunc) : scopeFunc();},
3109vip: vip,async: function async(generatorFn){return function () {
3110try {
3111var rv = awaitIterator(generatorFn.apply(this, arguments));
3112if(!rv || typeof rv.then !== 'function') return DexiePromise.resolve(rv);
3113return rv;} catch (e){return rejection(e);
3114}
3115};},spawn: function spawn(generatorFn, args, thiz){try {
3116var rv = awaitIterator(generatorFn.apply(thiz, args || []));
3117if(!rv || typeof rv.then !== 'function') return DexiePromise.resolve(rv);
3118return rv;} catch (e){return rejection(e);
3119}
3120},currentTransaction: {
3121get: function get(){return PSD.trans || null;}
3122},waitFor: function waitFor(promiseOrFunction, optionalTimeout){var promise = DexiePromise.resolve(typeof promiseOrFunction === 'function' ? Dexie.ignoreTransaction(promiseOrFunction) : promiseOrFunction).timeout(optionalTimeout || 60000);
3123return PSD.trans ? PSD.trans.waitFor(promise) : promise;},Promise: DexiePromise,
3124debug: {
3125get: function get(){return debug;},set: function set(value){setDebug(value);}
3126},derive: derive,
3127extend: extend,props: props,
3128override: override,Events: Events,
3129on: globalEvents,liveQuery: liveQuery,
3130extendObservabilitySet: extendObservabilitySet,getByKeyPath: getByKeyPath,
3131setByKeyPath: setByKeyPath,delByKeyPath: delByKeyPath,
3132shallowClone: shallowClone,deepClone: deepClone,
3133getObjectDiff: getObjectDiff,cmp: cmp,
3134asap: asap$1,minKey: minKey,
3135addons: [],connections: connections,
3136errnames: errnames,dependencies: domDeps,
3137cache: cache,semVer: DEXIE_VERSION,
3138version: DEXIE_VERSION.split('.').map(function (n){return parseInt(n);}).reduce(function (p, c, i){return p + c / Math.pow(10, i * 2);
3139})
3140}));
3141Dexie.maxKey = _getMaxKey(Dexie.dependencies.IDBKeyRange);
3142if(typeof dispatchEvent !== 'undefined' && typeof addEventListener !== 'undefined'){globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, function (updatedParts) {
3143if(!propagatingLocally){var event_1;
3144event_1 = new CustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, {
3145detail: updatedParts
3146});
3147propagatingLocally = true;
3148dispatchEvent(event_1);
3149propagatingLocally = false;}
3150});
3151addEventListener(STORAGE_MUTATED_DOM_EVENT_NAME, function (_a){var detail = _a.detail;
3152if(!propagatingLocally){propagateLocally(detail);}
3153});}
3154function propagateLocally(updateParts){var wasMe = propagatingLocally;
3155try {
3156propagatingLocally = true;
3157globalEvents.storagemutated.fire(updateParts);
3158signalSubscribersNow(updateParts, true);} finally {
3159propagatingLocally = wasMe;}
3160}
3161var propagatingLocally = false;
3162var bc;
3163var createBC = function createBC(){};if(typeof BroadcastChannel !== 'undefined'){createBC = function createBC() {
3164bc = new BroadcastChannel(STORAGE_MUTATED_DOM_EVENT_NAME);
3165bc.onmessage = function (ev){return ev.data && propagateLocally(ev.data);};};createBC();
3166if(typeof bc.unref === 'function'){bc.unref();}
3167globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, function (changedParts){if(!propagatingLocally) {
3168bc.postMessage(changedParts);}
3169});}
3170if(typeof addEventListener !== 'undefined'){addEventListener('pagehide', function (event) {
3171if(!Dexie$1.disableBfCache && event.persisted){if(debug) console.debug('Dexie: handling persisted pagehide');
3172bc === null || bc === void 0 ? void 0 : bc.close();
3173for (var _i = 0, connections_1 = connections; _i < connections_1.length; _i++){var db = connections_1[_i];
3174db.close({
3175disableAutoOpen: false
3176});}
3177}
3178});
3179addEventListener('pageshow', function (event){if(!Dexie$1.disableBfCache && event.persisted) {
3180if(debug) console.debug('Dexie: handling persisted pageshow');
3181createBC();
3182propagateLocally({
3183all: new RangeSet(-Infinity, [[]])
3184});}
3185});}
3186function add(value){return new PropModification({
3187add: value
3188});}
3189function remove(value){return new PropModification({
3190remove: value
3191});}
3192function replacePrefix(a, b){return new PropModification({
3193replacePrefix: [a, b]
3194});}
3195DexiePromise.rejectionMapper = mapError;
3196setDebug(debug);
3197window.BX.Dexie = Dexie$1;
3198window.BX.Dexie3 = {
3199Dexie: Dexie$1,liveQuery: liveQuery,
3200Entity: Entity,cmp: cmp,
3201PropModSymbol: PropModSymbol,PropModification: PropModification,
3202replacePrefix: replacePrefix,add: add,
3203remove: remove,RangeSet: RangeSet,
3204mergeRanges: mergeRanges,rangesOverlap: rangesOverlap
3205};

3205exports.Dexie = Dexie$1;
3206exports.liveQuery = liveQuery;
3207exports.Entity = Entity;
3208exports.cmp = cmp;
3209exports.PropModSymbol = PropModSymbol;
3210exports.PropModification = PropModification;
3211exports.replacePrefix = replacePrefix;
3212exports.add = add;
3213exports.remove = remove;
3214exports.RangeSet = RangeSet;
3215exports.mergeRanges = mergeRanges;
3216exports.rangesOverlap = rangesOverlap;}((this.BX.DexieExport = this.BX.DexieExport || {})));

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.