https://www.aversev.by/bitrix/js/ui/dexie/dist/dexie3.bundle.js?1734420282187520

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

113);
114	}
115	var _slice = [].slice;
116	function slice(args, start, end) {
117	  return _slice.call(args, start, end);
118	}
119	function override(origFunc, overridedFactory) {
120	  return overridedFactory(origFunc);
121	}
122	function assert(b) {
123	  if (!b) throw new Error("Assertion Failed");
124	}
125	function asap$1(fn) {
126	  if (_global.setImmediate) setImmediate(fn);else setTimeout(fn, 0);
127	}
128	function arrayToObject(array, extractor) {
129	  return array.reduce(function (result, item, i) {
130	    var nameAndValue = extractor(item, i);
131	    if (nameAndValue) result[nameAndValue[0]] = nameAndValue[1];
132	    return result;
133	  }, {});
134	}
135	function tryCatch(fn, onerror, args) {
136	  try {
137	    fn.apply(null, args);
138	  } catch (ex) {
139	    onerror && onerror(ex);
140	  }
141	}
142	function getByKeyPath(obj, keyPath) {
143	  if (hasOwn(obj, keyPath)) return obj[keyPath];
144	  if (!keyPath) return obj;
145	  if (typeof keyPath !== 'string') {
146	    var rv = [];
147	    for (var i = 0, l = keyPath.length; i < l; ++i) {
148	      var val = getByKeyPath(obj, keyPath[i]);
149	      rv.push(val);
150	    }
151	    return rv;
152	  }
153	  var period = keyPath.indexOf('.');
154	  if (period !== -1) {
155	    var innerObj = obj[keyPath.substr(0, period)];
156	    return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.substr(period + 1));
157	  }
158	  return undefined;
159	}
160	function setByKeyPath(obj, keyPath, value) {
161	  if (!obj || keyPath === undefined) return;
162	  if ('isFrozen' in Object && Object.isFrozen(obj)) return;
163	  if (typeof keyPath !== 'string' && 'length' in keyPath) {
164	    assert(typeof value !== 'string' && 'length' in value);
165	    for (var i = 0, l = keyPath.length; i < l; ++i) {
166	      setByKeyPath(obj, keyPath[i], value[i]);
167	    }
168	  } else {
169	    var period = keyPath.indexOf('.');
170	    if (period !== -1) {
171	      var currentKeyPath = keyPath.substr(0, period);
172	      var remainingKeyPath = keyPath.substr(period + 1);
173	      if (remainingKeyPath === "") {
174	        if (value === undefined) {
175	          if (isArray(obj) && !isNaN(parseInt(currentKeyPath))) obj.splice(currentKeyPath, 1);else delete obj[currentKeyPath];
176	        } else obj[currentKeyPath] = value;
177	      } else {
178	        var innerObj = obj[currentKeyPath];
179	        if (!innerObj || !hasOwn(obj, currentKeyPath)) innerObj = obj[currentKeyPath] = {};
180	        setByKeyPath(innerObj, remainingKeyPath, value);
181	      }
182	    } else {
183	      if (value === undefined) {
184	        if (isArray(obj) && !isNaN(parseInt(keyPath))) obj.splice(keyPath, 1);else delete obj[keyPath];
185	      } else obj[keyPath] = value;
186	    }
187	  }
188	}
189	function delByKeyPath(obj, keyPath) {
190	  if (typeof keyPath === 'string') setByKeyPath(obj, keyPath, undefined);else if ('length' in keyPath) [].map.call(keyPath, function (kp) {
191	    setByKeyPath(obj, kp, undefined);
192	  });
193	}
194	function shallowClone(obj) {
195	  var rv = {};
196	  for (var m in obj) {
197	    if (hasOwn(obj, m)) rv[m] = obj[m];
198	  }
199	  return rv;
200	}
201	var concat = [].concat;
202	function flatten(a) {
203	  return concat.apply([], a);
204	}
205	var intrinsicTypeNames = "Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey".split(',').concat(flatten([8, 16, 32, 64].map(function (num) {
206	  return ["Int", "Uint", "Float"].map(function (t) {
207	    return t + num + "Array";
208	  });
209	}))).filter(function (t) {
210	  return _global[t];
211	});
212	var intrinsicTypes = intrinsicTypeNames.map(function (t) {
213	  return _global[t];
214	});
215	arrayToObject(intrinsicTypeNames, function (x) {
216	  return [x, true];
217	});
218	var circularRefs = null;
219	function deepClone(any) {
220	  circularRefs = typeof WeakMap !== 'undefined' && new WeakMap();
221	  var rv = innerDeepClone(any);
222	  circularRefs = null;
223	  return rv;
224	}
225	function innerDeepClone(any) {
226	  if (!any || babelHelpers["typeof"](any) !== 'object') return any;
227	  var rv = circularRefs && circularRefs.get(any);
228	  if (rv) return rv;
229	  if (isArray(any)) {
230	    rv = [];
231	    circularRefs && circularRefs.set(any, rv);
232	    for (var i = 0, l = any.length; i < l; ++i) {
233	      rv.push(innerDeepClone(any[i]));
234	    }
235	  } else if (intrinsicTypes.indexOf(any.constructor) >= 0) {
236	    rv = any;
237	  } else {
238	    var proto = getProto(any);
239	    rv = proto === Object.prototype ? {} : Object.create(proto);
240	    circularRefs && circularRefs.set(any, rv);
241	    for (var prop in any) {
242	      if (hasOwn(any, prop)) {
243	        rv[prop] = innerDeepClone(any[prop]);
244	      }
245	    }
246	  }
247	  return rv;
248	}
249	var toString = {}.toString;
250	function toStringTag(o) {
251	  return toString.call(o).slice(8, -1);
252	}
253	var iteratorSymbol = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
254	var getIteratorOf = babelHelpers["typeof"](iteratorSymbol) === "symbol" ? function (x) {
255	  var i;
256	  return x != null && (i = x[iteratorSymbol]) && i.apply(x);
257	} : function () {
258	  return null;
259	};
260	var NO_CHAR_ARRAY = {};
261	function getArrayOf(arrayLike) {
262	  var i, a, x, it;

263	  if (arguments.length === 1) {
264	    if (isArray(arrayLike)) return arrayLike.slice();
265	    if (this === NO_CHAR_ARRAY && typeof arrayLike === 'string') return [arrayLike];
266	    if (it = getIteratorOf(arrayLike)) {
267	      a = [];
268	      while (x = it.next(), !x.done) a.push(x.value);
269	      return a;
270	    }
271	    if (arrayLike == null) return [arrayLike];
272	    i = arrayLike.length;
273	    if (typeof i === 'number') {
274	      a = new Array(i);
275	      while (i--) a[i] = arrayLike[i];
276	      return a;
277	    }
278	    return [arrayLike];
279	  }
280	  i = arguments.length;
281	  a = new Array(i);
282	  while (i--) a[i] = arguments[i];
283	  return a;
284	}
285	var isAsyncFunction = typeof Symbol !== 'undefined' ? function (fn) {
286	  return fn[Symbol.toStringTag] === 'AsyncFunction';
287	} : function () {
288	  return false;
289	};
290	var debug = typeof location !== 'undefined' && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
291	function setDebug(value, filter) {
292	  debug = value;
293	  libraryFilter = filter;
294	}
295	var libraryFilter = function libraryFilter() {
296	  return true;
297	};
298	var NEEDS_THROW_FOR_STACK = !new Error("").stack;
299	function getErrorWithStack() {
300	  if (NEEDS_THROW_FOR_STACK) try {
301	    throw new Error();
302	  } catch (e) {
303	    return e;
304	  }
305	  return new Error();
306	}
307	function prettyStack(exception, numIgnoredFrames) {
308	  var stack = exception.stack;
309	  if (!stack) return "";
310	  numIgnoredFrames = numIgnoredFrames || 0;
311	  if (stack.indexOf(exception.name) === 0) numIgnoredFrames += (exception.name + exception.message).split('\n').length;
312	  return stack.split('\n').slice(numIgnoredFrames).filter(libraryFilter).map(function (frame) {
313	    return "\n" + frame;
314	  }).join('');
315	}
316	var dexieErrorNames = ['Modify', 'Bulk', 'OpenFailed', 'VersionChange', 'Schema', 'Upgrade', 'InvalidTable', 'MissingAPI', 'NoSuchDatabase', 'InvalidArgument', 'SubTransaction', 'Unsupported', 'Internal', 'DatabaseClosed', 'PrematureCommit', 'ForeignAwait'];
317	var idbDomErrorNames = ['Unknown', 'Constraint', 'Data', 'TransactionInactive', 'ReadOnly', 'Version', 'NotFound', 'InvalidState', 'InvalidAccess', 'Abort', 'Timeout', 'QuotaExceeded', 'Syntax', 'DataClone'];
318	var errorList = dexieErrorNames.concat(idbDomErrorNames);
319	var defaultTexts = {
320	  VersionChanged: "Database version changed by other database connection",
321	  DatabaseClosed: "Database has been closed",
322	  Abort: "Transaction aborted",
323	  TransactionInactive: "Transaction has already completed or failed",
324	  MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb"
325	};
326	function DexieError(name, msg) {
327	  this._e = getErrorWithStack();
328	  this.name = name;
329	  this.message = msg;
330	}
331	derive(DexieError).from(Error).extend({
332	  stack: {
333	    get: function get() {
334	      return this._stack || (this._stack = this.name + ": " + this.message + prettyStack(this._e, 2));
335	    }
336	  },
337	  toString: function toString() {
338	    return this.name + ": " + this.message;
339	  }
340	});
341	function getMultiErrorMessage(msg, failures) {
342	  return msg + ". Errors: " + Object.keys(failures).map(function (key) {
343	    return failures[key].toString();
344	  }).filter(function (v, i, s) {
345	    return s.indexOf(v) === i;
346	  }).join('\n');
347	}
348	function ModifyError(msg, failures, successCount, failedKeys) {
349	  this._e = getErrorWithStack();
350	  this.failures = failures;
351	  this.failedKeys = failedKeys;
352	  this.successCount = successCount;
353	  this.message = getMultiErrorMessage(msg, failures);
354	}
355	derive(ModifyError).from(DexieError);
356	function BulkError(msg, failures) {
357	  this._e = getErrorWithStack();
358	  this.name = "BulkError";
359	  this.failures = Object.keys(failures).map(function (pos) {
360	    return failures[pos];
361	  });
362	  this.failuresByPos = failures;
363	  this.message = getMultiErrorMessage(msg, failures);
364	}
365	derive(BulkError).from(DexieError);
366	var errnames = errorList.reduce(function (obj, name) {
367	  return obj[name] = name + "Error", obj;
368	}, {});
369	var BaseException = DexieError;
370	var exceptions = errorList.reduce(function (obj, name) {
371	  var fullName = name + "Error";
372	  function DexieError(msgOrInner, inner) {
373	    this._e = getErrorWithStack();
374	    this.name = fullName;
375	    if (!msgOrInner) {
376	      this.message = defaultTexts[name] || fullName;
377	      this.inner = null;
378	    } else if (typeof msgOrInner === 'string') {
379	      this.message = "" + msgOrInner + (!inner ? '' : '\n ' + inner);
380	      this.inner = inner || null;
381	    } else if (babelHelpers["typeof"](msgOrInner) === 'object') {
382	      this.message = msgOrInner.name + " " + msgOrInner.message;
383	      this.inner = msgOrInner;
384	    }
385	  }
386	  derive(DexieError).from(BaseException);
387	  obj[name] = DexieError;
388	  return obj;
389	}, {});
390	exceptions.Syntax = SyntaxError;
391	exceptions.Type = TypeError;
392	exceptions.Range = RangeError;
393	var exceptionMap = idbDomErrorNames.reduce(function (obj, name) {
394	  obj[name + "Error"] = exceptions[name];
395	  return obj;
396	}, {});
397	function mapError(domError, message) {
398	  if (!domError || domError instanceof DexieError || domError instanceof TypeError || domError instanceof SyntaxError || !domError.name || !exceptionMap[domError.name]) return domError;
399	  var rv = new exceptionMap[domError.name](message || domError.message, domError);
400	  if ("stack" in domError) {
401	    setProp(rv, "stack", {
402	      get: function get() {
403	        return this.inner.stack;
404	      }
405	    });
406	  }
407	  return rv;
408	}
409	var fullNameExceptions = errorList.reduce(function (obj, name) {
410	  if (["Syntax", "Type", "Range"].indexOf(name) === -1) obj[name + "Error"] = exceptions[name];
411	  return obj;
412	}, {});
413	fullNameExceptions.ModifyError = ModifyError;
414	fullNameExceptions.DexieError = DexieError;
415	fullNameExceptions.BulkError = BulkError;
416	function nop() {}
417	function mirror(val) {
418	  return val;
419	}
420	function pureFunctionChain(f1, f2) {
421	  if (f1 == null || f1 === mirror) return f2;
422	  return function (val) {
423	    return f2(f1(val));
424	  };
425	}
426	function callBoth(on1, on2) {
427	  return function () {
428	    on1.apply(this, arguments);
429	    on2.apply(this, arguments);
430	  };
431	}
432	function hookCreatingChain(f1, f2) {
433	  if (f1 === nop) return f2;
434	  return function () {
435	    var res = f1.apply(this, arguments);
436	    if (res !== undefined) arguments[0] = res;
437	    var onsuccess = this.onsuccess,
438	      onerror = this.onerror;
439	    this.onsuccess = null;
440	    this.onerror = null;
441	    var res2 = f2.apply(this, arguments);
442	    if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;

443	    if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
444	    return res2 !== undefined ? res2 : res;
445	  };
446	}
447	function hookDeletingChain(f1, f2) {
448	  if (f1 === nop) return f2;
449	  return function () {
450	    f1.apply(this, arguments);
451	    var onsuccess = this.onsuccess,
452	      onerror = this.onerror;
453	    this.onsuccess = this.onerror = null;
454	    f2.apply(this, arguments);
455	    if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
456	    if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
457	  };
458	}
459	function hookUpdatingChain(f1, f2) {
460	  if (f1 === nop) return f2;
461	  return function (modifications) {
462	    var res = f1.apply(this, arguments);
463	    extend(modifications, res);
464	    var onsuccess = this.onsuccess,
465	      onerror = this.onerror;
466	    this.onsuccess = null;
467	    this.onerror = null;
468	    var res2 = f2.apply(this, arguments);
469	    if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
470	    if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror;
471	    return res === undefined ? res2 === undefined ? undefined : res2 : extend(res, res2);
472	  };
473	}
474	function reverseStoppableEventChain(f1, f2) {
475	  if (f1 === nop) return f2;
476	  return function () {
477	    if (f2.apply(this, arguments) === false) return false;
478	    return f1.apply(this, arguments);
479	  };
480	}
481	function promisableChain(f1, f2) {
482	  if (f1 === nop) return f2;
483	  return function () {
484	    var res = f1.apply(this, arguments);
485	    if (res && typeof res.then === 'function') {
486	      var thiz = this,
487	        i = arguments.length,
488	        args = new Array(i);
489	      while (i--) args[i] = arguments[i];
490	      return res.then(function () {
491	        return f2.apply(thiz, args);
492	      });
493	    }
494	    return f2.apply(this, arguments);
495	  };
496	}
497	var INTERNAL = {};
498	var LONG_STACKS_CLIP_LIMIT = 100,
499	  MAX_LONG_STACKS = 20,
500	  ZONE_ECHO_LIMIT = 100,
501	  _a$1 = typeof Promise === 'undefined' ? [] : function () {
502	    var globalP = Promise.resolve();
503	    if (typeof crypto === 'undefined' || !crypto.subtle) return [globalP, getProto(globalP), globalP];
504	    var nativeP = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
505	    return [nativeP, getProto(nativeP), globalP];
506	  }(),
507	  resolvedNativePromise = _a$1[0],
508	  nativePromiseProto = _a$1[1],
509	  resolvedGlobalPromise = _a$1[2],
510	  nativePromiseThen = nativePromiseProto && nativePromiseProto.then;
511	var NativePromise = resolvedNativePromise && resolvedNativePromise.constructor;
512	var patchGlobalPromise = !!resolvedGlobalPromise;
513	var stack_being_generated = false;
514	var schedulePhysicalTick = resolvedGlobalPromise ? function () {
515	  resolvedGlobalPromise.then(physicalTick);
516	} : _global.setImmediate ? setImmediate.bind(null, physicalTick) : _global.MutationObserver ? function () {
517	  var hiddenDiv = document.createElement("div");
518	  new MutationObserver(function () {
519	    physicalTick();
520	    hiddenDiv = null;
521	  }).observe(hiddenDiv, {
522	    attributes: true
523	  });
524	  hiddenDiv.setAttribute('i', '1');
525	} : function () {
526	  setTimeout(physicalTick, 0);
527	};
528	var asap = function asap(callback, args) {
529	  microtickQueue.push([callback, args]);
530	  if (needsNewPhysicalTick) {
531	    schedulePhysicalTick();
532	    needsNewPhysicalTick = false;
533	  }
534	};
535	var isOutsideMicroTick = true,
536	  needsNewPhysicalTick = true,
537	  unhandledErrors = [],
538	  rejectingErrors = [],
539	  currentFulfiller = null,
540	  rejectionMapper = mirror;
541	var globalPSD = {
542	  id: 'global',
543	  global: true,
544	  ref: 0,
545	  unhandleds: [],
546	  onunhandled: globalError,

547	  pgp: false,
548	  env: {},
549	  finalize: function finalize() {
550	    this.unhandleds.forEach(function (uh) {
551	      try {
552	        globalError(uh[0], uh[1]);
553	      } catch (e) {}
554	    });
555	  }
556	};
557	var PSD = globalPSD;
558	var microtickQueue = [];
559	var numScheduledCalls = 0;
560	var tickFinalizers = [];
561	function DexiePromise(fn) {
562	  if (babelHelpers["typeof"](this) !== 'object') throw new TypeError('Promises must be constructed via new');
563	  this._listeners = [];
564	  this.onuncatched = nop;
565	  this._lib = false;
566	  var psd = this._PSD = PSD;
567	  if (debug) {
568	    this._stackHolder = getErrorWithStack();
569	    this._prev = null;
570	    this._numPrev = 0;
571	  }
572	  if (typeof fn !== 'function') {
573	    if (fn !== INTERNAL) throw new TypeError('Not a function');
574	    this._state = arguments[1];
575	    this._value = arguments[2];
576	    if (this._state === false) handleRejection(this, this._value);
577	    return;
578	  }
579	  this._state = null;
580	  this._value = null;
581	  ++psd.ref;
582	  executePromiseTask(this, fn);
583	}
584	var thenProp = {
585	  get: function get() {
586	    var psd = PSD,
587	      microTaskId = totalEchoes;
588	    function then(onFulfilled, onRejected) {
589	      var _this = this;
590	      var possibleAwait = !psd.global && (psd !== PSD || microTaskId !== totalEchoes);
591	      var cleanup = possibleAwait && !decrementExpectedAwaits();
592	      var rv = new DexiePromise(function (resolve, reject) {
593	        propagateToListener(_this, new Listener(nativeAwaitCompatibleWrap(onFulfilled, psd, possibleAwait, cleanup), nativeAwaitCompatibleWrap(onRejected, psd, possibleAwait, cleanup), resolve, reject, psd));
594	      });
595	      debug && linkToPreviousPromise(rv, this);
596	      return rv;
597	    }
598	    then.prototype = INTERNAL;
599	    return then;
600	  },
601	  set: function set(value) {
602	    setProp(this, 'then', value && value.prototype === INTERNAL ? thenProp : {
603	      get: function get() {
604	        return value;
605	      },
606	      set: thenProp.set
607	    });
608	  }
609	};
610	props(DexiePromise.prototype, {
611	  then: thenProp,
612	  _then: function _then(onFulfilled, onRejected) {
613	    propagateToListener(this, new Listener(null, null, onFulfilled, onRejected, PSD));
614	  },
615	  "catch": function _catch(onRejected) {
616	    if (arguments.length === 1) return this.then(null, onRejected);
617	    var type = arguments[0],
618	      handler = arguments[1];
619	    return typeof type === 'function' ? this.then(null, function (err) {
620	      return err instanceof type ? handler(err) : PromiseReject(err);
621	    }) : this.then(null, function (err) {
622	      return err && err.name === type ? handler(err) : PromiseReject(err);
623	    });
624	  },
625	  "finally": function _finally(onFinally) {
626	    return this.then(function (value) {
627	      onFinally();
628	      return value;
629	    }, function (err) {
630	      onFinally();
631	      return PromiseReject(err);
632	    });
633	  },
634	  stack: {
635	    get: function get() {
636	      if (this._stack) return this._stack;
637	      try {
638	        stack_being_generated = true;
639	        var stacks = getStack(this, [], MAX_LONG_STACKS);
640	        var stack = stacks.join("\nFrom previous: ");
641	        if (this._state !== null) this._stack = stack;
642	        return stack;
643	      } finally {
644	        stack_being_generated = false;
645	      }
646	    }
647	  },
648	  timeout: function timeout(ms, msg) {
649	    var _this = this;
650	    return ms < Infinity ? new DexiePromise(function (resolve, reject) {
651	      var handle = setTimeout(function () {
652	        return reject(new exceptions.Timeout(msg));
653	      }, ms);
654	      _this.then(resolve, reject)["finally"](clearTimeout.bind(null, handle));
655	    }) : this;
656	  }
657	});
658	if (typeof Symbol !== 'undefined' && Symbol.toStringTag) setProp(DexiePromise.prototype, Symbol.toStringTag, 'Dexie.Promise');
659	globalPSD.env = snapShot();
660	function Listener(onFulfilled, onRejected, resolve, reject, zone) {
661	  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
662	  this.onRejected = typeof onRejected === 'function' ? onRejected : null;
663	  this.resolve = resolve;
664	  this.reject = reject;
665	  this.psd = zone;
666	}
667	props(DexiePromise, {
668	  all: function all() {
669	    var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
670	    return new DexiePromise(function (resolve, reject) {
671	      if (values.length === 0) resolve([]);
672	      var remaining = values.length;

673	      values.forEach(function (a, i) {
674	        return DexiePromise.resolve(a).then(function (x) {
675	          values[i] = x;
676	          if (! --remaining) resolve(values);
677	        }, reject);
678	      });
679	    });
680	  },
681	  resolve: function resolve(value) {
682	    if (value instanceof DexiePromise) return value;
683	    if (value && typeof value.then === 'function') return new DexiePromise(function (resolve, reject) {
684	      value.then(resolve, reject);
685	    });
686	    var rv = new DexiePromise(INTERNAL, true, value);
687	    linkToPreviousPromise(rv, currentFulfiller);
688	    return rv;
689	  },
690	  reject: PromiseReject,
691	  race: function race() {
692	    var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
693	    return new DexiePromise(function (resolve, reject) {
694	      values.map(function (value) {
695	        return DexiePromise.resolve(value).then(resolve, reject);
696	      });
697	    });
698	  },
699	  PSD: {
700	    get: function get() {
701	      return PSD;
702	    },
703	    set: function set(value) {
704	      return PSD = value;
705	    }
706	  },
707	  totalEchoes: {
708	    get: function get() {
709	      return totalEchoes;
710	    }
711	  },
712	  newPSD: newScope,
713	  usePSD: usePSD,
714	  scheduler: {
715	    get: function get() {
716	      return asap;
717	    },
718	    set: function set(value) {
719	      asap = value;
720	    }
721	  },
722	  rejectionMapper: {
723	    get: function get() {
724	      return rejectionMapper;
725	    },
726	    set: function set(value) {
727	      rejectionMapper = value;
728	    }
729	  },
730	  follow: function follow(fn, zoneProps) {
731	    return new DexiePromise(function (resolve, reject) {
732	      return newScope(function (resolve, reject) {
733	        var psd = PSD;
734	        psd.unhandleds = [];
735	        psd.onunhandled = reject;
736	        psd.finalize = callBoth(function () {
737	          var _this = this;
738	          run_at_end_of_this_or_next_physical_tick(function () {
739	            _this.unhandleds.length === 0 ? resolve() : reject(_this.unhandleds[0]);
740	          });
741	        }, psd.finalize);
742	        fn();
743	      }, zoneProps, resolve, reject);
744	    });
745	  }
746	});
747	if (NativePromise) {
748	  if (NativePromise.allSettled) setProp(DexiePromise, "allSettled", function () {
749	    var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
750	    return new DexiePromise(function (resolve) {
751	      if (possiblePromises.length === 0) resolve([]);
752	      var remaining = possiblePromises.length;
753	      var results = new Array(remaining);
754	      possiblePromises.forEach(function (p, i) {
755	        return DexiePromise.resolve(p).then(function (value) {
756	          return results[i] = {
757	            status: "fulfilled",
758	            value: value
759	          };
760	        }, function (reason) {
761	          return results[i] = {
762	            status: "rejected",
763	            reason: reason
764	          };
765	        }).then(function () {
766	          return --remaining || resolve(results);
767	        });
768	      });
769	    });
770	  });
771	  if (NativePromise.any && typeof AggregateError !== 'undefined') setProp(DexiePromise, "any", function () {
772	    var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
773	    return new DexiePromise(function (resolve, reject) {
774	      if (possiblePromises.length === 0) reject(new AggregateError([]));
775	      var remaining = possiblePromises.length;
776	      var failures = new Array(remaining);
777	      possiblePromises.forEach(function (p, i) {
778	        return DexiePromise.resolve(p).then(function (value) {
779	          return resolve(value);
780	        }, function (failure) {
781	          failures[i] = failure;
782	          if (! --remaining) reject(new AggregateError(failures));
783	        });
784	      });
785	    });
786	  });
787	}
788	function executePromiseTask(promise, fn) {
789	  try {
790	    fn(function (value) {
791	      if (promise._state !== null) return;
792	      if (value === promise) throw new TypeError('A promise cannot be resolved with itself.');
793	      var shouldExecuteTick = promise._lib && beginMicroTickScope();
794	      if (value && typeof value.then === 'function') {
795	        executePromiseTask(promise, function (resolve, reject) {
796	          value instanceof DexiePromise ? value._then(resolve, reject) : value.then(resolve, reject);
797	        });
798	      } else {
799	        promise._state = true;
800	        promise._value = value;
801	        propagateAllListeners(promise);
802	      }
803	      if (shouldExecuteTick) endMicroTickScope();
804	    }, handleRejection.bind(null, promise));
805	  } catch (ex) {
806	    handleRejection(promise, ex);
807	  }
808	}
809	function handleRejection(promise, reason) {
810	  rejectingErrors.push(reason);
811	  if (promise._state !== null) return;
812	  var shouldExecuteTick = promise._lib && beginMicroTickScope();
813	  reason = rejectionMapper(reason);
814	  promise._state = false;

815	  promise._value = reason;
816	  debug && reason !== null && babelHelpers["typeof"](reason) === 'object' && !reason._promise && tryCatch(function () {
817	    var origProp = getPropertyDescriptor(reason, "stack");
818	    reason._promise = promise;
819	    setProp(reason, "stack", {
820	      get: function get() {
821	        return stack_being_generated ? origProp && (origProp.get ? origProp.get.apply(reason) : origProp.value) : promise.stack;
822	      }
823	    });
824	  });
825	  addPossiblyUnhandledError(promise);
826	  propagateAllListeners(promise);
827	  if (shouldExecuteTick) endMicroTickScope();
828	}
829	function propagateAllListeners(promise) {
830	  var listeners = promise._listeners;
831	  promise._listeners = [];
832	  for (var i = 0, len = listeners.length; i < len; ++i) {
833	    propagateToListener(promise, listeners[i]);
834	  }
835	  var psd = promise._PSD;
836	  --psd.ref || psd.finalize();
837	  if (numScheduledCalls === 0) {
838	    ++numScheduledCalls;
839	    asap(function () {
840	      if (--numScheduledCalls === 0) finalizePhysicalTick();
841	    }, []);
842	  }
843	}
844	function propagateToListener(promise, listener) {
845	  if (promise._state === null) {
846	    promise._listeners.push(listener);
847	    return;
848	  }
849	  var cb = promise._state ? listener.onFulfilled : listener.onRejected;
850	  if (cb === null) {
851	    return (promise._state ? listener.resolve : listener.reject)(promise._value);
852	  }
853	  ++listener.psd.ref;
854	  ++numScheduledCalls;
855	  asap(callListener, [cb, promise, listener]);
856	}
857	function callListener(cb, promise, listener) {
858	  try {
859	    currentFulfiller = promise;
860	    var ret,
861	      value = promise._value;
862	    if (promise._state) {
863	      ret = cb(value);
864	    } else {
865	      if (rejectingErrors.length) rejectingErrors = [];
866	      ret = cb(value);
867	      if (rejectingErrors.indexOf(value) === -1) markErrorAsHandled(promise);
868	    }
869	    listener.resolve(ret);
870	  } catch (e) {
871	    listener.reject(e);
872	  } finally {
873	    currentFulfiller = null;
874	    if (--numScheduledCalls === 0) finalizePhysicalTick();
875	    --listener.psd.ref || listener.psd.finalize();
876	  }
877	}
878	function getStack(promise, stacks, limit) {
879	  if (stacks.length === limit) return stacks;
880	  var stack = "";
881	  if (promise._state === false) {
882	    var failure = promise._value,
883	      errorName,
884	      message;
885	    if (failure != null) {
886	      errorName = failure.name || "Error";
887	      message = failure.message || failure;
888	      stack = prettyStack(failure, 0);
889	    } else {
890	      errorName = failure;
891	      message = "";
892	    }
893	    stacks.push(errorName + (message ? ": " + message : "") + stack);
894	  }
895	  if (debug) {
896	    stack = prettyStack(promise._stackHolder, 2);
897	    if (stack && stacks.indexOf(stack) === -1) stacks.push(stack);
898	    if (promise._prev) getStack(promise._prev, stacks, limit);
899	  }
900	  return stacks;
901	}
902	function linkToPreviousPromise(promise, prev) {
903	  var numPrev = prev ? prev._numPrev + 1 : 0;
904	  if (numPrev < LONG_STACKS_CLIP_LIMIT) {
905	    promise._prev = prev;
906	    promise._numPrev = numPrev;
907	  }
908	}
909	function physicalTick() {
910	  beginMicroTickScope() && endMicroTickScope();
911	}
912	function beginMicroTickScope() {
913	  var wasRootExec = isOutsideMicroTick;
914	  isOutsideMicroTick = false;
915	  needsNewPhysicalTick = false;
916	  return wasRootExec;
917	}
918	function endMicroTickScope() {
919	  var callbacks, i, l;
920	  do {
921	    while (microtickQueue.length > 0) {
922	      callbacks = microtickQueue;
923	      microtickQueue = [];
924	      l = callbacks.length;
925	      for (i = 0; i < l; ++i) {
926	        var item = callbacks[i];
927	        item[0].apply(null, item[1]);
928	      }
929	    }
930	  } while (microtickQueue.length > 0);
931	  isOutsideMicroTick = true;
932	  needsNewPhysicalTick = true;
933	}
934	function finalizePhysicalTick() {
935	  var unhandledErrs = unhandledErrors;
936	  unhandledErrors = [];
937	  unhandledErrs.forEach(function (p) {
938	    p._PSD.onunhandled.call(null, p._value, p);
939	  });
940	  var finalizers = tickFinalizers.slice(0);
941	  var i = finalizers.length;
942	  while (i) finalizers[--i]();
943	}
944	function run_at_end_of_this_or_next_physical_tick(fn) {
945	  function finalizer() {
946	    fn();
947	    tickFinalizers.splice(tickFinalizers.indexOf(finalizer), 1);
948	  }
949	  tickFinalizers.push(finalizer);
950	  ++numScheduledCalls;
951	  asap(function () {
952	    if (--numScheduledCalls === 0) finalizePhysicalTick();
953	  }, []);
954	}
955	function addPossiblyUnhandledError(promise) {
956	  if (!unhandledErrors.some(function (p) {
957	    return p._value === promise._value;
958	  })) unhandledErrors.push(promise);
959	}
960	function markErrorAsHandled(promise) {
961	  var i = unhandledErrors.length;

962	  while (i) if (unhandledErrors[--i]._value === promise._value) {
963	    unhandledErrors.splice(i, 1);
964	    return;
965	  }
966	}
967	function PromiseReject(reason) {
968	  return new DexiePromise(INTERNAL, false, reason);
969	}
970	function wrap(fn, errorCatcher) {
971	  var psd = PSD;
972	  return function () {
973	    var wasRootExec = beginMicroTickScope(),
974	      outerScope = PSD;
975	    try {
976	      switchToZone(psd, true);
977	      return fn.apply(this, arguments);
978	    } catch (e) {
979	      errorCatcher && errorCatcher(e);
980	    } finally {
981	      switchToZone(outerScope, false);
982	      if (wasRootExec) endMicroTickScope();
983	    }
984	  };
985	}
986	var task = {
987	  awaits: 0,
988	  echoes: 0,
989	  id: 0
990	};
991	var taskCounter = 0;
992	var zoneStack = [];
993	var zoneEchoes = 0;
994	var totalEchoes = 0;
995	var zone_id_counter = 0;
996	function newScope(fn, props, a1, a2) {
997	  var parent = PSD,
998	    psd = Object.create(parent);
999	  psd.parent = parent;
1000	  psd.ref = 0;
1001	  psd.global = false;
1002	  psd.id = ++zone_id_counter;
1003	  var globalEnv = globalPSD.env;
1004	  psd.env = patchGlobalPromise ? {
1005	    Promise: DexiePromise,
1006	    PromiseProp: {
1007	      value: DexiePromise,
1008	      configurable: true,
1009	      writable: true
1010	    },
1011	    all: DexiePromise.all,
1012	    race: DexiePromise.race,
1013	    allSettled: DexiePromise.allSettled,
1014	    any: DexiePromise.any,
1015	    resolve: DexiePromise.resolve,
1016	    reject: DexiePromise.reject,
1017	    nthen: getPatchedPromiseThen(globalEnv.nthen, psd),
1018	    gthen: getPatchedPromiseThen(globalEnv.gthen, psd)
1019	  } : {};
1020	  if (props) extend(psd, props);
1021	  ++parent.ref;
1022	  psd.finalize = function () {
1023	    --this.parent.ref || this.parent.finalize();
1024	  };
1025	  var rv = usePSD(psd, fn, a1, a2);
1026	  if (psd.ref === 0) psd.finalize();
1027	  return rv;
1028	}
1029	function incrementExpectedAwaits() {
1030	  if (!task.id) task.id = ++taskCounter;
1031	  ++task.awaits;
1032	  task.echoes += ZONE_ECHO_LIMIT;
1033	  return task.id;
1034	}
1035	function decrementExpectedAwaits() {
1036	  if (!task.awaits) return false;
1037	  if (--task.awaits === 0) task.id = 0;
1038	  task.echoes = task.awaits * ZONE_ECHO_LIMIT;
1039	  return true;
1040	}
1041	if (('' + nativePromiseThen).indexOf('[native code]') === -1) {
1042	  incrementExpectedAwaits = decrementExpectedAwaits = nop;
1043	}
1044	function onPossibleParallellAsync(possiblePromise) {
1045	  if (task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) {
1046	    incrementExpectedAwaits();
1047	    return possiblePromise.then(function (x) {
1048	      decrementExpectedAwaits();
1049	      return x;
1050	    }, function (e) {
1051	      decrementExpectedAwaits();
1052	      return rejection(e);
1053	    });
1054	  }
1055	  return possiblePromise;
1056	}
1057	function zoneEnterEcho(targetZone) {
1058	  ++totalEchoes;
1059	  if (!task.echoes || --task.echoes === 0) {
1060	    task.echoes = task.id = 0;
1061	  }
1062	  zoneStack.push(PSD);
1063	  switchToZone(targetZone, true);
1064	}
1065	function zoneLeaveEcho() {
1066	  var zone = zoneStack[zoneStack.length - 1];
1067	  zoneStack.pop();
1068	  switchToZone(zone, false);
1069	}
1070	function switchToZone(targetZone, bEnteringZone) {
1071	  var currentZone = PSD;
1072	  if (bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (! --zoneEchoes || targetZone !== PSD)) {
1073	    enqueueNativeMicroTask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho);
1074	  }
1075	  if (targetZone === PSD) return;
1076	  PSD = targetZone;
1077	  if (currentZone === globalPSD) globalPSD.env = snapShot();
1078	  if (patchGlobalPromise) {
1079	    var GlobalPromise_1 = globalPSD.env.Promise;
1080	    var targetEnv = targetZone.env;
1081	    nativePromiseProto.then = targetEnv.nthen;
1082	    GlobalPromise_1.prototype.then = targetEnv.gthen;
1083	    if (currentZone.global || targetZone.global) {
1084	      Object.defineProperty(_global, 'Promise', targetEnv.PromiseProp);
1085	      GlobalPromise_1.all = targetEnv.all;
1086	      GlobalPromise_1.race = targetEnv.race;
1087	      GlobalPromise_1.resolve = targetEnv.resolve;
1088	      GlobalPromise_1.reject = targetEnv.reject;
1089	      if (targetEnv.allSettled) GlobalPromise_1.allSettled = targetEnv.allSettled;
1090	      if (targetEnv.any) GlobalPromise_1.any = targetEnv.any;
1091	    }
1092	  }
1093	}
1094	function snapShot() {
1095	  var GlobalPromise = _global.Promise || Promise; // tag 02032020
1096	  return patchGlobalPromise ? {
1097	    Promise: GlobalPromise,
1098	    PromiseProp: Object.getOwnPropertyDescriptor(_global, "Promise"),
1099	    all: GlobalPromise.all,
1100	    race: GlobalPromise.race,
1101	    allSettled: GlobalPromise.allSettled,
1102	    any: GlobalPromise.any,
1103	    resolve: GlobalPromise.resolve,
1104	    reject: GlobalPromise.reject,
1105	    nthen: nativePromiseProto.then,
1106	    gthen: GlobalPromise.prototype.then
1107	  } : {};
1108	}
1109	function usePSD(psd, fn, a1, a2, a3) {
1110	  var outerScope = PSD;
1111	  try {
1112	    switchToZone(psd, true);
1113	    return fn(a1, a2, a3);
1114	  } finally {
1115	    switchToZone(outerScope, false);
1116	  }
1117	}
1118	function enqueueNativeMicroTask(job) {
1119	  nativePromiseThen.call(resolvedNativePromise, job);
1120	}
1121	function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) {
1122	  return typeof fn !== 'function' ? fn : function () {
1123	    var outerZone = PSD;
1124	    if (possibleAwait) incrementExpectedAwaits();
1125	    switchToZone(zone, true);
1126	    try {
1127	      return fn.apply(this, arguments);
1128	    } finally {
1129	      switchToZone(outerZone, false);
1130	      if (cleanup) enqueueNativeMicroTask(decrementExpectedAwaits);
1131	    }
1132	  };
1133	}
1134	function getPatchedPromiseThen(origThen, zone) {
1135	  return function (onResolved, onRejected) {
1136	    return origThen.call(this, nativeAwaitCompatibleWrap(onResolved, zone), nativeAwaitCompatibleWrap(onRejected, zone));
1137	  };
1138	}
1139	var UNHANDLEDREJECTION = "unhandledrejection";
1140	function globalError(err, promise) {
1141	  var rv;
1142	  try {
1143	    rv = promise.onuncatched(err);
1144	  } catch (e) {}
1145	  if (rv !== false) try {
1146	    var event,
1147	      eventData = {
1148	        promise: promise,
1149	        reason: err
1150	      };
1151	    if (_global.document && document.createEvent) {
1152	      event = document.createEvent('Event');
1153	      event.initEvent(UNHANDLEDREJECTION, true, true);
1154	      extend(event, eventData);
1155	    } else if (_global.CustomEvent) {
1156	      event = new CustomEvent(UNHANDLEDREJECTION, {
1157	        detail: eventData
1158	      });
1159	      extend(event, eventData);
1160	    }
1161	    if (event && _global.dispatchEvent) {
1162	      dispatchEvent(event);
1163	      if (!_global.PromiseRejectionEvent && _global.onunhandledrejection) try {
1164	        _global.onunhandledrejection(event);
1165	      } catch (_) {}
1166	    }
1167	    if (debug && event && !event.defaultPrevented) {
1168	      console.warn("Unhandled rejection: " + (err.stack || err));
1169	    }
1170	  } catch (e) {}
1171	}
1172	var rejection = DexiePromise.reject;
1173	function tempTransaction(db, mode, storeNames, fn) {
1174	  if (!db.idbdb || !db._state.openComplete && !PSD.letThrough && !db._vip) {
1175	    if (db._state.openComplete) {
1176	      return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));
1177	    }
1178	    if (!db._state.isBeingOpened) {
1179	      if (!db._options.autoOpen) return rejection(new exceptions.DatabaseClosed());
1180	      db.open()["catch"](nop);
1181	    }
1182	    return db._state.dbReadyPromise.then(function () {
1183	      return tempTransaction(db, mode, storeNames, fn);
1184	    });
1185	  } else {
1186	    var trans = db._createTransaction(mode, storeNames, db._dbSchema);
1187	    try {
1188	      trans.create();
1189	      db._state.PR1398_maxLoop = 3;
1190	    } catch (ex) {
1191	      if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) {
1192	        console.warn('Dexie: Need to reopen db');
1193	        db._close();
1194	        return db.open().then(function () {
1195	          return tempTransaction(db, mode, storeNames, fn);
1196	        });
1197	      }
1198	      return rejection(ex);
1199	    }
1200	    return trans._promise(mode, function (resolve, reject) {
1201	      return newScope(function () {
1202	        PSD.trans = trans;
1203	        return fn(resolve, reject, trans);
1204	      });
1205	    }).then(function (result) {
1206	      return trans._completion.then(function () {
1207	        return result;
1208	      });
1209	    });
1210	  }
1211	}
1212	var DEXIE_VERSION = '3.2.2';
1213	var maxString = String.fromCharCode(65535);
1214	var minKey = -Infinity;
1215	var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
1216	var STRING_EXPECTED = "String expected.";
1217	var connections = [];
1218	var isIEOrEdge = typeof navigator !== 'undefined' && /(MSIE|Trident|Edge)/.test(navigator.userAgent);
1219	var hasIEDeleteObjectStoreBug = isIEOrEdge;
1220	var hangsOnDeleteLargeKeyRange = isIEOrEdge;
1221	var dexieStackFrameFilter = function dexieStackFrameFilter(frame) {
1222	  return !/(dexie\.js|dexie\.min\.js)/.test(frame);
1223	};
1224	var DBNAMES_DB = '__dbnames';
1225	var READONLY = 'readonly';
1226	var READWRITE = 'readwrite';
1227	function combine(filter1, filter2) {
1228	  return filter1 ? filter2 ? function () {
1229	    return filter1.apply(this, arguments) && filter2.apply(this, arguments);
1230	  } : filter1 : filter2;
1231	}
1232	var AnyRange = {
1233	  type: 3,
1234	  lower: -Infinity,
1235	  lowerOpen: false,
1236	  upper: [[]],
1237	  upperOpen: false
1238	};

1239	function workaroundForUndefinedPrimKey(keyPath) {
1240	  return typeof keyPath === "string" && !/\./.test(keyPath) ? function (obj) {
1241	    if (obj[keyPath] === undefined && keyPath in obj) {
1242	      obj = deepClone(obj);
1243	      delete obj[keyPath];
1244	    }
1245	    return obj;
1246	  } : function (obj) {
1247	    return obj;
1248	  };
1249	}
1250	var Table = function () {
1251	  function Table() {}
1252	  Table.prototype._trans = function (mode, fn, writeLocked) {
1253	    var trans = this._tx || PSD.trans;
1254	    var tableName = this.name;
1255	    function checkTableInTransaction(resolve, reject, trans) {
1256	      if (!trans.schema[tableName]) throw new exceptions.NotFound("Table " + tableName + " not part of transaction");
1257	      return fn(trans.idbtrans, trans);
1258	    }
1259	    var wasRootExec = beginMicroTickScope();
1260	    try {
1261	      return trans && trans.db === this.db ? trans === PSD.trans ? trans._promise(mode, checkTableInTransaction, writeLocked) : newScope(function () {
1262	        return trans._promise(mode, checkTableInTransaction, writeLocked);
1263	      }, {
1264	        trans: trans,
1265	        transless: PSD.transless || PSD
1266	      }) : tempTransaction(this.db, mode, [this.name], checkTableInTransaction);
1267	    } finally {
1268	      if (wasRootExec) endMicroTickScope();
1269	    }
1270	  };
1271	  Table.prototype.get = function (keyOrCrit, cb) {
1272	    var _this = this;
1273	    if (keyOrCrit && keyOrCrit.constructor === Object) return this.where(keyOrCrit).first(cb);
1274	    return this._trans('readonly', function (trans) {
1275	      return _this.core.get({
1276	        trans: trans,
1277	        key: keyOrCrit
1278	      }).then(function (res) {
1279	        return _this.hook.reading.fire(res);
1280	      });
1281	    }).then(cb);
1282	  };
1283	  Table.prototype.where = function (indexOrCrit) {
1284	    if (typeof indexOrCrit === 'string') return new this.db.WhereClause(this, indexOrCrit);
1285	    if (isArray(indexOrCrit)) return new this.db.WhereClause(this, "[" + indexOrCrit.join('+') + "]");
1286	    var keyPaths = keys(indexOrCrit);
1287	    if (keyPaths.length === 1) return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]);
1288	    var compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter(function (ix) {
1289	      return ix.compound && keyPaths.every(function (keyPath) {
1290	        return ix.keyPath.indexOf(keyPath) >= 0;
1291	      }) && ix.keyPath.every(function (keyPath) {
1292	        return keyPaths.indexOf(keyPath) >= 0;
1293	      });
1294	    })[0];
1295	    if (compoundIndex && this.db._maxKey !== maxString) return this.where(compoundIndex.name).equals(compoundIndex.keyPath.map(function (kp) {
1296	      return indexOrCrit[kp];
1297	    }));
1298	    if (!compoundIndex && debug) console.warn("The query " + JSON.stringify(indexOrCrit) + " on " + this.name + " would benefit of a " + ("compound index [" + keyPaths.join('+') + "]"));
1299	    var idxByName = this.schema.idxByName;
1300	    var idb = this.db._deps.indexedDB;
1301	    function equals(a, b) {
1302	      try {
1303	        return idb.cmp(a, b) === 0;
1304	      } catch (e) {
1305	        return false;
1306	      }
1307	    }
1308	    var _a = keyPaths.reduce(function (_a, keyPath) {
1309	        var prevIndex = _a[0],
1310	          prevFilterFn = _a[1];
1311	        var index = idxByName[keyPath];
1312	        var value = indexOrCrit[keyPath];
1313	        return [prevIndex || index, prevIndex || !index ? combine(prevFilterFn, index && index.multi ? function (x) {
1314	          var prop = getByKeyPath(x, keyPath);
1315	          return isArray(prop) && prop.some(function (item) {
1316	            return equals(value, item);
1317	          });
1318	        } : function (x) {
1319	          return equals(value, getByKeyPath(x, keyPath));
1320	        }) : prevFilterFn];
1321	      }, [null, null]),
1322	      idx = _a[0],
1323	      filterFunction = _a[1];
1324	    return idx ? this.where(idx.name).equals(indexOrCrit[idx.keyPath]).filter(filterFunction) : compoundIndex ? this.filter(filterFunction) : this.where(keyPaths).equals('');
1325	  };
1326	  Table.prototype.filter = function (filterFunction) {
1327	    return this.toCollection().and(filterFunction);
1328	  };
1329	  Table.prototype.count = function (thenShortcut) {
1330	    return this.toCollection().count(thenShortcut);
1331	  };
1332	  Table.prototype.offset = function (offset) {
1333	    return this.toCollection().offset(offset);
1334	  };
1335	  Table.prototype.limit = function (numRows) {
1336	    return this.toCollection().limit(numRows);
1337	  };
1338	  Table.prototype.each = function (callback) {
1339	    return this.toCollection().each(callback);
1340	  };
1341	  Table.prototype.toArray = function (thenShortcut) {
1342	    return this.toCollection().toArray(thenShortcut);
1343	  };
1344	  Table.prototype.toCollection = function () {
1345	    return new this.db.Collection(new this.db.WhereClause(this));
1346	  };
1347	  Table.prototype.orderBy = function (index) {
1348	    return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? "[" + index.join('+') + "]" : index));
1349	  };
1350	  Table.prototype.reverse = function () {
1351	    return this.toCollection().reverse();
1352	  };
1353	  Table.prototype.mapToClass = function (constructor) {
1354	    this.schema.mappedClass = constructor;
1355	    var readHook = function readHook(obj) {
1356	      if (!obj) return obj;
1357	      var res = Object.create(constructor.prototype);
1358	      for (var m in obj) if (hasOwn(obj, m)) try {
1359	        res[m] = obj[m];
1360	      } catch (_) {}
1361	      return res;
1362	    };
1363	    if (this.schema.readHook) {
1364	      this.hook.reading.unsubscribe(this.schema.readHook);
1365	    }
1366	    this.schema.readHook = readHook;
1367	    this.hook("reading", readHook);
1368	    return constructor;
1369	  };
1370	  Table.prototype.defineClass = function () {
1371	    function Class(content) {
1372	      extend(this, content);
1373	    }
1374	    return this.mapToClass(Class);
1375	  };
1376	  Table.prototype.add = function (obj, key) {
1377	    var _this = this;
1378	    var _a = this.schema.primKey,
1379	      auto = _a.auto,
1380	      keyPath = _a.keyPath;
1381	    var objToAdd = obj;
1382	    if (keyPath && auto) {

1383	      objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
1384	    }
1385	    return this._trans('readwrite', function (trans) {
1386	      return _this.core.mutate({
1387	        trans: trans,
1388	        type: 'add',
1389	        keys: key != null ? [key] : null,
1390	        values: [objToAdd]
1391	      });
1392	    }).then(function (res) {
1393	      return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult;
1394	    }).then(function (lastResult) {
1395	      if (keyPath) {
1396	        try {
1397	          setByKeyPath(obj, keyPath, lastResult);
1398	        } catch (_) {}
1399	      }
1400	      return lastResult;
1401	    });
1402	  };
1403	  Table.prototype.update = function (keyOrObject, modifications) {
1404	    if (babelHelpers["typeof"](keyOrObject) === 'object' && !isArray(keyOrObject)) {
1405	      var key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath);
1406	      if (key === undefined) return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key"));
1407	      try {
1408	        if (typeof modifications !== "function") {
1409	          keys(modifications).forEach(function (keyPath) {
1410	            setByKeyPath(keyOrObject, keyPath, modifications[keyPath]);
1411	          });
1412	        } else {
1413	          modifications(keyOrObject, {
1414	            value: keyOrObject,
1415	            primKey: key
1416	          });
1417	        }
1418	      } catch (_a) {}
1419	      return this.where(":id").equals(key).modify(modifications);
1420	    } else {
1421	      return this.where(":id").equals(keyOrObject).modify(modifications);
1422	    }
1423	  };
1424	  Table.prototype.put = function (obj, key) {
1425	    var _this = this;
1426	    var _a = this.schema.primKey,
1427	      auto = _a.auto,
1428	      keyPath = _a.keyPath;
1429	    var objToAdd = obj;
1430	    if (keyPath && auto) {

1431	      objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj);
1432	    }
1433	    return this._trans('readwrite', function (trans) {
1434	      return _this.core.mutate({
1435	        trans: trans,
1436	        type: 'put',
1437	        values: [objToAdd],
1438	        keys: key != null ? [key] : null
1439	      });
1440	    }).then(function (res) {
1441	      return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult;
1442	    }).then(function (lastResult) {
1443	      if (keyPath) {
1444	        try {
1445	          setByKeyPath(obj, keyPath, lastResult);
1446	        } catch (_) {}
1447	      }
1448	      return lastResult;
1449	    });
1450	  };
1451	  Table.prototype["delete"] = function (key) {
1452	    var _this = this;
1453	    return this._trans('readwrite', function (trans) {
1454	      return _this.core.mutate({
1455	        trans: trans,
1456	        type: 'delete',
1457	        keys: [key]
1458	      });
1459	    }).then(function (res) {
1460	      return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined;
1461	    });
1462	  };
1463	  Table.prototype.clear = function () {
1464	    var _this = this;
1465	    return this._trans('readwrite', function (trans) {
1466	      return _this.core.mutate({
1467	        trans: trans,
1468	        type: 'deleteRange',
1469	        range: AnyRange
1470	      });
1471	    }).then(function (res) {
1472	      return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined;
1473	    });
1474	  };
1475	  Table.prototype.bulkGet = function (keys) {
1476	    var _this = this;
1477	    return this._trans('readonly', function (trans) {
1478	      return _this.core.getMany({
1479	        keys: keys,
1480	        trans: trans
1481	      }).then(function (result) {
1482	        return result.map(function (res) {
1483	          return _this.hook.reading.fire(res);
1484	        });
1485	      });
1486	    });
1487	  };
1488	  Table.prototype.bulkAdd = function (objects, keysOrOptions, options) {
1489	    var _this = this;
1490	    var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
1491	    options = options || (keys ? undefined : keysOrOptions);
1492	    var wantResults = options ? options.allKeys : undefined;
1493	    return this._trans('readwrite', function (trans) {
1494	      var _a = _this.schema.primKey,
1495	        auto = _a.auto,
1496	        keyPath = _a.keyPath;
1497	      if (keyPath && keys) throw new exceptions.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");
1498	      if (keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
1499	      var numObjects = objects.length;
1500	      var objectsToAdd = keyPath && auto ? objects.map(workaroundForUndef

1500inedPrimKey(keyPath)) : objects;
1501	      return _this.core.mutate({
1502	        trans: trans,
1503	        type: 'add',
1504	        keys: keys,
1505	        values: objectsToAdd,
1506	        wantResults: wantResults
1507	      }).then(function (_a) {
1508	        var numFailures = _a.numFailures,
1509	          results = _a.results,
1510	          lastResult = _a.lastResult,
1511	          failures = _a.failures;
1512	        var result = wantResults ? results : lastResult;
1513	        if (numFailures === 0) return result;
1514	        throw new BulkError(_this.name + ".bulkAdd(): " + numFailures + " of " + numObjects + " operations failed", failures);
1515	      });
1516	    });
1517	  };
1518	  Table.prototype.bulkPut = function (objects, keysOrOptions, options) {
1519	    var _this = this;
1520	    var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined;
1521	    options = options || (keys ? undefined : keysOrOptions);
1522	    var wantResults = options ? options.allKeys : undefined;
1523	    return this._trans('readwrite', function (trans) {
1524	      var _a = _this.schema.primKey,
1525	        auto = _a.auto,
1526	        keyPath = _a.keyPath;
1527	      if (keyPath && keys) throw new exceptions.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");
1528	      if (keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length");
1529	      var numObjects = objects.length;
1530	      var objectsToPut = keyPath && auto ? objects.map(workaroundForUndef

1530inedPrimKey(keyPath)) : objects;
1531	      return _this.core.mutate({
1532	        trans: trans,
1533	        type: 'put',
1534	        keys: keys,
1535	        values: objectsToPut,
1536	        wantResults: wantResults
1537	      }).then(function (_a) {
1538	        var numFailures = _a.numFailures,
1539	          results = _a.results,
1540	          lastResult = _a.lastResult,
1541	          failures = _a.failures;
1542	        var result = wantResults ? results : lastResult;
1543	        if (numFailures === 0) return result;
1544	        throw new BulkError(_this.name + ".bulkPut(): " + numFailures + " of " + numObjects + " operations failed", failures);
1545	      });
1546	    });
1547	  };
1548	  Table.prototype.bulkDelete = function (keys) {
1549	    var _this = this;
1550	    var numKeys = keys.length;
1551	    return this._trans('readwrite', function (trans) {
1552	      return _this.core.mutate({
1553	        trans: trans,
1554	        type: 'delete',
1555	        keys: keys
1556	      });
1557	    }).then(function (_a) {
1558	      var numFailures = _a.numFailures,
1559	        lastResult = _a.lastResult,
1560	        failures = _a.failures;
1561	      if (numFailures === 0) return lastResult;
1562	      throw new BulkError(_this.name + ".bulkDelete(): " + numFailures + " of " + numKeys + " operations failed", failures);
1563	    });
1564	  };
1565	  return Table;
1566	}();
1567	function Events(ctx) {
1568	  var evs = {};
1569	  var rv = function rv(eventName, subscriber) {
1570	    if (subscriber) {
1571	      var i = arguments.length,
1572	        args = new Array(i - 1);
1573	      while (--i) args[i - 1] = arguments[i];
1574	      evs[eventName].subscribe.apply(null, args);
1575	      return ctx;
1576	    } else if (typeof eventName === 'string') {
1577	      return evs[eventName];
1578	    }
1579	  };
1580	  rv.addEventType = add;
1581	  for (var i = 1, l = arguments.length; i < l; ++i) {
1582	    add(arguments[i]);
1583	  }
1584	  return rv;
1585	  function add(eventName, chainFunction, defaultFunction) {
1586	    if (babelHelpers["typeof"](eventName) === 'object') return addConfiguredEvents(eventName);
1587	    if (!chainFunction) chainFunction = reverseStoppableEventChain;
1588	    if (!defaultFunction) defaultFunction = nop;
1589	    var context = {
1590	      subscribers: [],
1591	      fire: defaultFunction,
1592	      subscribe: function subscribe(cb) {
1593	        if (context.subscribers.indexOf(cb) === -1) {
1594	          context.subscribers.push(cb);
1595	          context.fire = chainFunction(context.fire, cb);
1596	        }
1597	      },
1598	      unsubscribe: function unsubscribe(cb) {
1599	        context.subscribers = context.subscribers.filter(function (fn) {
1600	          return fn !== cb;
1601	        });
1602	        context.fire = context.subscribers.reduce(chainFunction, defaultFunction);
1603	      }
1604	    };
1605	    evs[eventName] = rv[eventName] = context;
1606	    return context;
1607	  }
1608	  function addConfiguredEvents(cfg) {
1609	    keys(cfg).forEach(function (eventName) {
1610	      var args = cfg[eventName];
1611	      if (isArray(args)) {
1612	        add(eventName, cfg[eventName][0], cfg[eventName][1]);
1613	      } else if (args === 'asap') {
1614	        var context = add(eventName, mirror, function fire() {
1615	          var i = arguments.length,
1616	            args = new Array(i);
1617	          while (i--) args[i] = arguments[i];
1618	          context.subscribers.forEach(function (fn) {
1619	            asap$1(function fireEvent() {
1620	              fn.apply(null, args);
1621	            });
1622	          });
1623	        });
1624	      } else throw new exceptions.InvalidArgument("Invalid event config");
1625	    });
1626	  }
1627	}
1628	function makeClassConstructor(prototype, constructor) {
1629	  derive(constructor).from({
1630	    prototype: prototype
1631	  });
1632	  return constructor;
1633	}
1634	function createTableConstructor(db) {
1635	  return makeClassConstructor(Table.prototype, function Table(name, tableSchema, trans) {
1636	    this.db = db;
1637	    this._tx = trans;
1638	    this.name = name;
1639	    this.schema = tableSchema;
1640	    this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, {
1641	      "creating": [hookCreatingChain, nop],
1642	      "reading": [pureFunctionChain, mirror],
1643	      "updating": [hookUpdatingChain, nop],
1644	      "deleting": [hookDeletingChain, nop]
1645	    });
1646	  });
1647	}
1648	function isPlainKeyRange(ctx, ignoreLimitFilter) {
1649	  return !(ctx.filter || ctx.algorithm || ctx.or) && (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter);
1650	}
1651	function addFilter(ctx, fn) {

1652	  ctx.filter = combine(ctx.filter, fn);
1653	}
1654	function addReplayFilter(ctx, factory, isLimitFilter) {
1655	  var curr = ctx.replayFilter;
1656	  ctx.replayFilter = curr ? function () {
1657	    return combine(curr(), factory());
1658	  } : factory;
1659	  ctx.justLimit = isLimitFilter && !curr;
1660	}
1661	function addMatchFilter(ctx, fn) {
1662	  ctx.isMatch = combine(ctx.isMatch, fn);
1663	}
1664	function getIndexOrStore(ctx, coreSchema) {
1665	  if (ctx.isPrimKey) return coreSchema.primaryKey;
1666	  var index = coreSchema.getIndexByKeyPath(ctx.index);
1667	  if (!index) throw new exceptions.Schema("KeyPath " + ctx.index + " on object store " + coreSchema.name + " is not indexed");
1668	  return index;
1669	}
1670	function openCursor(ctx, coreTable, trans) {
1671	  var index = getIndexOrStore(ctx, coreTable.schema);
1672	  return coreTable.openCursor({
1673	    trans: trans,
1674	    values: !ctx.keysOnly,
1675	    reverse: ctx.dir === 'prev',
1676	    unique: !!ctx.unique,
1677	    query: {
1678	      index: index,
1679	      range: ctx.range
1680	    }
1681	  });
1682	}
1683	function iter(ctx, fn, coreTrans, coreTable) {
1684	  var filter = ctx.replayFilter ? combine(ctx.filter, ctx.replayFilter()) : ctx.filter;
1685	  if (!ctx.or) {
1686	    return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper);
1687	  } else {
1688	    var set_1 = {};
1689	    var union = function union(item, cursor, advance) {
1690	      if (!filter || filter(cursor, advance, function (result) {
1691	        return cursor.stop(result);
1692	      }, function (err) {
1693	        return cursor.fail(err);
1694	      })) {
1695	        var primaryKey = cursor.primaryKey;
1696	        var key = '' + primaryKey;
1697	        if (key === '[object ArrayBuffer]') key = '' + new Uint8Array(primaryKey);
1698	        if (!hasOwn(set_1, key)) {
1699	          set_1[key] = true;
1700	          fn(item, cursor, advance);
1701	        }
1702	      }
1703	    };
1704	    return Promise.all([ctx.or._iterate(union, coreTrans), iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper)]);
1705	  }
1706	}
1707	function iterate(cursorPromise, filter, fn, valueMapper) {
1708	  var mappedFn = valueMapper ? function (x, c, a) {
1709	    return fn(valueMapper(x), c, a);
1710	  } : fn;
1711	  var wrappedFn = wrap(mappedFn);
1712	  return cursorPromise.then(function (cursor) {
1713	    if (cursor) {
1714	      return cursor.start(function () {
1715	        var c = function c() {
1716	          return cursor["continue"]();
1717	        };
1718	        if (!filter || filter(cursor, function (advancer) {
1719	          return c = advancer;
1720	        }, function (val) {
1721	          cursor.stop(val);
1722	          c = nop;
1723	        }, function (e) {
1724	          cursor.fail(e);
1725	          c = nop;
1726	        })) wrappedFn(cursor.value, cursor, function (advancer) {
1727	          return c = advancer;
1728	        });
1729	        c();
1730	      });
1731	    }
1732	  });
1733	}
1734	function cmp(a, b) {
1735	  try {
1736	    var ta = type(a);
1737	    var tb = type(b);
1738	    if (ta !== tb) {
1739	      if (ta === 'Array') return 1;
1740	      if (tb === 'Array') return -1;
1741	      if (ta === 'binary') return 1;
1742	      if (tb === 'binary') return -1;
1743	      if (ta === 'string') return 1;
1744	      if (tb === 'string') return -1;
1745	      if (ta === 'Date') return 1;
1746	      if (tb !== 'Date') return NaN;
1747	      return -1;
1748	    }
1749	    switch (ta) {
1750	      case 'number':
1751	      case 'Date':
1752	      case 'string':
1753	        return a > b ? 1 : a < b ? -1 : 0;
1754	      case 'binary':
1755	        {
1756	          return compareUint8Arrays(getUint8Array(a), getUint8Array(b));
1757	        }
1758	      case 'Array':
1759	        return compareArrays(a, b);
1760	    }
1761	  } catch (_a) {}
1762	  return NaN;
1763	}
1764	function compareArrays(a, b) {
1765	  var al = a.length;
1766	  var bl = b.length;
1767	  var l = al < bl ? al : bl;
1768	  for (var i = 0; i < l; ++i) {
1769	    var res = cmp(a[i], b[i]);
1770	    if (res !== 0) return res;
1771	  }
1772	  return al === bl ? 0 : al < bl ? -1 : 1;
1773	}
1774	function compareUint8Arrays(a, b) {
1775	  var al = a.length;
1776	  var bl = b.length;
1777	  var l = al < bl ? al : bl;
1778	  for (var i = 0; i < l; ++i) {
1779	    if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
1780	  }
1781	  return al === bl ? 0 : al < bl ? -1 : 1;
1782	}
1783	function type(x) {
1784	  var t = babelHelpers["typeof"](x);
1785	  if (t !== 'object') return t;
1786	  if (ArrayBuffer.isView(x)) return 'binary';
1787	  var tsTag = toStringTag(x);
1788	  return tsTag === 'ArrayBuffer' ? 'binary' : tsTag;
1789	}
1790	function getUint8Array(a) {
1791	  if (a instanceof Uint8Array) return a;
1792	  if (ArrayBuffer.isView(a)) return new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
1793	  return new Uint8Array(a);
1794	}
1795	var Collection = function () {
1796	  function Collection() {}
1797	  Collection.prototype._read = function (fn, cb) {
1798	    var ctx = this._ctx;
1799	    return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readonly', fn).then(cb);
1800	  };
1801	  Collection.prototype._write = function (fn) {
1802	    var ctx = this._ctx;
1803	    return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readwrite', fn, "locked");
1804	  };
1805	  Collection.prototype._addAlgorithm = function (fn) {
1806	    var ctx = this._ctx;
1807	    ctx.algorithm = combine(ctx.algorithm, fn);
1808	  };
1809	  Collection.prototype._iterate = function (fn, coreTrans) {
1810	    return iter(this._ctx, fn, coreTrans, this._ctx.table.core);
1811	  };
1812	  Collection.prototype.clone = function (props) {
1813	    var rv = Object.create(this.constructor.prototype),
1814	      ctx = Object.create(this._ctx);
1815	    if (props) extend(ctx, props);
1816	    rv._ctx = ctx;
1817	    return rv;
1818	  };
1819	  Collection.prototype.raw = function () {
1820	    this._ctx.valueMapper = null;
1821	    return this;
1822	  };

1823	  Collection.prototype.each = function (fn) {
1824	    var ctx = this._ctx;
1825	    return this._read(function (trans) {
1826	      return iter(ctx, fn, trans, ctx.table.core);
1827	    });
1828	  };
1829	  Collection.prototype.count = function (cb) {
1830	    var _this = this;
1831	    return this._read(function (trans) {
1832	      var ctx = _this._ctx;
1833	      var coreTable = ctx.table.core;
1834	      if (isPlainKeyRange(ctx, true)) {
1835	        return coreTable.count({
1836	          trans: trans,
1837	          query: {
1838	            index: getIndexOrStore(ctx, coreTable.schema),
1839	            range: ctx.range
1840	          }
1841	        }).then(function (count) {
1842	          return Math.min(count, ctx.limit);
1843	        });
1844	      } else {
1845	        var count = 0;
1846	        return iter(ctx, function () {
1847	          ++count;
1848	          return false;
1849	        }, trans, coreTable).then(function () {
1850	          return count;
1851	        });
1852	      }
1853	    }).then(cb);
1854	  };
1855	  Collection.prototype.sortBy = function (keyPath, cb) {
1856	    var parts = keyPath.split('.').reverse(),
1857	      lastPart = parts[0],
1858	      lastIndex = parts.length - 1;
1859	    function getval(obj, i) {
1860	      if (i) return getval(obj[parts[i]], i - 1);
1861	      return obj[lastPart];
1862	    }
1863	    var order = this._ctx.dir === "next" ? 1 : -1;
1864	    function sorter(a, b) {
1865	      var aVal = getval(a, lastIndex),
1866	        bVal = getval(b, lastIndex);
1867	      return aVal < bVal ? -order : aVal > bVal ? order : 0;
1868	    }
1869	    return this.toArray(function (a) {
1870	      return a.sort(sorter);
1871	    }).then(cb);
1872	  };

1873	  Collection.prototype.toArray = function (cb) {
1874	    var _this = this;
1875	    return this._read(function (trans) {
1876	      var ctx = _this._ctx;
1877	      if (ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0) {
1878	        var valueMapper_1 = ctx.valueMapper;
1879	        var index = getIndexOrStore(ctx, ctx.table.core.schema);
1880	        return ctx.table.core.query({
1881	          trans: trans,
1882	          limit: ctx.limit,
1883	          values: true,
1884	          query: {
1885	            index: index,
1886	            range: ctx.range
1887	          }
1888	        }).then(function (_a) {
1889	          var result = _a.result;
1890	          return valueMapper_1 ? result.map(valueMapper_1) : result;
1891	        });
1892	      } else {
1893	        var a_1 = [];
1894	        return iter(ctx, function (item) {
1895	          return a_1.push(item);
1896	        }, trans, ctx.table.core).then(function () {
1897	          return a_1;
1898	        });
1899	      }
1900	    }, cb);
1901	  };
1902	  Collection.prototype.offset = function (offset) {
1903	    var ctx = this._ctx;
1904	    if (offset <= 0) return this;
1905	    ctx.offset += offset;
1906	    if (isPlainKeyRange(ctx)) {
1907	      addReplayFilter(ctx, function () {
1908	        var offsetLeft = offset;
1909	        return function (cursor, advance) {
1910	          if (offsetLeft === 0) return true;
1911	          if (offsetLeft === 1) {
1912	            --offsetLeft;
1913	            return false;
1914	          }
1915	          advance(function () {
1916	            cursor.advance(offsetLeft);
1917	            offsetLeft = 0;
1918	          });
1919	          return false;
1920	        };
1921	      });
1922	    } else {
1923	      addReplayFilter(ctx, function () {
1924	        var offsetLeft = offset;
1925	        return function () {
1926	          return --offsetLeft < 0;
1927	        };
1928	      });
1929	    }
1930	    return this;
1931	  };

1932	  Collection.prototype.limit = function (numRows) {
1933	    this._ctx.limit = Math.min(this._ctx.limit, numRows);
1934	    addReplayFilter(this._ctx, function () {
1935	      var rowsLeft = numRows;
1936	      return function (cursor, advance, resolve) {
1937	        if (--rowsLeft <= 0) advance(resolve);
1938	        return rowsLeft >= 0;
1939	      };
1940	    }, true);
1941	    return this;
1942	  };
1943	  Collection.prototype.until = function (filterFunction, bIncludeStopEntry) {
1944	    addFilter(this._ctx, function (cursor, advance, resolve) {
1945	      if (filterFunction(cursor.value)) {
1946	        advance(resolve);
1947	        return bIncludeStopEntry;
1948	      } else {
1949	        return true;
1950	      }
1951	    });
1952	    return this;
1953	  };
1954	  Collection.prototype.first = function (cb) {
1955	    return this.limit(1).toArray(function (a) {
1956	      return a[0];
1957	    }).then(cb);
1958	  };
1959	  Collection.prototype.last = function (cb) {
1960	    return this.reverse().first(cb);
1961	  };
1962	  Collection.prototype.filter = function (filterFunction) {
1963	    addFilter(this._ctx, function (cursor) {
1964	      return filterFunction(cursor.value);
1965	    });
1966	    addMatchFilter(this._ctx, filterFunction);
1967	    return this;
1968	  };
1969	  Collection.prototype.and = function (filter) {
1970	    return this.filter(filter);
1971	  };
1972	  Collection.prototype.or = function (indexName) {
1973	    return new this.db.WhereClause(this._ctx.table, indexName, this);
1974	  };
1975	  Collection.prototype.reverse = function () {
1976	    this._ctx.dir = this._ctx.dir === "prev" ? "next" : "prev";
1977	    if (this._ondirectionchange) this._ondirectionchange(this._ctx.dir);
1978	    return this;
1979	  };
1980	  Collection.prototype.desc = function () {
1981	    return this.reverse();
1982	  };
1983	  Collection.prototype.eachKey = function (cb) {
1984	    var ctx = this._ctx;
1985	    ctx.keysOnly = !ctx.isMatch;
1986	    return this.each(function (val, cursor) {
1987	      cb(cursor.key, cursor);
1988	    });
1989	  };
1990	  Collection.prototype.eachUniqueKey = function (cb) {
1991	    this._ctx.unique = "unique";
1992	    return this.eachKey(cb);
1993	  };
1994	  Collection.prototype.eachPrimaryKey = function (cb) {
1995	    var ctx = this._ctx;
1996	    ctx.keysOnly = !ctx.isMatch;
1997	    return this.each(function (val, cursor) {
1998	      cb(cursor.primaryKey, cursor);
1999	    });
2000	  };
2001	  Collection.prototype.keys = function (cb) {
2002	    var ctx = this._ctx;
2003	    ctx.keysOnly = !ctx.isMatch;
2004	    var a = [];
2005	    return this.each(function (item, cursor) {
2006	      a.push(cursor.key);
2007	    }).then(function () {
2008	      return a;
2009	    }).then(cb);
2010	  };

2011	  Collection.prototype.primaryKeys = function (cb) {
2012	    var ctx = this._ctx;
2013	    if (ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0) {
2014	      return this._read(function (trans) {
2015	        var index = getIndexOrStore(ctx, ctx.table.core.schema);
2016	        return ctx.table.core.query({
2017	          trans: trans,
2018	          values: false,
2019	          limit: ctx.limit,
2020	          query: {
2021	            index: index,
2022	            range: ctx.range
2023	          }
2024	        });
2025	      }).then(function (_a) {
2026	        var result = _a.result;
2027	        return result;
2028	      }).then(cb);
2029	    }
2030	    ctx.keysOnly = !ctx.isMatch;
2031	    var a = [];
2032	    return this.each(function (item, cursor) {
2033	      a.push(cursor.primaryKey);
2034	    }).then(function () {
2035	      return a;
2036	    }).then(cb);
2037	  };
2038	  Collection.prototype.uniqueKeys = function (cb) {
2039	    this._ctx.unique = "unique";
2040	    return this.keys(cb);
2041	  };
2042	  Collection.prototype.firstKey = function (cb) {
2043	    return this.limit(1).keys(function (a) {
2044	      return a[0];
2045	    }).then(cb);
2046	  };

2047	  Collection.prototype.lastKey = function (cb) {
2048	    return this.reverse().firstKey(cb);
2049	  };
2050	  Collection.prototype.distinct = function () {
2051	    var ctx = this._ctx,
2052	      idx = ctx.index && ctx.table.schema.idxByName[ctx.index];
2053	    if (!idx || !idx.multi) return this;
2054	    var set = {};
2055	    addFilter(this._ctx, function (cursor) {
2056	      var strKey = cursor.primaryKey.toString();
2057	      var found = hasOwn(set, strKey);
2058	      set[strKey] = true;
2059	      return !found;
2060	    });
2061	    return this;
2062	  };
2063	  Collection.prototype.modify = function (changes) {
2064	    var _this = this;
2065	    var ctx = this._ctx;
2066	    return this._write(function (trans) {
2067	      var modifyer;
2068	      if (typeof changes === 'function') {
2069	        modifyer = changes;
2070	      } else {
2071	        var keyPaths = keys(changes);
2072	        var numKeys = keyPaths.length;
2073	        modifyer = function modifyer(item) {
2074	          var anythingModified = false;
2075	          for (var i = 0; i < numKeys; ++i) {
2076	            var keyPath = keyPaths[i],
2077	              val = changes[keyPath];
2078	            if (getByKeyPath(item, keyPath) !== val) {
2079	              setByKeyPath(item, keyPath, val);
2080	              anythingModified = true;
2081	            }
2082	          }
2083	          return anythingModified;
2084	        };
2085	      }
2086	      var coreTable = ctx.table.core;
2087	      var _a = coreTable.schema.primaryKey,
2088	        outbound = _a.outbound,
2089	        extractKey = _a.extractKey;
2090	      var limit = _this.db._options.modifyChunkSize || 200;
2091	      var totalFailures = [];
2092	      var successCount = 0;
2093	      var failedKeys = [];
2094	      var applyMutateResult = function applyMutateResult(expectedCount, res) {
2095	        var failures = res.failures,
2096	          numFailures = res.numFailures;
2097	        successCount += expectedCount - numFailures;
2098	        for (var _i = 0, _a = keys(failures); _i < _a.length; _i++) {
2099	          var pos = _a[_i];
2100	          totalFailures.push(failures[pos]);
2101	        }
2102	      };
2103	      return _this.clone().primaryKeys().then(function (keys) {
2104	        var nextChunk = function nextChunk(offset) {
2105	          var count = Math.min(limit, keys.length - offset);
2106	          return coreTable.getMany({
2107	            trans: trans,
2108	            keys: keys.slice(offset, offset + count),
2109	            cache: "immutable"
2110	          }).then(function (values) {
2111	            var addValues = [];
2112	            var putValues = [];
2113	            var putKeys = outbound ? [] : null;
2114	            var deleteKeys = [];
2115	            for (var i = 0; i < count; ++i) {
2116	              var origValue = values[i];
2117	              var ctx_1 = {
2118	                value: deepClone(origValue),
2119	                primKey: keys[offset + i]
2120	              };
2121	              if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) {
2122	                if (ctx_1.value == null) {
2123	                  deleteKeys.push(keys[offset + i]);
2124	                } else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) {
2125	                  deleteKeys.push(keys[offset + i]);
2126	                  addValues.push(ctx_1.value);
2127	                } else {
2128	                  putValues.push(ctx_1.value);
2129	                  if (outbound) putKeys.push(keys[offset + i]);
2130	                }
2131	              }
2132	            }
2133	            var criteria = isPlainKeyRange(ctx) && ctx.limit === Infinity && (typeof changes !== 'function' || changes === deleteCallback) && {
2134	              index: ctx.index,
2135	              range: ctx.range
2136	            };
2137	            return Promise.resolve(addValues.length > 0 && coreTable.mutate({
2138	              trans: trans,
2139	              type: 'add',
2140	              values: addValues
2141	            }).then(function (res) {
2142	              for (var pos in res.failures) {
2143	                deleteKeys.splice(parseInt(pos), 1);
2144	              }
2145	              applyMutateResult(addValues.length, res);
2146	            })).then(function () {
2147	              return (putValues.length > 0 || criteria && babelHelpers["typeof"](changes) === 'object') && coreTable.mutate({
2148	                trans: trans,
2149	                type: 'put',
2150	                keys: putKeys,
2151	                values: putValues,
2152	                criteria: criteria,
2153	                changeSpec: typeof changes !== 'function' && changes
2154	              }).then(function (res) {
2155	                return applyMutateResult(putValues.length, res);
2156	              });
2157	            }).then(function () {
2158	              return (deleteKeys.length > 0 || criteria && changes === deleteCallback) && coreTable.mutate({
2159	                trans: trans,
2160	                type: 'delete',
2161	                keys: deleteKeys,
2162	                criteria: criteria
2163	              }).then(function (res) {
2164	                return applyMutateResult(deleteKeys.length, res);
2165	              });
2166	            }).then(function () {
2167	              return keys.length > offset + count && nextChunk(offset + limit);
2168	            });
2169	          });
2170	        };
2171	        return nextChunk(0).then(function () {
2172	          if (totalFailures.length > 0) throw new ModifyError("Error modifying one or more objects", totalFailures, successCount, failedKeys);
2173	          return keys.length;
2174	        });
2175	      });
2176	    });
2177	  };

2178	  Collection.prototype["delete"] = function () {
2179	    var ctx = this._ctx,
2180	      range = ctx.range;
2181	    if (isPlainKeyRange(ctx) && (ctx.isPrimKey && !hangsOnDeleteLargeKeyRange || range.type === 3)) {
2182	      return this._write(function (trans) {
2183	        var primaryKey = ctx.table.core.schema.primaryKey;
2184	        var coreRange = range;
2185	        return ctx.table.core.count({
2186	          trans: trans,
2187	          query: {
2188	            index: primaryKey,
2189	            range: coreRange
2190	          }
2191	        }).then(function (count) {
2192	          return ctx.table.core.mutate({
2193	            trans: trans,
2194	            type: 'deleteRange',
2195	            range: coreRange
2196	          }).then(function (_a) {
2197	            var failures = _a.failures;
2198	            _a.lastResult;
2199	            _a.results;
2200	            var numFailures = _a.numFailures;
2201	            if (numFailures) throw new ModifyError("Could not delete some values", Object.keys(failures).map(function (pos) {
2202	              return failures[pos];
2203	            }), count - numFailures);
2204	            return count - numFailures;
2205	          });
2206	        });
2207	      });
2208	    }
2209	    return this.modify(deleteCallback);
2210	  };
2211	  return Collection;
2212	}();
2213	var deleteCallback = function deleteCallback(value, ctx) {
2214	  return ctx.value = null;
2215	};
2216	function createCollectionConstructor(db) {
2217	  return makeClassConstructor(Collection.prototype, function Collection(whereClause, keyRangeGenerator) {
2218	    this.db = db;
2219	    var keyRange = AnyRange,
2220	      error = null;
2221	    if (keyRangeGenerator) try {
2222	      keyRange = keyRangeGenerator();
2223	    } catch (ex) {
2224	      error = ex;
2225	    }
2226	    var whereCtx = whereClause._ctx;
2227	    var table = whereCtx.table;
2228	    var readingHook = table.hook.reading.fire;
2229	    this._ctx = {
2230	      table: table,
2231	      index: whereCtx.index,
2232	      isPrimKey: !whereCtx.index || table.schema.primKey.keyPath && whereCtx.index === table.schema.primKey.name,
2233	      range: keyRange,
2234	      keysOnly: false,
2235	      dir: "next",
2236	      unique: "",
2237	      algorithm: null,
2238	      filter: null,
2239	      replayFilter: null,
2240	      justLimit: true,
2241	      isMatch: null,
2242	      offset: 0,
2243	      limit: Infinity,
2244	      error: error,
2245	      or: whereCtx.or,
2246	      valueMapper: readingHook !== mirror ? readingHook : null
2247	    };
2248	  });
2249	}
2250	function simpleCompare(a, b) {
2251	  return a < b ? -1 : a === b ? 0 : 1;
2252	}
2253	function simpleCompareReverse(a, b) {
2254	  return a > b ? -1 : a === b ? 0 : 1;
2255	}
2256	function fail(collectionOrWhereClause, err, T) {
2257	  var collection = collectionOrWhereClause instanceof WhereClause ? new collectionOrWhereClause.Collection(collectionOrWhereClause) : collectionOrWhereClause;
2258	  collection._ctx.error = T ? new T(err) : new TypeError(err);
2259	  return collection;
2260	}
2261	function emptyCollection(whereClause) {
2262	  return new whereClause.Collection(whereClause, function () {
2263	    return rangeEqual("");
2264	  }).limit(0);
2265	}
2266	function upperFactory(dir) {
2267	  return dir === "next" ? function (s) {
2268	    return s.toUpperCase();
2269	  } : function (s) {
2270	    return s.toLowerCase();
2271	  };
2272	}
2273	function lowerFactory(dir) {
2274	  return dir === "next" ? function (s) {
2275	    return s.toLowerCase();
2276	  } : function (s) {
2277	    return s.toUpperCase();
2278	  };
2279	}
2280	function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir) {
2281	  var length = Math.min(key.length, lowerNeedle.length);
2282	  var llp = -1;
2283	  for (var i = 0; i < length; ++i) {
2284	    var lwrKeyChar = lowerKey[i];
2285	    if (lwrKeyChar !== lowerNeedle[i]) {
2286	      if (cmp(key[i], upperNeedle[i]) < 0) return key.substr(0, i) + upperNeedle[i] + upperNeedle.substr(i + 1);
2287	      if (cmp(key[i], lowerNeedle[i]) < 0) return key.substr(0, i) + lowerNeedle[i] + upperNeedle.substr(i + 1);
2288	      if (llp >= 0) return key.substr(0, llp) + lowerKey[llp] + upperNeedle.substr(llp + 1);
2289	      return null;
2290	    }
2291	    if (cmp(key[i], lwrKeyChar) < 0) llp = i;
2292	  }
2293	  if (length < lowerNeedle.length && dir === "next") return key + upperNeedle.substr(key.length);
2294	  if (length < key.length && dir === "prev") return key.substr(0, upperNeedle.length);

2295	  return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1);
2296	}
2297	function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) {
2298	  var upper,
2299	    lower,
2300	    compare,
2301	    upperNeedles,
2302	    lowerNeedles,
2303	    direction,
2304	    nextKeySuffix,
2305	    needlesLen = needles.length;
2306	  if (!needles.every(function (s) {
2307	    return typeof s === 'string';
2308	  })) {
2309	    return fail(whereClause, STRING_EXPECTED);
2310	  }
2311	  function initDirection(dir) {
2312	    upper = upperFactory(dir);
2313	    lower = lowerFactory(dir);
2314	    compare = dir === "next" ? simpleCompare : simpleCompareReverse;
2315	    var needleBounds = needles.map(function (needle) {
2316	      return {
2317	        lower: lower(needle),
2318	        upper: upper(needle)
2319	      };
2320	    }).sort(function (a, b) {
2321	      return compare(a.lower, b.lower);
2322	    });
2323	    upperNeedles = needleBounds.map(function (nb) {
2324	      return nb.upper;
2325	    });
2326	    lowerNeedles = needleBounds.map(function (nb) {
2327	      return nb.lower;
2328	    });
2329	    direction = dir;
2330	    nextKeySuffix = dir === "next" ? "" : suffix;
2331	  }
2332	  initDirection("next");
2333	  var c = new whereClause.Collection(whereClause, function () {
2334	    return createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix);
2335	  });
2336	  c._ondirectionchange = function (direction) {
2337	    initDirection(direction);
2338	  };
2339	  var firstPossibleNeedle = 0;
2340	  c._addAlgorithm(function (cursor, advance, resolve) {
2341	    var key = cursor.key;
2342	    if (typeof key !== 'string') return false;
2343	    var lowerKey = lower(key);
2344	    if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) {
2345	      return true;
2346	    } else {
2347	      var lowestPossibleCasing = null;
2348	      for (var i = firstPossibleNeedle; i < needlesLen; ++i) {
2349	        var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction);
2350	        if (casing === null && lowestPossibleCasing === null) firstPossibleNeedle = i + 1;else if (lowestPossibleCasing === null || compare(lowestPossibleCasing, casing) > 0) {
2351	          lowestPossibleCasing = casing;
2352	        }
2353	      }
2354	      if (lowestPossibleCasing !== null) {
2355	        advance(function () {
2356	          cursor["continue"](lowestPossibleCasing + nextKeySuffix);
2357	        });
2358	      } else {
2359	        advance(resolve);
2360	      }
2361	      return false;
2362	    }
2363	  });
2364	  return c;
2365	}
2366	function createRange(lower, upper, lowerOpen, upperOpen) {
2367	  return {
2368	    type: 2,
2369	    lower: lower,
2370	    upper: upper,
2371	    lowerOpen: lowerOpen,
2372	    upperOpen: upperOpen
2373	  };
2374	}
2375	function rangeEqual(value) {
2376	  return {
2377	    type: 1,
2378	    lower: value,
2379	    upper: value
2380	  };
2381	}
2382	var WhereClause = function () {
2383	  function WhereClause() {}
2384	  Object.defineProperty(WhereClause.prototype, "Collection", {
2385	    get: function get() {
2386	      return this._ctx.table.db.Collection;
2387	    },
2388	    enumerable: false,
2389	    configurable: true
2390	  });
2391	  WhereClause.prototype.between = function (lower, upper, includeLower, includeUpper) {
2392	    includeLower = includeLower !== false;
2393	    includeUpper = includeUpper === true;
2394	    try {
2395	      if (this._cmp(lower, upper) > 0 || this._cmp(lower, upper) === 0 && (includeLower || includeUpper) && !(includeLower && includeUpper)) return emptyCollection(this);
2396	      return new this.Collection(this, function () {
2397	        return createRange(lower, upper, !includeLower, !includeUpper);
2398	      });
2399	    } catch (e) {
2400	      return fail(this, INVALID_KEY_ARGUMENT);
2401	    }
2402	  };
2403	  WhereClause.prototype.equals = function (value) {
2404	    if (value == null) return fail(this, INVALID_KEY_ARGUMENT);
2405	    return new this.Collection(this, function () {
2406	      return rangeEqual(value);
2407	    });
2408	  };
2409	  WhereClause.prototype.above = function (value) {
2410	    if (value == null) return fail(this, INVALID_KEY_ARGUMENT);
2411	    return new this.Collection(this, function () {
2412	      return createRange(value, undefined, true);
2413	    });
2414	  };
2415	  WhereClause.prototype.aboveOrEqual = function (value) {
2416	    if (value == null) return fail(this, INVALID_KEY_ARGUMENT);
2417	    return new this.Collection(this, function () {
2418	      return createRange(value, undefined, false);
2419	    });
2420	  };
2421	  WhereClause.prototype.below = function (value) {
2422	    if (value == null) return fail(this, INVALID_KEY_ARGUMENT);
2423	    return new this.Collection(this, function () {
2424	      return createRange(undefined, value, false, true);
2425	    });
2426	  };
2427	  WhereClause.prototype.belowOrEqual = function (value) {
2428	    if (value == null) return fail(this, INVALID_KEY_ARGUMENT);
2429	    return new this.Collection(this, function () {
2430	      return createRange(undefined, value);
2431	    });
2432	  };
2433	  WhereClause.prototype.startsWith = function (str) {
2434	    if (typeof str !== 'string') return fail(this, STRING_EXPECTED);
2435	    return this.between(str, str + maxString, true, true);
2436	  };
2437	  WhereClause.prototype.startsWithIgnoreCase = function (str) {
2438	    if (str === "") return this.startsWith(str);
2439	    return addIgnoreCaseAlgorithm(this, function (x, a) {
2440	      return x.indexOf(a[0]) === 0;
2441	    }, [str], maxString);
2442	  };
2443	  WhereClause.prototype.equalsIgnoreCase = function (str) {
2444	    return addIgnoreCaseAlgorithm(this, function (x, a) {
2445	      return x === a[0];
2446	    }, [str], "");
2447	  };
2448	  WhereClause.prototype.anyOfIgnoreCase = function () {
2449	    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
2450	    if (set.length === 0) return emptyCollection(this);
2451	    return addIgnoreCaseAlgorithm(this, function (x, a) {
2452	      return a.indexOf(x) !== -1;
2453	    }, set, "");
2454	  };
2455	  WhereClause.prototype.startsWithAnyOfIgnoreCase = function () {
2456	    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
2457	    if (set.length === 0) return emptyCollection(this);
2458	    return addIgnoreCaseAlgorithm(this, function (x, a) {
2459	      return a.some(function (n) {
2460	        return x.indexOf(n) === 0;
2461	      });
2462	    }, set, maxString);
2463	  };
2464	  WhereClause.prototype.anyOf = function () {
2465	    var _this = this;
2466	    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
2467	    var compare = this._cmp;
2468	    try {
2469	      set.sort(compare);
2470	    } catch (e) {
2471	      return fail(this, INVALID_KEY_ARGUMENT);
2472	    }
2473	    if (set.length === 0) return emptyCollection(this);
2474	    var c = new this.Collection(this, function () {
2475	      return createRange(set[0], set[set.length - 1]);
2476	    });
2477	    c._ondirectionchange = function (direction) {
2478	      compare = direction === "next" ? _this._ascending : _this._descending;
2479	      set.sort(compare);
2480	    };
2481	    var i = 0;
2482	    c._addAlgorithm(function (cursor, advance, resolve) {
2483	      var key = cursor.key;
2484	      while (compare(key, set[i]) > 0) {
2485	        ++i;
2486	        if (i === set.length) {
2487	          advance(resolve);
2488	          return false;
2489	        }
2490	      }
2491	      if (compare(key, set[i]) === 0) {
2492	        return true;
2493	      } else {
2494	        advance(function () {
2495	          cursor["continue"](set[i]);
2496	        });
2497	        return false;
2498	      }
2499	    });
2500	    return c;
2501	  };
2502	  WhereClause.prototype.notEqual = function (value) {
2503	    return this.inAnyRange([[minKey, value], [value, this.db._maxKey]], {
2504	      includeLowers: false,
2505	      includeUppers: false
2506	    });
2507	  };
2508	  WhereClause.prototype.noneOf = function () {
2509	    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
2510	    if (set.length === 0) return new this.Collection(this);
2511	    try {
2512	      set.sort(this._ascending);
2513	    } catch (e) {
2514	      return fail(this, INVALID_KEY_ARGUMENT);
2515	    }
2516	    var ranges = set.reduce(function (res, val) {
2517	      return res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]];
2518	    }, null);
2519	    ranges.push([set[set.length - 1], this.db._maxKey]);
2520	    return this.inAnyRange(ranges, {
2521	      includeLowers: false,
2522	      includeUppers: false
2523	    });
2524	  };
2525	  WhereClause.prototype.inAnyRange = function (ranges, options) {
2526	    var _this = this;
2527	    var cmp = this._cmp,
2528	      ascending = this._ascending,
2529	      descending = this._descending,
2530	      min = this._min,
2531	      max = this._max;
2532	    if (ranges.length === 0) return emptyCollection(this);
2533	    if (!ranges.every(function (range) {
2534	      return range[0] !== undefined && range[1] !== undefined && ascending(range[0], range[1]) <= 0;
2535	    })) {
2536	      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);
2537	    }
2538	    var includeLowers = !options || options.includeLowers !== false;
2539	    var includeUppers = options && options.includeUppers === true;
2540	    function addRange(ranges, newRange) {
2541	      var i = 0,
2542	        l = ranges.length;
2543	      for (; i < l; ++i) {
2544	        var range = ranges[i];
2545	        if (cmp(newRange[0], range[1]) < 0 && cmp(newRange[1], range[0]) > 0) {
2546	          range[0] = min(range[0], newRange[0]);
2547	          range[1] = max(range[1], newRange[1]);
2548	          break;
2549	        }
2550	      }
2551	      if (i === l) ranges.push(newRange);
2552	      return ranges;
2553	    }
2554	    var sortDirection = ascending;
2555	    function rangeSorter(a, b) {
2556	      return sortDirection(a[0], b[0]);
2557	    }
2558	    var set;
2559	    try {
2560	      set = ranges.reduce(addRange, []);
2561	      set.sort(rangeSorter);
2562	    } catch (ex) {
2563	      return fail(this, INVALID_KEY_ARGUMENT);
2564	    }
2565	    var rangePos = 0;
2566	    var keyIsBeyondCurrentEntry = includeUppers ? function (key) {
2567	      return ascending(key, set[rangePos][1]) > 0;
2568	    } : function (key) {
2569	      return ascending(key, set[rangePos][1]) >= 0;
2570	    };
2571	    var keyIsBeforeCurrentEntry = includeLowers ? function (key) {
2572	      return descending(key, set[rangePos][0]) > 0;
2573	    } : function (key) {
2574	      return descending(key, set[rangePos][0]) >= 0;
2575	    };
2576	    function keyWithinCurrentRange(key) {
2577	      return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key);
2578	    }
2579	    var checkKey = keyIsBeyondCurrentEntry;
2580	    var c = new this.Collection(this, function () {
2581	      return createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers);
2582	    });
2583	    c._ondirectionchange = function (direction) {
2584	      if (direction === "next") {
2585	        checkKey = keyIsBeyondCurrentEntry;
2586	        sortDirection = ascending;
2587	      } else {
2588	        checkKey = keyIsBeforeCurrentEntry;
2589	        sortDirection = descending;
2590	      }

2591	      set.sort(rangeSorter);
2592	    };
2593	    c._addAlgorithm(function (cursor, advance, resolve) {
2594	      var key = cursor.key;
2595	      while (checkKey(key)) {
2596	        ++rangePos;
2597	        if (rangePos === set.length) {
2598	          advance(resolve);
2599	          return false;
2600	        }
2601	      }
2602	      if (keyWithinCurrentRange(key)) {
2603	        return true;
2604	      } else if (_this._cmp(key, set[rangePos][1]) === 0 || _this._cmp(key, set[rangePos][0]) === 0) {
2605	        return false;
2606	      } else {
2607	        advance(function () {
2608	          if (sortDirection === ascending) cursor["continue"](set[rangePos][0]);else cursor["continue"](set[rangePos][1]);
2609	        });
2610	        return false;
2611	      }
2612	    });
2613	    return c;
2614	  };
2615	  WhereClause.prototype.startsWithAnyOf = function () {
2616	    var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments);
2617	    if (!set.every(function (s) {
2618	      return typeof s === 'string';
2619	    })) {
2620	      return fail(this, "startsWithAnyOf() only works with strings");
2621	    }
2622	    if (set.length === 0) return emptyCollection(this);
2623	    return this.inAnyRange(set.map(function (str) {
2624	      return [str, str + maxString];
2625	    }));
2626	  };
2627	  return WhereClause;
2628	}();
2629	function createWhereClauseConstructor(db) {
2630	  return makeClassConstructor(WhereClause.prototype, function WhereClause(table, index, orCollection) {
2631	    this.db = db;
2632	    this._ctx = {
2633	      table: table,
2634	      index: index === ":id" ? null : index,
2635	      or: orCollection
2636	    };
2637	    var indexedDB = db._deps.indexedDB;
2638	    if (!indexedDB) throw new exceptions.MissingAPI();
2639	    this._cmp = this._ascending = indexedDB.cmp.bind(indexedDB);
2640	    this._descending = function (a, b) {
2641	      return indexedDB.cmp(b, a);
2642	    };
2643	    this._max = function (a, b) {
2644	      return indexedDB.cmp(a, b) > 0 ? a : b;
2645	    };
2646	    this._min = function (a, b) {
2647	      return indexedDB.cmp(a, b) < 0 ? a : b;
2648	    };
2649	    this._IDBKeyRange = db._deps.IDBKeyRange;
2650	  });
2651	}
2652	function eventRejectHandler(reject) {
2653	  return wrap(function (event) {
2654	    preventDefault(event);
2655	    reject(event.target.error);
2656	    return false;
2657	  });
2658	}
2659	function preventDefault(event) {
2660	  if (event.stopPropagation) event.stopPropagation();
2661	  if (event.preventDefault) event.preventDefault();
2662	}
2663	var DEXIE_STORAGE_MUTATED_EVENT_NAME = 'storagemutated';
2664	var STORAGE_MUTATED_DOM_EVENT_NAME = 'x-storagemutated-1';
2665	var globalEvents = Events(null, DEXIE_STORAGE_MUTATED_EVENT_NAME);
2666	var Transaction = function () {
2667	  function Transaction() {}
2668	  Transaction.prototype._lock = function () {
2669	    assert(!PSD.global);
2670	    ++this._reculock;
2671	    if (this._reculock === 1 && !PSD.global) PSD.lockOwnerFor = this;
2672	    return this;
2673	  };
2674	  Transaction.prototype._unlock = function () {
2675	    assert(!PSD.global);
2676	    if (--this._reculock === 0) {
2677	      if (!PSD.global) PSD.lockOwnerFor = null;
2678	      while (this._blockedFuncs.length > 0 && !this._locked()) {
2679	        var fnAndPSD = this._blockedFuncs.shift();
2680	        try {
2681	          usePSD(fnAndPSD[1], fnAndPSD[0]);
2682	        } catch (e) {}
2683	      }
2684	    }
2685	    return this;
2686	  };
2687	  Transaction.prototype._locked = function () {
2688	    return this._reculock && PSD.lockOwnerFor !== this;
2689	  };
2690	  Transaction.prototype.create = function (idbtrans) {
2691	    var _this = this;
2692	    if (!this.mode) return this;
2693	    var idbdb = this.db.idbdb;
2694	    var dbOpenError = this.db._state.dbOpenError;
2695	    assert(!this.idbtrans);
2696	    if (!idbtrans && !idbdb) {
2697	      switch (dbOpenError && dbOpenError.name) {
2698	        case "DatabaseClosedError":
2699	          throw new exceptions.DatabaseClosed(dbOpenError);
2700	        case "MissingAPIError":
2701	          throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError);
2702	        default:
2703	          throw new exceptions.OpenFailed(dbOpenError);
2704	      }
2705	    }
2706	    if (!this.active) throw new exceptions.TransactionInactive();
2707	    assert(this._completion._state === null);
2708	    idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, {
2709	      durability: this.chromeTransactionDurability
2710	    }) : idbdb.transaction(this.storeNames, this.mode, {
2711	      durability: this.chromeTransactionDurability
2712	    }));
2713	    idbtrans.onerror = wrap(function (ev) {
2714	      preventDefault(ev);
2715	      _this._reject(idbtrans.error);
2716	    });
2717	    idbtrans.onabort = wrap(function (ev) {
2718	      preventDefault(ev);
2719	      _this.active && _this._reject(new exceptions.Abort(idbtrans.error));
2720	      _this.active = false;